Commit c2487692e6d51da16194cd38ba2b42f095ee7594 | markodown

author	clover caruso <git@paperclover.net> 2026-02-17 00:42:05-08:00
committer	clover caruso <git@paperclover.net> 2026-02-18 02:46:06-08:00
log	c2487692e6d51da16194cd38ba2b42f095ee7594
tree	c6977c291b145699061208614582e03305a9cf1e
parent	e8d9aa0ccc17ba1add4757022b7121d0f731858c
signature	Signed by SSH key SHA256:xbd+BjjhyBfwk7GVoURf9Yx0gzDerHbvYv7SddNWmAs

chore: fork markdown-it to fix a bug

106 files changed, 36030 insertions(+), 13 deletions(-)

ARCHITECTURE.md+9-2

 @@ -1,16 +1,23 @@
 # architecture
+markodown is implemented in rust using a fork of the markdown-it-rust create. we
+fork it because they are unmaintained and we have hit bugs. the rust codebase is
+compiled to wasm and then shipped as an NPM/JSR package for use in the web
+ecosystem.
 ## `src/`: rust code
 the rust code in `src` implements most of markodown. it exports a cli for
-testing. most of the tests are on the rust code
+testing. most of the tests are on the rust code. here are the relevant files
 - `src/lib.rs` - main library, primary function `transform`
-- `src/main.rs` - main cli
+  - `src/wasm.rs` - binding for WASM
+- `src/main.rs` - testing cli
 - `src/typescript.rs` - wrappers around oxc parser to expose parsers for
   different subsets of the ast, including a much more garbage-forgiving
   expression parser.
 - `src/marko.rs` - general marko tag parser
+  - `src/marko_ast.rs` - ast structure for the marko parser
 - `src/plugin/` - `markdown-it` plugin and all rules
 markdown-it does not support failiable plugins, so instead errors are lowered

Cargo.lock+1-10

 @@ -82,12 +82,6 @@ dependencies = [
  "object",
 ]
-[[package]]
-name = "argparse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f8ebf5827e4ac4fd5946560e6a99776ea73b596d80898f357007317a7141e47"
 [[package]]
 name = "autocfg"
 version = "1.5.0"
 @@ -379,11 +373,8 @@ dependencies = [
 [[package]]
 name = "markdown-it"
-version = "0.6.1"
+version = "0.6.1-patched"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f99c010929c8217b2dc0940954267a2e15a15f17cb309cd1f299e21933f84fac"
 dependencies = [
- "argparse",
  "const_format",
  "derivative",
  "derive_more",

Cargo.toml+5-1

...	@@ -8,7 +8,7 @@ crate-type = ["cdylib", "rlib"]	...	@@ -8,7 +8,7 @@ crate-type = ["cdylib", "rlib"]
8	[dependencies]	8	[dependencies]
9	serde = { version = "1.0", features = ["derive"] }	9	serde = { version = "1.0", features = ["derive"] }
10	clap = { version = "4.5.57", features = ["derive"] }	10	clap = { version = "4.5.57", features = ["derive"] }
11	markdown-it = { version = "0.6.1", default-features = false, features = ["linkify"] }	11	markdown-it = { path = "crates/markdown-it", default-features = false, features = ["linkify"] }
12	oxc_allocator = "0.96.0"	12	oxc_allocator = "0.96.0"
13	oxc_ast = "0.96.0"	13	oxc_ast = "0.96.0"
14	oxc_diagnostics = "0.96.0"	14	oxc_diagnostics = "0.96.0"
...	@@ -18,3 +18,7 @@ serde_json = "1.0"	...	@@ -18,3 +18,7 @@ serde_json = "1.0"
18	serde_yml = "0.0.12"	18	serde_yml = "0.0.12"
19	wasm-bindgen = { version = "0.2" }	19	wasm-bindgen = { version = "0.2" }
20	serde-wasm-bindgen = "0.6.5"	20	serde-wasm-bindgen = "0.6.5"
		21
		22	[workspace]
		23	members = [".", "crates/markdown-it"]
		24	resolver = "2"

crates/markdown-it/Cargo.toml created+35

...	@@ -0,0 +1,35 @@
1	[package]
2	name = "markdown-it"
3	version = "0.6.1-patched"
4	authors = ["Alex Kocharin <alex@kocharin.ru>"]
5	description = "Rust port of popular markdown-it.js library."
6	homepage = "https://github.com/markdown-it-rust/markdown-it"
7	repository = "https://github.com/markdown-it-rust/markdown-it"
8	readme = "README.md"
9	keywords = ["markdown", "commonmark"]
10	license = "MIT"
11	categories = ["text-processing", "parsing"]
12	edition = "2021"
13
14	[lib]
15	name = "markdown_it"
16	path = "src/lib.rs"
17
18	[features]
19	default = ["linkify"]
20	syntect = []
21
22	[dependencies]
23	const_format = ">= 0.1.0, < 0.3"
24	derivative = ">= 1.0.2, < 3"
25	derive_more = ">= 0.99.0, < 1"
26	downcast-rs = ">= 1.0.2, < 2"
27	entities = ">= 0.1.0, < 2"
28	html-escape = ">= 0.1.0, < 0.3"
29	linkify = { version = ">= 0.5.0, < 0.11", optional = true }
30	mdurl = ">= 0.3.1, < 0.4"
31	once_cell = ">= 1.0.1, < 2"
32	readonly = ">= 0.2.0, < 0.3"
33	regex = ">= 1.0.0, < 2"
34	stacker = ">= 0.1.2, < 0.2"
35	unicode-general-category = ">= 0.1.0, < 0.7"

crates/markdown-it/LICENSE created+28

...	@@ -0,0 +1,28 @@
1	The MIT License
2
3	Rust port https://github.com/rlidwka/markdown-it.rs:
4	Copyright (c) 2022 Alex Kocharin.
5
6	Original library https://github.com/markdown-it/markdown-it:
7	Copyright (c) 2014 Vitaly Puzrin, Alex Kocharin.
8
9	Permission is hereby granted, free of charge, to any person
10	obtaining a copy of this software and associated documentation
11	files (the "Software"), to deal in the Software without
12	restriction, including without limitation the rights to use,
13	copy, modify, merge, publish, distribute, sublicense, and/or sell
14	copies of the Software, and to permit persons to whom the
15	Software is furnished to do so, subject to the following
16	conditions:
17
18	The above copyright notice and this permission notice shall be
19	included in all copies or substantial portions of the Software.
20
21	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
23	OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
25	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
26	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
28	OTHER DEALINGS IN THE SOFTWARE.

crates/markdown-it/README.md created+32

...	@@ -0,0 +1,32 @@
1	# markdown-it
2
3	This directory holds a fork of the unmaintained markdown-it-rust package.
4	Markodown forks this package to make bug fixes to its core CommonMark
5	implementation.
6
7	Rust port of popular
8	[markdown-it.js](https://github.com/markdown-it/markdown-it) library.
9
10	### Features
11
12	- 100% CommonMark compatibility
13	- AST
14	- Source maps (full support, not just on block tags like cmark)
15	- Ability to write your own syntax of arbitrary complexity
16	- to prove this point, CommonMark syntax itself is written as a plugin
17
18	### Usage
19
20	```rust
21	let parser = &mut markdown_it::MarkdownIt::new();
22	markdown_it::plugins::cmark::add(parser);
23	markdown_it::plugins::extra::add(parser);
24
25	let ast = parser.parse("Hello world!");
26	let html = ast.render();
27
28	print!("{html}");
29	// prints "<p>Hello <strong>world</strong>!</p>"
30	```
31
32	For a guide on how to extend it, see `examples` folder.

crates/markdown-it/examples/ferris/README.md created+21

...	@@ -0,0 +1,21 @@
1	This is an example of how you can make your own plugins in markdown-it.
2
3	### What is it
4
5	There are 3 different plugins here:
6
7	- inline rule - turns `(\/)` into `🦀` in inline context (i.e. inside other text)
8
9	- block rule - turns `(\/)-------(\/)` into
10	[ferris.svg](https://upload.wikimedia.org/wikipedia/commons/0/0f/Original_Ferris.svg)
11	in block context (i.e. it has to occupy the entire line)
12
13	- core rule - counts the number of nodes created by the above two plugins and writes
14	that number at the end of the document
15
16	It represents three stages of markdown processing (block elements, inline elements
17	and AST post-processing).
18
19	### How to use
20
21	`cargo run --example ferris`

crates/markdown-it/examples/ferris/block_rule.rs created+72

...	@@ -0,0 +1,72 @@
1	// Replaces `(\/)-------(\/)` with a nice picture.
2
3	use markdown_it::parser::block::{BlockRule, BlockState};
4	use markdown_it::{MarkdownIt, Node, NodeValue, Renderer};
5
6	const CRAB_CLAW : &str = r#"(\/)"#;
7	const CRAB_URL : &str = "https://upload.wikimedia.org/wikipedia/commons/0/0f/Original_Ferris.svg";
8
9	#[derive(Debug)]
10	// This is a structure that represents your custom Node in AST.
11	pub struct BlockFerris;
12
13	impl NodeValue for BlockFerris {
14	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
15	// build attributes for `div`
16	let mut attrs_div = node.attrs.clone();
17	attrs_div.push(("class", "ferris-block".into()));
18
19	// build attributes for `img`
20	let attrs_img = vec![("src", CRAB_URL.into())];
21
22	fmt.cr(); // linebreak, multiples get merged
23	fmt.open("div", &attrs_div); // opening tag, `<div>`
24	fmt.self_close("img", &attrs_img); // `<img>`
25	fmt.close("div"); // closing tag, `</div>`
26	fmt.cr();
27	}
28	}
29
30	// This is an extension for the block subparser.
31	struct FerrisBlockScanner;
32
33	impl BlockRule for FerrisBlockScanner {
34	// This is a custom function that will be invoked on every line
35	// in a block context.
36	//
37	// It should get a line number `state.line` and report if your
38	// custom structure appears there.
39	//
40	// If custom structure is found, it:
41	// - creates a new `Node` in AST
42	// - increments `state.line` to a position after this node
43	// - returns true
44	//
45	// In "silent mode" (when `silent=true`) you aren't allowed to
46	// create any nodes, should only increment `state.line`.
47	//
48	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
49	// get contents of a line number `state.line` and check it
50	let line = state.get_line(state.line).trim();
51	if !line.starts_with(CRAB_CLAW) { return None; }
52	if !line.ends_with(CRAB_CLAW) { return None; }
53
54	// require any number of `-` in between, but no less than 4
55	if line.len() < CRAB_CLAW.len() * 2 + 4 { return None; }
56
57	// and make sure no other characters are present there
58	let dashes = &line[CRAB_CLAW.len()..line.len()-CRAB_CLAW.len()];
59	if dashes.chars().any(\|c\| c != '-') { return None; }
60
61	// return new node and number of lines it occupies
62	Some((
63	Node::new(BlockFerris),
64	1,
65	))
66	}
67	}
68
69	pub fn add(md: &mut MarkdownIt) {
70	// insert this rule into block subparser
71	md.block.add_rule::<FerrisBlockScanner>();
72	}

crates/markdown-it/examples/ferris/core_rule.rs created+64

...	@@ -0,0 +1,64 @@
1	// Counts the number of crabs lurking around.
2
3	use super::block_rule::BlockFerris;
4	use super::inline_rule::InlineFerris;
5	use markdown_it::parser::core::CoreRule;
6	use markdown_it::{MarkdownIt, Node, NodeValue, Renderer};
7
8	#[derive(Debug)]
9	// This is a structure that represents your custom Node in AST,
10	// it has one single argument - crab counter.
11	pub struct FerrisCounter(usize);
12
13	// This defines how your custom node should be rendered.
14	impl NodeValue for FerrisCounter {
15	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
16	// `node.attrs` are custom attributes added by other plugins
17	// (for example, source mapping information)
18	let mut attrs = node.attrs.clone();
19
20	// add a custom class attribute
21	attrs.push(("class", "ferris-counter".into()));
22
23	fmt.cr(); // linebreak, multiples get merged
24	fmt.open("footer", &attrs);
25	#[allow(clippy::useless_format)] // for simplicity's sake
26	fmt.text(&match self.0 {
27	0 => format!("No crabs around here."),
28	1 => format!("There is a crab lurking in this document."),
29	_ => format!("There are {} crabs lurking in this document.", self.0),
30	});
31	fmt.close("footer");
32	fmt.cr();
33	}
34	}
35
36	// This is an extension for the markdown parser.
37	struct FerrisCounterRule;
38
39	impl CoreRule for FerrisCounterRule {
40	// This is a custom function that will be invoked once per document.
41	//
42	// It has `root` node of the AST as an argument and may modify its
43	// contents as you like.
44	//
45	fn run(root: &mut Node, _: &MarkdownIt) {
46	let mut counter = 0;
47
48	// walk through AST recursively and count the number of two
49	// custom nodes added by other two rules
50	root.walk(\|node, _\| {
51	if node.is::<InlineFerris>() \|\| node.is::<BlockFerris>() {
52	counter += 1;
53	}
54	});
55
56	// append a counter to the root as a custom node
57	root.children.push(Node::new(FerrisCounter(counter)))
58	}
59	}
60
61	pub fn add(md: &mut MarkdownIt) {
62	// insert this rule into parser
63	md.add_rule::<FerrisCounterRule>();
64	}

crates/markdown-it/examples/ferris/inline_rule.rs created+61

...	@@ -0,0 +1,61 @@
1	// Replaces `(\/)` with `🦀`.
2
3	use markdown_it::parser::inline::{InlineRule, InlineState};
4	use markdown_it::{MarkdownIt, Node, NodeValue, Renderer};
5
6	const CRAB_CLAW : &str = r#"(\/)"#;
7
8	#[derive(Debug)]
9	// This is a structure that represents your custom Node in AST.
10	pub struct InlineFerris;
11
12	// This defines how your custom node should be rendered.
13	impl NodeValue for InlineFerris {
14	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
15	// `node.attrs` are custom attributes added by other plugins
16	// (for example, source mapping information)
17	let mut attrs = node.attrs.clone();
18
19	// add a custom class attribute
20	attrs.push(("class", "ferris-inline".into()));
21
22	fmt.open("span", &attrs);
23	fmt.text("🦀");
24	fmt.close("span");
25	}
26	}
27
28	// This is an extension for the inline subparser.
29	struct FerrisInlineScanner;
30
31	impl InlineRule for FerrisInlineScanner {
32	// This is a character that starts your custom structure
33	// (other characters may get skipped over).
34	const MARKER: char = '(';
35
36	// This is a custom function that will be invoked on every character
37	// in an inline context.
38	//
39	// It should look for `state.src` exactly at position `state.pos`
40	// and report if your custom structure appears there.
41	//
42	// If custom structure is found, it:
43	// - creates a new `Node` in AST
44	// - returns length of it
45	//
46	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
47	let input = &state.src[state.pos..state.pos_max]; // look for stuff at state.pos
48	if !input.starts_with(CRAB_CLAW) { return None; } // return None if it's not found
49
50	// return new node and length of this structure
51	Some((
52	Node::new(InlineFerris),
53	CRAB_CLAW.len(),
54	))
55	}
56	}
57
58	pub fn add(md: &mut MarkdownIt) {
59	// insert this rule into inline subparser
60	md.inline.add_rule::<FerrisInlineScanner>();
61	}

crates/markdown-it/examples/ferris/main.rs created+31

...	@@ -0,0 +1,31 @@
1	// Adds three custom plugins and runs them.
2	mod block_rule;
3	mod core_rule;
4	mod inline_rule;
5
6	fn main() {
7	// create markdown parser
8	let md = &mut markdown_it::MarkdownIt::new();
9
10	// add commonmark syntax, you almost always want to do that
11	markdown_it::plugins::cmark::add(md);
12
13	// add custom three rules described above
14	inline_rule::add(md);
15	block_rule::add(md);
16	core_rule::add(md);
17
18	// and now you can use it
19	let html = md.parse(r#"
20	(\/) hello world (\/)
21	(\/)-------------(\/)
22	"#).render();
23
24	print!("{html}");
25
26	assert_eq!(html.trim(), r#"
27	<p><span class="ferris-inline">🦀</span> hello world <span class="ferris-inline">🦀</span></p>
28	<div class="ferris-block"><img src="https://upload.wikimedia.org/wikipedia/commons/0/0f/Original_Ferris.svg"></div>
29	<footer class="ferris-counter">There are 3 crabs lurking in this document.</footer>
30	"#.trim());
31	}

crates/markdown-it/src/common/mod.rs created+11

...	@@ -0,0 +1,11 @@
1	//! Self-contained modules used for miscellaneous purposes.
2	//!
3	//! These are all candidates for being separated into different crates,
4	//! tell me if functionality they provide is useful enough to do that.
5
6	pub mod ruler;
7	pub mod sourcemap;
8	pub mod utils;
9
10	mod typekey;
11	pub use typekey::TypeKey;

crates/markdown-it/src/common/ruler.rs created+393

...	@@ -0,0 +1,393 @@
1	//! Plugin manager with dependency resolution.
2
3	use derivative::Derivative;
4	use once_cell::sync::OnceCell;
5	use std::collections::{HashMap, HashSet};
6	use std::fmt::Debug;
7	use std::hash::Hash;
8	use std::slice::Iter;
9
10	///
11	/// Ruler allows you to implement a plugin system with dependency management and ensure that
12	/// your dependencies are called in the correct order.
13	///
14	/// You can use it like this:
15	/// ```
16	/// use markdown_it::common::ruler::Ruler;
17	///
18	/// // this example prints "[ hello, world! ]",
19	/// // where each token is printed by separate closure
20	/// let mut chain = Ruler::<&str, fn (&mut String)>::new();
21	///
22	/// // define rules printing "hello" and "world"
23	/// chain.add("hello", \|s\| s.push_str("hello"));
24	/// chain.add("world", \|s\| s.push_str("world"));
25	///
26	/// // open bracket should be before "hello", and closing one after "world"
27	/// chain.add("open_bracket", \|s\| s.push_str("[ ")).before("hello");
28	/// chain.add("close_bracket", \|s\| s.push_str(" ]")).after("world");
29	///
30	/// // between "hello" and "world" we shall have a comma
31	/// chain.add("comma", \|s\| s.push_str(", ")).after("hello").before("world");
32	///
33	/// // after "world" we should have "!" as a first rule, but ensure "world" exists first
34	/// chain.add("bang", \|s\| s.push_str("!")).require("world").after("world").before_all();
35	///
36	/// // now we run this chain
37	/// let mut result = String::new();
38	/// for f in chain.iter() { f(&mut result); }
39	/// assert_eq!(result, "[ hello, world! ]");
40	/// ```
41	///
42	/// This data structure contains any number of elements (M, T), where T is any type and
43	/// M (mark) is its identifier.
44	///
45	/// - `M` is used for ordering and dependency checking, it must implement `Eq + Copy + Hash + Debug`
46	/// . Common choices for `M` are `u32`, `&'static str`, or a special `Symbol` type
47	/// designed for this purpose.
48	///
49	/// - `T` is any user-defined type. It's usually a function or boxed trait.
50	///
51	pub struct Ruler<M, T> {
52	deps: Vec<RuleItem<M, T>>,
53	compiled: OnceCell<(Vec<usize>, Vec<T>)>,
54	}
55
56	impl<M, T> Ruler<M, T> {
57	pub fn new() -> Self {
58	Self::default()
59	}
60	}
61
62	impl<M: Eq + Hash + Copy + Debug, T: Clone> Ruler<M, T> {
63	/// Add a new rule identified by `mark` with payload `value`.
64	pub fn add(&mut self, mark: M, value: T) -> &mut RuleItem<M, T> {
65	self.compiled = OnceCell::new();
66	let dep = RuleItem::new(mark, value);
67	self.deps.push(dep);
68	self.deps.last_mut().unwrap()
69	}
70
71	/// Remove all rules identified by `mark`.
72	pub fn remove(&mut self, mark: M) {
73	self.deps.retain(\|dep\| !dep.marks.contains(&mark));
74	}
75
76	/// Check if there are any rules identified by `mark`.
77	pub fn contains(&mut self, mark: M) -> bool {
78	self.deps.iter().any(\|dep\| dep.marks.contains(&mark))
79	}
80
81	/// Ordered iteration through rules.
82	#[inline]
83	pub fn iter(&self) -> Iter<T> {
84	self.compiled.get_or_init(\|\| self.compile()).1.iter()
85	}
86
87	fn compile(&self) -> (Vec<usize>, Vec<T>) {
88	// ID -> [RuleItem index]
89	let mut idhash = HashMap::<M, Vec<usize>>::new();
90
91	// RuleItem index -> [RuleItem index] - dependency graph, None if already inserted
92	let mut deps_graph = vec![HashSet::new(); self.deps.len()];
93
94	// additional level of indirection that takes into account item priority
95	let mut deps_order = vec![];
96	let mut beforeall_len = 0;
97	let mut afterall_len = 0;
98
99	// compiled result
100	let mut result = vec![];
101	let mut result_idx = vec![];
102
103	// track which rules have been added already
104	let mut deps_inserted = vec![false; self.deps.len()];
105	let mut deps_remaining = self.deps.len();
106
107	for (idx, dep) in self.deps.iter().enumerate() {
108	match dep.prio {
109	RuleItemPriority::Normal => {
110	deps_order.insert(deps_order.len() - afterall_len, idx);
111	}
112	RuleItemPriority::BeforeAll => {
113	deps_order.insert(beforeall_len, idx);
114	beforeall_len += 1;
115	}
116	RuleItemPriority::AfterAll => {
117	deps_order.insert(deps_order.len(), idx);
118	afterall_len += 1;
119	}
120	}
121	for mark in &dep.marks {
122	idhash.entry(*mark).or_default().push(idx);
123	}
124	}
125
126	// build dependency graph, replacing all after's with before's,
127	// i.e. B.after(A) -> A.before(B)
128	for idx in deps_order.iter().copied() {
129	let dep = self.deps.get(idx).unwrap();
130	for constraint in &dep.cons {
131	match constraint {
132	RuleItemConstraint::Before(v) => {
133	for depidx in idhash.entry(*v).or_default().iter() {
134	deps_graph.get_mut(*depidx).unwrap().insert(idx);
135	}
136	}
137	RuleItemConstraint::After(v) => {
138	for depidx in idhash.entry(*v).or_default().iter() {
139	deps_graph.get_mut(idx).unwrap().insert(*depidx);
140	}
141	}
142	RuleItemConstraint::Require(v) => {
143	assert!(
144	idhash.contains_key(v),
145	"missing dependency: {:?} requires {:?}", dep.marks.first().unwrap(), v
146	);
147	}
148	}
149	}
150	}
151
152	// now go through the deps and push whatever doesn't have any
153	'outer: while deps_remaining > 0 {
154	for idx in deps_order.iter().copied() {
155	let inserted = deps_inserted.get_mut(idx).unwrap();
156	if *inserted { continue; }
157
158	let dlist = deps_graph.get(idx).unwrap();
159	if dlist.is_empty() {
160	let dep = self.deps.get(idx).unwrap();
161	result.push(dep.value.clone());
162	result_idx.push(idx);
163	*inserted = true;
164	deps_remaining -= 1;
165	for d in deps_graph.iter_mut() {
166	d.remove(&idx);
167	}
168	continue 'outer;
169	}
170	}
171
172	#[cfg(debug_assertions)] {
173	// check cycles in dependency graph;
174	// this is very suboptimal, but only used to generate a nice panic message.
175	// in release mode we'll just simply panic
176	for idx in deps_order.iter().copied() {
177	let mut seen = HashMap::new();
178	let mut vec = vec![idx];
179	while let Some(didx) = vec.pop() {
180	let dlist = deps_graph.get(didx).unwrap();
181	for x in dlist.iter() {
182	if seen.contains_key(x) { continue; }
183	vec.push(*x);
184	seen.insert(*x, didx);
185	if *x == idx {
186	let mut backtrack = vec![];
187	let mut curr = idx;
188	while !backtrack.contains(&curr) {
189	backtrack.push(curr);
190	curr = *seen.get(&curr).unwrap();
191	}
192	backtrack.push(curr);
193	let path = backtrack.iter()
194	.rev()
195	.map(\|x\| format!("{:?}", self.deps.get(*x).unwrap().marks.first().unwrap()))
196	.collect::<Vec<String>>()
197	.join(" < ");
198	panic!("cyclic dependency: {}", path);
199	}
200	}
201	}
202	}
203	}
204
205	// if you see this in debug mode, report it as a bug
206	panic!("cyclic dependency: (use debug mode for more details)");
207	}
208
209	(result_idx, result)
210	}
211	}
212
213	impl<M: Eq + Hash + Copy + Debug, T: Clone> Debug for Ruler<M, T> {
214	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
215	let vec: Vec<(usize, M)> = self.compiled.get_or_init(\|\| self.compile()).0
216	.iter()
217	.map(\|idx\| (idx, self.deps.get(*idx).unwrap().marks.first().unwrap()))
218	.collect();
219
220	f.debug_struct("Ruler")
221	.field("deps", &self.deps)
222	.field("compiled", &vec)
223	.finish()
224	}
225	}
226
227	impl<M, T> Default for Ruler<M, T> {
228	fn default() -> Self {
229	Self {
230	deps: Vec::new(),
231	compiled: OnceCell::new(),
232	}
233	}
234	}
235
236	///
237	/// Result of [Ruler::add](Ruler::add), allows to customize position of each rule.
238	///
239	#[derive(Derivative)]
240	#[derivative(Debug)]
241	pub struct RuleItem<M, T> {
242	marks: Vec<M>,
243	#[derivative(Debug="ignore")]
244	value: T,
245	prio: RuleItemPriority,
246	cons: Vec<RuleItemConstraint<M>>,
247	}
248
249	impl<M, T> RuleItem<M, T> {
250	fn new(mark: M, value: T) -> Self {
251	Self {
252	marks: vec![mark],
253	value,
254	prio: RuleItemPriority::Normal,
255	cons: vec![],
256	}
257	}
258	}
259
260	impl<M: Copy, T> RuleItem<M, T> {
261	/// Make sure this rule will be inserted before any rule defined by `mark` (if such rule exists).
262	/// ```
263	/// use markdown_it::common::ruler::Ruler;
264	/// let mut chain = Ruler::<&str, fn (&mut String)>::new();
265	///
266	/// chain.add("a", \|s\| s.push_str("bar"));
267	/// chain.add("b", \|s\| s.push_str("foo")).before("a");
268	///
269	/// let mut result = String::new();
270	/// for f in chain.iter() { f(&mut result); }
271	/// assert_eq!(result, "foobar");
272	/// ```
273	pub fn before(&mut self, mark: M) -> &mut Self {
274	self.cons.push(RuleItemConstraint::Before(mark));
275	self
276	}
277
278	/// Make sure this rule will be inserted after any rule defined by `mark` (if such rule exists).
279	/// Similar to [RuleItem::before](RuleItem::before).
280	pub fn after(&mut self, mark: M) -> &mut Self {
281	self.cons.push(RuleItemConstraint::After(mark));
282	self
283	}
284
285	/// This rule will be inserted as early as possible, while still taking into account dependencies,
286	/// i.e. `.after(X).before_all()` causes this to be first rule after X.
287	/// ```
288	/// use markdown_it::common::ruler::Ruler;
289	/// let mut chain = Ruler::<&str, fn (&mut String)>::new();
290	///
291	/// chain.add("a", \|s\| s.push_str("A"));
292	/// chain.add("c", \|s\| s.push_str("C")).after("a");
293	/// chain.add("b", \|s\| s.push_str("B")).after("a").before_all();
294	///
295	/// let mut result = String::new();
296	/// for f in chain.iter() { f(&mut result); }
297	/// // without before_all order will be ACB
298	/// assert_eq!(result, "ABC");
299	/// ```
300	pub fn before_all(&mut self) -> &mut Self {
301	self.prio = RuleItemPriority::BeforeAll;
302	self
303	}
304
305	/// This rule will be inserted as late as possible, while still taking into account dependencies,
306	/// i.e. `.before(X).after_all()` causes this to be last rule before X.
307	/// Similar to [RuleItem::before_all](RuleItem::before_all).
308	pub fn after_all(&mut self) -> &mut Self {
309	self.prio = RuleItemPriority::AfterAll;
310	self
311	}
312
313	/// Add another auxiliary identifier to this rule. It can be used to group together multiple
314	/// rules with similar functionality.
315	/// ```
316	/// use markdown_it::common::ruler::Ruler;
317	/// let mut chain = Ruler::<&str, fn (&mut String)>::new();
318	///
319	/// chain.add("b", \|s\| s.push_str("B")).alias("BorC");
320	/// chain.add("c", \|s\| s.push_str("C")).alias("BorC");
321	/// chain.add("a", \|s\| s.push_str("A")).before("BorC");
322	///
323	/// let mut result = String::new();
324	/// for f in chain.iter() { f(&mut result); }
325	/// assert_eq!(result, "ABC");
326	/// ```
327	pub fn alias(&mut self, mark: M) -> &mut Self {
328	self.marks.push(mark);
329	self
330	}
331
332	/// Require another rule identified by `mark`, panic if not found.
333	pub fn require(&mut self, mark: M) -> &mut Self {
334	self.cons.push(RuleItemConstraint::Require(mark));
335	self
336	}
337	}
338
339	#[derive(Debug)]
340	enum RuleItemConstraint<M> {
341	Before(M),
342	After(M),
343	Require(M),
344	}
345
346	#[derive(Debug)]
347	enum RuleItemPriority {
348	Normal,
349	BeforeAll,
350	AfterAll,
351	}
352
353
354	#[cfg(test)]
355	mod tests {
356	use super::Ruler;
357
358	#[test]
359	#[should_panic(expected=r#"cyclic dependency: "A" < "B" < "C" < "D" < "E" < "F" < "A""#)]
360	#[cfg(debug_assertions)]
361	fn cyclic_dependency_debug() {
362	let mut r = Ruler::new();
363	r.add("%", ()).after("D");
364	r.add("A", ()).after("B");
365	r.add("E", ()).after("F");
366	r.add("C", ()).after("D");
367	r.add("B", ()).after("C");
368	r.add("D", ()).after("E");
369	r.add("F", ()).after("A");
370	r.compile();
371	}
372
373	#[test]
374	#[should_panic(expected=r#"cyclic dependency"#)]
375	fn cyclic_dependency() {
376	let mut r = Ruler::new();
377	r.add("A", ()).after("B");
378	r.add("B", ()).after("C");
379	r.add("C", ()).after("A");
380	r.compile();
381	}
382
383
384	#[test]
385	#[should_panic(expected=r#"missing dependency: "C" requires "Z"#)]
386	fn missing_require() {
387	let mut r = Ruler::new();
388	r.add("A", ());
389	r.add("B", ()).require("A");
390	r.add("C", ()).require("Z");
391	r.compile();
392	}
393	}

crates/markdown-it/src/common/sourcemap.rs created+143

...	@@ -0,0 +1,143 @@
1	//! Tools to work with source positions and mapping.
2
3	#[derive(Debug)]
4	/// Holds source code, allows to calculate `line:column` from byte offset.
5	pub struct SourceWithLineStarts {
6	src: String,
7	marks: Vec<CharMappingMark>,
8	}
9
10	impl SourceWithLineStarts {
11	pub fn new(src: &str) -> Self {
12	let mut iterator = src.char_indices().peekable();
13	let mut line = 1;
14	let mut column = 0;
15	let mut marks = vec![CharMappingMark { offset: 0, line, column }];
16
17	loop {
18	match iterator.next() {
19	Some((_, '\r')) if matches!(iterator.peek(), Some((_, '\n'))) => {
20	// ignore \r followed by \n
21	column += 1;
22	}
23	Some((offset, '\r' \| '\n')) => {
24	// \r or \n are linebreaks
25	line += 1;
26	column = 0;
27	marks.push(CharMappingMark { offset: offset + 1, line, column });
28	}
29	Some((offset, _)) => {
30	// any other character, just increase position
31	if column % 16 == 0 && column > 0 {
32	marks.push(CharMappingMark { offset, line, column });
33	}
34	column += 1;
35	},
36	None => break,
37	}
38	}
39
40	Self { src: src.to_owned(), marks }
41	}
42
43	fn get_position(&self, byte_offset: usize) -> (u32, u32) {
44	let byte_offset = byte_offset + 1; // include current char
45	let found = match self.marks.binary_search_by(\|mark\| mark.offset.cmp(&byte_offset)) {
46	Ok(x) => x,
47	Err(x) => x - 1,
48	};
49	let mark = &self.marks[found];
50	let line = mark.line;
51	let mut column = mark.column;
52	for (offset, _) in self.src[mark.offset..].char_indices() {
53	if mark.offset + offset >= byte_offset { break; }
54	column += 1;
55	}
56	(line, column)
57	}
58	}
59
60	#[derive(Debug)]
61	struct CharMappingMark {
62	offset: usize,
63	line: u32,
64	column: u32,
65	}
66
67	#[derive(Default, Clone, Copy)]
68	/// Positions of the start and the end of an AST node.
69	pub struct SourcePos {
70	byte_offset: (usize, usize),
71	}
72
73	impl SourcePos {
74	/// Create positions from byte offsets:
75	/// - start - offset of the first char of the node
76	/// - end - offset of the first char after the node
77	pub fn new(start: usize, end: usize) -> Self {
78	SourcePos {
79	byte_offset: (start, end),
80	}
81	}
82
83	pub fn get_byte_offsets(&self) -> (usize, usize) {
84	self.byte_offset
85	}
86
87	/// Returns (line_start, column_start, line_end, column_end) from given positions
88	pub fn get_positions(&self, map: &SourceWithLineStarts) -> ((u32, u32), (u32, u32)) {
89	let start = map.get_position(self.byte_offset.0);
90	let end_off = if self.byte_offset.1 > 0 { self.byte_offset.1 - 1 } else { self.byte_offset.1 };
91	let end = map.get_position(end_off);
92	(start, end)
93	}
94	}
95
96	impl std::fmt::Debug for SourcePos {
97	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
98	self.byte_offset.fmt(f)
99	}
100	}
101
102	#[cfg(test)]
103	mod tests {
104	use super::SourceWithLineStarts;
105	use super::SourcePos;
106
107	#[test]
108	fn no_linebreaks() {
109	let map = SourceWithLineStarts::new("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM");
110	for i in 0..20 {
111	assert_eq!(SourcePos::new(i, 0).get_positions(&map).0, (1, i as u32 + 1));
112	}
113	}
114
115	#[test]
116	fn unicode() {
117	let map = SourceWithLineStarts::new("!ΑαΒβΓγΔδΕεΖζΗηΘθΙιΚκΛλΜμΝνΞξΟοΠπΡρΣσςΤτΥυΦφΧχΨψΩω");
118	assert_eq!(SourcePos::new(0, 0).get_positions(&map).0, (1, 1));
119	for i in 1..20 {
120	assert_eq!(SourcePos::new(i, 0).get_positions(&map).0, (1, ((i - 1) / 2) as u32 + 2));
121	}
122	}
123
124	#[test]
125	fn many_linebreaks() {
126	let map = SourceWithLineStarts::new("\n\n\n\n\n\n123");
127	for i in 0..6 {
128	assert_eq!(SourcePos::new(i, 0).get_positions(&map).0, (i as u32 + 2, 0));
129	}
130	assert_eq!(SourcePos::new(7, 0).get_positions(&map).0, (7, 2));
131	assert_eq!(SourcePos::new(8, 0).get_positions(&map).0, (7, 3));
132	}
133
134	#[test]
135	fn after_end() {
136	let map = SourceWithLineStarts::new("123");
137	assert_eq!(SourcePos::new(100, 0).get_positions(&map).0, (1, 3));
138	let map = SourceWithLineStarts::new("123\n");
139	assert_eq!(SourcePos::new(100, 0).get_positions(&map).0, (2, 0));
140	let map = SourceWithLineStarts::new("123\n456");
141	assert_eq!(SourcePos::new(100, 0).get_positions(&map).0, (2, 3));
142	}
143	}

crates/markdown-it/src/common/typekey.rs created+81

...	@@ -0,0 +1,81 @@
1	use std::any::{self, TypeId};
2	use std::fmt::{self, Debug};
3	use std::hash::{Hash, Hasher};
4
5	#[readonly::make]
6	#[derive(Clone, Copy)]
7	/// [std::any::TypeId] and [std::any::type_name] fused into one struct.
8	///
9	/// It acts as TypeId when hashed or compared, and it acts as type_name when printed.
10	/// Used to improve debuggability of type ids in hashmaps in particular.
11	/// ```
12	/// # use markdown_it::common::TypeKey;
13	/// struct A;
14	/// struct B;
15	///
16	/// let mut set = std::collections::HashSet::new();
17	///
18	/// set.insert(TypeKey::of::<A>());
19	/// set.insert(TypeKey::of::<B>());
20	///
21	/// assert!(set.contains(&TypeKey::of::<A>()));
22	/// dbg!(set);
23	/// ```
24	pub struct TypeKey {
25	/// type id (read only)
26	pub id: TypeId,
27	/// type name (read only)
28	pub name: &'static str,
29	}
30
31	impl TypeKey {
32	#[must_use]
33	/// Similar to [TypeId::of](std::any::TypeId::of), returns `TypeKey`
34	/// of the type this generic function has been instantiated with.
35	pub fn of<T: ?Sized + 'static>() -> Self {
36	Self { id: TypeId::of::<T>(), name: any::type_name::<T>() }
37	}
38	}
39
40	impl Hash for TypeKey {
41	fn hash<H: Hasher>(&self, state: &mut H) {
42	self.id.hash(state);
43	}
44	}
45
46	impl PartialEq for TypeKey {
47	fn eq(&self, other: &Self) -> bool {
48	self.id == other.id
49	}
50	}
51
52	impl Eq for TypeKey {}
53
54	impl Debug for TypeKey {
55	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
56	write!(f, "{}", self.name)
57	}
58	}
59
60	#[cfg(test)]
61	mod tests {
62	use super::TypeKey;
63
64	#[test]
65	fn typekey_eq() {
66	struct A;
67	struct B;
68	assert_eq!(TypeKey { id: std::any::TypeId::of::<A>(), name: "foo" },
69	TypeKey { id: std::any::TypeId::of::<A>(), name: "bar" });
70	assert_ne!(TypeKey { id: std::any::TypeId::of::<A>(), name: "foo" },
71	TypeKey { id: std::any::TypeId::of::<B>(), name: "foo" });
72	}
73
74	#[test]
75	fn typekey_of() {
76	struct A;
77	struct B;
78	assert_eq!(TypeKey::of::<A>(), TypeKey::of::<A>());
79	assert_ne!(TypeKey::of::<A>(), TypeKey::of::<B>());
80	}
81	}

crates/markdown-it/src/common/utils.rs created+467

...	@@ -0,0 +1,467 @@
1	//! Random assortment of functions that's used internally to write plugins.
2
3	use entities;
4	use once_cell::sync::Lazy;
5	use regex::Regex;
6	use std::borrow::Cow;
7	use std::collections::HashMap;
8
9	const UNESCAPE_MD_RE : &str = r##"\\([!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{\|}~])"##;
10	const ENTITY_RE : &str = r##"&([A-Za-z#][A-Za-z0-9]{1,31});"##;
11
12	static DIGITAL_ENTITY_TEST_RE : Lazy<Regex> = Lazy::new(\|\|
13	Regex::new(r#"(?i)^&#(x[a-f0-9]{1,8}\|[0-9]{1,8});$"#).unwrap()
14	);
15	static UNESCAPE_ALL_RE : Lazy<Regex> = Lazy::new(\|\|
16	Regex::new(&format!("{UNESCAPE_MD_RE}\|{ENTITY_RE}")).unwrap()
17	);
18
19	#[allow(clippy::manual_range_contains)]
20	/// Return true if a `code` you got from `&#xHHHH;` entity is a valid charcode.
21	///
22	/// It returns false for surrogates and non-printables, so it's a subset of `char::from_u32`.
23	/// For example, it returns false for 0xFDD0, which is a valid character, but not safe to
24	/// render on the screen due to turning you into stone, as per <https://xkcd.com/380/>
25	/// ```
26	/// # use markdown_it::common::utils::is_valid_entity_code;
27	/// assert_eq!(is_valid_entity_code(1), false);
28	/// assert_eq!(is_valid_entity_code(32), true);
29	/// ```
30	pub fn is_valid_entity_code(code: u32) -> bool {
31	// broken sequence
32	if code >= 0xD800 && code <= 0xDFFF { return false; }
33	// never used
34	if code >= 0xFDD0 && code <= 0xFDEF { return false; }
35	if (code & 0xFFFF) == 0xFFFF \|\| (code & 0xFFFF) == 0xFFFE { return false; }
36	// control codes
37	if code <= 0x08 { return false; }
38	if code == 0x0B { return false; }
39	if code >= 0x0E && code <= 0x1F { return false; }
40	if code >= 0x7F && code <= 0x9F { return false; }
41	// out of range
42	if code > 0x10FFFF { return false; }
43	true
44	}
45
46	/// Check if "&xxxx;" string is a valid HTML entity, return character it represents.
47	/// ```
48	/// # use markdown_it::common::utils::get_entity_from_str;
49	/// assert_eq!(get_entity_from_str("&"), Some("&"));
50	/// assert_eq!(get_entity_from_str("&xxx;"), None);
51	/// ```
52	pub fn get_entity_from_str(str: &str) -> Option<&'static str> {
53	pub static ENTITIES_HASH : Lazy<HashMap<&'static str, &'static str>> = Lazy::new(\|\| {
54	let mut mapping = HashMap::new();
55	for e in &entities::ENTITIES {
56	if e.entity.ends_with(';') {
57	mapping.insert(e.entity, e.characters);
58	}
59	}
60	mapping
61	});
62
63	ENTITIES_HASH.get(str).copied()
64	}
65
66	#[allow(clippy::from_str_radix_10)]
67	fn replace_entity_pattern(str: &str) -> Option<String> {
68	if let Some(entity) = get_entity_from_str(str) {
69	Some((*entity).to_owned())
70	} else if let Some(captures) = DIGITAL_ENTITY_TEST_RE.captures(str) {
71	let str = captures.get(1).unwrap().as_str();
72	let code = if str.starts_with('x') \|\| str.starts_with('X') {
73	u32::from_str_radix(&str[1..], 16).unwrap()
74	} else {
75	u32::from_str_radix(str, 10).unwrap()
76	};
77
78	if is_valid_entity_code(code) {
79	Some(char::from_u32(code).unwrap().into())
80	} else {
81	None
82	}
83	} else {
84	None
85	}
86	}
87
88	/// Unescape both entities (`" -> "`) and backslash escapes (`\" -> "`).
89	/// ```
90	/// # use markdown_it::common::utils::unescape_all;
91	/// assert_eq!(unescape_all("&"), "&");
92	/// assert_eq!(unescape_all("\\&"), "&");
93	/// ```
94	pub fn unescape_all(str: &str) -> Cow<str> {
95	if !str.contains('\\') && !str.contains('&') { return Cow::Borrowed(str); }
96
97	UNESCAPE_ALL_RE.replace_all(str, \|captures: &regex::Captures\| {
98	let s = captures.get(0).unwrap().as_str();
99	if let Some(m) = captures.get(1) {
100	// \" -> "
101	m.as_str().to_owned()
102	} else if let Some(replacement) = replace_entity_pattern(s) {
103	// " -> "
104	replacement
105	} else {
106	s.to_owned()
107	}
108	})
109	}
110
111	/// Escape `" < > &` with corresponding HTML entities;
112	/// ```
113	/// # use markdown_it::common::utils::escape_html;
114	/// assert_eq!(escape_html("&\""), "&"");
115	/// ```
116	pub fn escape_html(str: &str) -> Cow<str> {
117	html_escape::encode_double_quoted_attribute(str)
118	}
119
120	/// Unicode case folding + space normalization, used for for reference labels.
121	///
122	/// So that strings equal according to commonmark standard are converted to
123	/// the same string (lowercase/uppercase differences and spacing go away).
124	/// ```
125	/// # use markdown_it::common::utils::normalize_reference;
126	/// assert_eq!(normalize_reference("hello"), normalize_reference("HELLO"));
127	/// assert_eq!(normalize_reference("a b"), normalize_reference("a b"));
128	/// ```
129	pub fn normalize_reference(str: &str) -> String {
130	static SPACE_RE : Lazy<Regex> = Lazy::new(\|\| Regex::new(r"\s+").unwrap());
131
132	// Trim and collapse whitespace
133	//
134	let str = SPACE_RE.replace_all(str.trim(), " ");
135
136	// .toLowerCase().toUpperCase() should get rid of all differences
137	// between letter variants.
138	//
139	// Simple .toLowerCase() doesn't normalize 125 code points correctly,
140	// and .toUpperCase doesn't normalize 6 of them (list of exceptions:
141	// İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
142	// uppercased versions).
143	//
144	// Here's an example showing how it happens. Lets take greek letter omega:
145	// uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
146	//
147	// Unicode entries:
148	// 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;
149	// 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
150	// 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
151	// 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;
152	//
153	// Case-insensitive comparison should treat all of them as equivalent.
154	//
155	// But .toLowerCase() doesn't change ϑ (it's already lowercase),
156	// and .toUpperCase() doesn't change ϴ (already uppercase).
157	//
158	// Applying first lower then upper case normalizes any character:
159	// '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
160	//
161	// Note: this is equivalent to unicode case folding; unicode normalization
162	// is a different step that is not required here.
163	//
164	// Final result should be uppercased, because it's later stored in an object
165	// (this avoid a conflict with Object.prototype members,
166	// most notably, `__proto__`)
167	//
168	str.to_lowercase().to_uppercase()
169	}
170
171	/// Count number of characters since last occurrence of `char`.
172	///
173	/// Finds last occurrence of `char` in `source`, returns number of characters from
174	/// that last occurrence. If char is not found, return number of characters total.
175	/// ```
176	/// # use markdown_it::common::utils::rfind_and_count;
177	/// assert_eq!(rfind_and_count("abcde", 'e'), 0);
178	/// assert_eq!(rfind_and_count("abcde", 'b'), 3);
179	/// assert_eq!(rfind_and_count("abcde", 'z'), 5);
180	/// ```
181	pub fn rfind_and_count(source: &str, char: char) -> usize {
182	let mut result = 0;
183	for c in source.chars().rev() {
184	if c == char { break; }
185	result += 1;
186	}
187	result
188	}
189
190	/// Calculate number of spaces from `pos` to first non-space character or EOL.
191	///
192	/// Tabs are expanded to variable number of spaces with tabstop = 4.
193	/// Returns relative indent and offset of first non-space character.
194	/// ```
195	/// # use markdown_it::common::utils::find_indent_of;
196	/// assert_eq!(find_indent_of("\tfoo", 0), (4, 1));
197	/// ```
198	pub fn find_indent_of(line: &str, mut pos: usize) -> (usize, usize) {
199	let mut chars = line[pos..].chars();
200	let mut indent = 0;
201
202	loop {
203	match chars.next() {
204	Some('\t') => {
205	let bs_count = rfind_and_count(&line[..pos], '\t');
206	indent += 4 - bs_count % 4;
207	pos += 1;
208	}
209	Some(' ') => {
210	indent += 1;
211	pos += 1;
212	}
213	_ => return ( indent, pos ),
214	}
215	}
216	}
217
218	/// Returns trailing whitespace with total length of `indent`.
219	///
220	/// Input: a string of characters (presumed whitespaces, can be anything), where each one of
221	/// them contributes 1 to indent (except for tabs, whose width may vary with tabstop = 4).
222	///
223	/// If an indent would split a tab, that tab is replaced with 4 spaces.
224	///
225	/// Example: cut_right_whitespace_with_tabstops("\t\t", 6) would return " \t" (two preceding
226	/// spaces) because first tab gets expanded to 6 spaces.
227	/// ```
228	/// # use markdown_it::common::utils::cut_right_whitespace_with_tabstops;
229	/// assert_eq!(cut_right_whitespace_with_tabstops("\t\t", 6), " \t");
230	/// ```
231	pub fn cut_right_whitespace_with_tabstops(source: &str, indent: i32) -> Cow<str> {
232	let (num_spaces, start) = calc_right_whitespace_with_tabstops(source, indent);
233
234	if num_spaces > 0 {
235	let mut result = " ".repeat(num_spaces);
236	result += &source[start..];
237	Cow::Owned(result)
238	} else {
239	Cow::Borrowed(&source[start..])
240	}
241	}
242
243	/// Calculate trailing whitespace with total length of `indent`.
244	///
245	/// See [cut_right_whitespace_with_tabstops](cut_right_whitespace_with_tabstops)
246	/// for algorithm and details.
247	///
248	/// Returns number of spaces + number of bytes to cut from the end.
249	/// ```
250	/// # use markdown_it::common::utils::calc_right_whitespace_with_tabstops;
251	/// assert_eq!(calc_right_whitespace_with_tabstops("\t\t", 6), (2, 1));
252	/// ```
253	pub fn calc_right_whitespace_with_tabstops(source: &str, mut indent: i32) -> (usize, usize) {
254	let mut start = source.len();
255	let mut chars = source.char_indices().rev();
256
257	while indent > 0 {
258	match chars.next() {
259	Some((pos, '\t')) => {
260	// previous tab is guaranteed to finish at 0 modulo 4,
261	// so we can finish counting there
262	let indent_from_start = rfind_and_count(&source[..pos], '\t');
263	let tab_width = 4 - indent_from_start as i32 % 4;
264
265	if indent < tab_width {
266	return ( indent as usize, start );
267	}
268
269	indent -= tab_width;
270	start = pos;
271	}
272	Some((pos, _)) => {
273	indent -= 1;
274	start = pos;
275	}
276	None => {
277	start = 0;
278	break;
279	}
280	}
281	}
282
283	( 0, start )
284	}
285
286	/// Checks whether a given character should count as punctuation
287	///
288	/// used to determine word boundaries, made to match the implementation of
289	/// `isPunctChar` from the JS library.
290	/// This is currently implemented as a `match`, but might be simplified as a
291	/// regex if benchmarking shows this to be beneficient.
292	pub fn is_punct_char(ch: char) -> bool {
293	use unicode_general_category::get_general_category;
294	use unicode_general_category::GeneralCategory::*;
295
296	match get_general_category(ch) {
297	// P
298	ConnectorPunctuation \| DashPunctuation \| OpenPunctuation \| ClosePunctuation \|
299	InitialPunctuation \| FinalPunctuation \| OtherPunctuation => true,
300
301	// L
302	UppercaseLetter \| LowercaseLetter \| TitlecaseLetter \| ModifierLetter \| OtherLetter \|
303	// M
304	NonspacingMark \| SpacingMark \| EnclosingMark \|
305	// N
306	DecimalNumber \| LetterNumber \| OtherNumber \|
307	// S
308	MathSymbol \| CurrencySymbol \| ModifierSymbol \| OtherSymbol \|
309	// Z
310	SpaceSeparator \| LineSeparator \| ParagraphSeparator \|
311	// C
312	Control \| Format \| Surrogate \| PrivateUse \| Unassigned => false
313	}
314	}
315
316	#[cfg(test)]
317	mod tests {
318	use super::cut_right_whitespace_with_tabstops as cut_ws;
319	use super::rfind_and_count;
320	use super::find_indent_of;
321	use super::replace_entity_pattern;
322	use super::unescape_all;
323
324	#[test]
325	fn rfind_and_count_test() {
326	assert_eq!(rfind_and_count("", 'b'), 0);
327	assert_eq!(rfind_and_count("abcde", 'e'), 0);
328	assert_eq!(rfind_and_count("abcde", 'b'), 3);
329	assert_eq!(rfind_and_count("abcde", 'z'), 5);
330	assert_eq!(rfind_and_count("abcεπ", 'b'), 3);
331	}
332
333	#[test]
334	fn find_indent_of_simple_test() {
335	assert_eq!(find_indent_of("a", 0), (0, 0));
336	assert_eq!(find_indent_of(" a", 0), (1, 1));
337	assert_eq!(find_indent_of(" a", 0), (3, 3));
338	assert_eq!(find_indent_of(" ", 0), (4, 4));
339	assert_eq!(find_indent_of("\ta", 0), (4, 1));
340	assert_eq!(find_indent_of(" \ta", 0), (4, 2));
341	assert_eq!(find_indent_of(" \ta", 0), (4, 3));
342	assert_eq!(find_indent_of(" \ta", 0), (4, 4));
343	assert_eq!(find_indent_of(" \ta", 0), (8, 5));
344	}
345
346	#[test]
347	fn find_indent_of_with_offset() {
348	assert_eq!(find_indent_of(" a", 2), (1, 3));
349	assert_eq!(find_indent_of(" a", 2), (2, 4));
350	assert_eq!(find_indent_of(" \ta", 2), (2, 3));
351	assert_eq!(find_indent_of(" \ta", 2), (2, 4));
352	assert_eq!(find_indent_of(" \ta", 2), (6, 5));
353	assert_eq!(find_indent_of(" \ta", 2), (6, 6));
354	}
355
356	#[test]
357	fn find_indent_of_tabs_test() {
358	assert_eq!(find_indent_of(" \t \ta", 1), (7, 5));
359	assert_eq!(find_indent_of(" \t \ta", 2), (6, 5));
360	assert_eq!(find_indent_of(" \t \ta", 3), (4, 5));
361	assert_eq!(find_indent_of(" \t \ta", 4), (3, 5));
362	}
363
364	#[test]
365	fn cut_ws_simple() {
366	assert_eq!(cut_ws("abc", -1), "");
367	assert_eq!(cut_ws("abc", 0), "");
368	assert_eq!(cut_ws("abc", 1), "c");
369	assert_eq!(cut_ws("abc", 2), "bc");
370	assert_eq!(cut_ws("abc", 3), "abc");
371	assert_eq!(cut_ws("abc", 4), "abc");
372	}
373
374	#[test]
375	fn cut_ws_unicode() {
376	assert_eq!(cut_ws("αβγδ", 1), "δ");
377	assert_eq!(cut_ws("αβγδ ", 3), "γδ ");
378	}
379
380	#[test]
381	fn cut_ws_expands_partial_tabs() {
382	assert_eq!(cut_ws("\t", 1), " ");
383	assert_eq!(cut_ws("\t", 2), " ");
384	assert_eq!(cut_ws("\t", 3), " ");
385	assert_eq!(cut_ws("\t\t\t", 5), " \t");
386	assert_eq!(cut_ws("\t\t\t", 7), " \t");
387	}
388
389	#[test]
390	fn cut_ws_retains_full_tabs() {
391	assert_eq!(cut_ws("\t\t\t", 4), "\t");
392	assert_eq!(cut_ws("\t\t\t", 8), "\t\t");
393	}
394
395	#[test]
396	fn cut_ws_proper_tabstops() {
397	assert_eq!(cut_ws("a\t", 1), " ");
398	assert_eq!(cut_ws("a\t", 2), " ");
399	assert_eq!(cut_ws("a\t", 3), "\t");
400	assert_eq!(cut_ws("ab\t", 3), "b\t");
401	assert_eq!(cut_ws("abc\t", 3), "bc\t");
402	}
403
404	#[test]
405	fn cut_ws_proper_tabstops_nested() {
406	assert_eq!(cut_ws("a\tb\t", 2), " ");
407	assert_eq!(cut_ws("a\tb\t", 3), "\t");
408	assert_eq!(cut_ws("a\tb\t", 4), "b\t");
409	assert_eq!(cut_ws("a\tb\t", 5), " b\t");
410	assert_eq!(cut_ws("a\tb\t", 6), " b\t");
411	assert_eq!(cut_ws("a\tb\t", 7), "\tb\t");
412	assert_eq!(cut_ws("a\tb\t", 8), "a\tb\t");
413	}
414
415	#[test]
416	fn cut_ws_different_tabstops_nested() {
417	assert_eq!(cut_ws("abc\tde\tf\tg", 3), " g");
418	assert_eq!(cut_ws("abc\tde\tf\tg", 4), "\tg");
419	assert_eq!(cut_ws("abc\tde\tf\tg", 5), "f\tg");
420	assert_eq!(cut_ws("abc\tde\tf\tg", 6), " f\tg");
421	assert_eq!(cut_ws("abc\tde\tf\tg", 7), "\tf\tg");
422	assert_eq!(cut_ws("abc\tde\tf\tg", 9), "de\tf\tg");
423	assert_eq!(cut_ws("abc\tde\tf\tg", 10), "\tde\tf\tg");
424	}
425
426	#[test]
427	fn test_replace_entity_pattern() {
428	assert_eq!(replace_entity_pattern("&"), Some("&".into()));
429	assert_eq!(replace_entity_pattern("€"), Some("€".into()));
430	assert_eq!(replace_entity_pattern("—"), Some("—".into()));
431	assert_eq!(replace_entity_pattern("—"), Some("—".into()));
432	assert_eq!(replace_entity_pattern("&#X20;"), Some(" ".into()));
433	assert_eq!(replace_entity_pattern("?"), Some("?".into()));
434	assert_eq!(replace_entity_pattern("&ffff;"), None);
435	assert_eq!(replace_entity_pattern("&#3F;"), None);
436	assert_eq!(replace_entity_pattern("&#xGG;"), None);
437	}
438
439	#[test]
440	fn test_unescape_all_simple() {
441	assert_eq!(unescape_all("&"), "&");
442	assert_eq!(unescape_all("\\&"), "&");
443	}
444
445	#[test]
446	fn test_unescape_all_xss() {
447	assert_eq!(
448	unescape_all(r#"javascript:alert(1)"#),
449	r#"javascript:alert(1)"#);
450
451	assert_eq!(
452	unescape_all(r#"Javascript:alert(1)"#),
453	r#"Javascript:alert(1)"#);
454
455	assert_eq!(
456	unescape_all(r#"&#74;avascript:alert(1)"#),
457	r#"Javascript:alert(1)"#);
458
459	assert_eq!(
460	unescape_all(r#"\Javascript:alert(1)"#),
461	r#"Javascript:alert(1)"#);
462
463	assert_eq!(
464	unescape_all(r#""><script>alert("xss")</script>"#),
465	r#""><script>alert("xss")</script>"#);
466	}
467	}

crates/markdown-it/src/examples/ferris/block_rule.rs created+7

...	@@ -0,0 +1,7 @@
1	//! Replaces `(\/)-------(\/)` with a nice picture.
2	//!
3	//! ```rust
4	//! # const IGNORE : &str = stringify! {
5	#![doc=include_str!("../../../examples/ferris/block_rule.rs")]
6	//! # };
7	//! ```

crates/markdown-it/src/examples/ferris/core_rule.rs created+7

...	@@ -0,0 +1,7 @@
1	//! Counts the number of crabs lurking around.
2	//!
3	//! ```rust
4	//! # const IGNORE : &str = stringify! {
5	#![doc=include_str!("../../../examples/ferris/core_rule.rs")]
6	//! # };
7	//! ```

crates/markdown-it/src/examples/ferris/inline_rule.rs created+7

...	@@ -0,0 +1,7 @@
1	//! Replaces `(\/)` with `🦀`.
2	//!
3	//! ```rust
4	//! # const IGNORE : &str = stringify! {
5	#![doc=include_str!("../../../examples/ferris/inline_rule.rs")]
6	//! # };
7	//! ```

crates/markdown-it/src/examples/ferris/mod.rs created+15

...	@@ -0,0 +1,15 @@
1	#![doc=include_str!("../../../examples/ferris/README.md")]
2	//!
3	//! ### Implementation
4	//!
5	//! See [core_rule], [block_rule] and [inline_rule] below for implementations.
6	//!
7	//! ```rust
8	//! # const IGNORE : &str = stringify! {
9	#![doc=include_str!("../../../examples/ferris/main.rs")]
10	//! # };
11	//! ```
12
13	pub mod block_rule;
14	pub mod core_rule;
15	pub mod inline_rule;

crates/markdown-it/src/examples/mod.rs created+4

...	@@ -0,0 +1,4 @@
1	//! Copied content from `examples/` folder (docs only).
2
3	pub mod ferris;
4	mod testreadme;

crates/markdown-it/src/examples/testreadme.rs created+2

...	@@ -0,0 +1,2 @@
1	// This file is used only to test examples in README.
2	#![doc=include_str!("../../README.md")]

crates/markdown-it/src/generics/inline/code_pair.rs created+142

...	@@ -0,0 +1,142 @@
1	//! Structure similar to `` `code span` `` with configurable markers of variable length.
2	//!
3	//! It allows you to define a custom structure with variable number of markers
4	//! (e.g. with `%` defined as a marker, user can write `%foo%` or `%%%foo%%%`
5	//! resulting in the same node).
6	//!
7	//! You add a custom structure by using [add_with] function, which takes following arguments:
8	//! - `MARKER` - marker character
9	//! - `md` - parser instance
10	//! - `f` - function that should return your custom [Node]
11	//!
12	//! Here is an example of a rule turning `%foo%` into `🦀foo🦀`:
13	//!
14	//! ```rust
15	//! use markdown_it::generics::inline::code_pair;
16	//! use markdown_it::{MarkdownIt, Node, NodeValue, Renderer};
17	//!
18	//! #[derive(Debug)]
19	//! struct Ferris;
20	//! impl NodeValue for Ferris {
21	//! fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
22	//! fmt.text("🦀");
23	//! fmt.contents(&node.children);
24	//! fmt.text("🦀");
25	//! }
26	//! }
27	//!
28	//! let md = &mut MarkdownIt::new();
29	//! code_pair::add_with::<'%'>(md, \|_\| Node::new(Ferris));
30	//! let html = md.parse("hello %world%").render();
31	//! assert_eq!(html.trim(), "hello 🦀world🦀");
32	//! ```
33	//!
34	//! This generic structure follows exact rules of code span in CommonMark:
35	//!
36	//! 1. Literal marker character sequence can be used inside of structure if its length
37	//! doesn't match length of the opening/closing sequence (e.g. with `%` defined
38	//! as a marker, `%%foo%bar%%` gets parsed as `Node("foo%bar")`).
39	//!
40	//! 2. Single space inside is trimmed to allow you to write `% %%foo %` to be parsed as
41	//! `Node("%%foo")`.
42	//!
43	//! If you define two structures with the same marker, only the first one will work.
44	//!
45	use crate::parser::extset::{InlineRootExt, MarkdownItExt};
46	use crate::parser::inline::{InlineRule, InlineState, Text};
47	use crate::{MarkdownIt, Node};
48
49	#[derive(Debug, Default)]
50	struct CodePairCache<const MARKER: char> {
51	scanned: bool,
52	max: Vec<usize>,
53	}
54	impl<const MARKER: char> InlineRootExt for CodePairCache<MARKER> {}
55
56	#[derive(Debug)]
57	struct CodePairConfig<const MARKER: char>(fn (usize) -> Node);
58	impl<const MARKER: char> MarkdownItExt for CodePairConfig<MARKER> {}
59
60	pub fn add_with<const MARKER: char>(md: &mut MarkdownIt, f: fn (length: usize) -> Node) {
61	md.ext.insert(CodePairConfig::<MARKER>(f));
62
63	md.inline.add_rule::<CodePairScanner<MARKER>>();
64	}
65
66	#[doc(hidden)]
67	pub struct CodePairScanner<const MARKER: char>;
68	impl<const MARKER: char> InlineRule for CodePairScanner<MARKER> {
69	const MARKER: char = MARKER;
70
71	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
72	let mut chars = state.src[state.pos..state.pos_max].chars();
73	if chars.next().unwrap() != MARKER { return None; }
74	if state.trailing_text_get().ends_with(MARKER) { return None; }
75
76	let mut pos = state.pos + 1;
77
78	// scan marker length
79	while Some(MARKER) == chars.next() {
80	pos += 1;
81	}
82
83	// backtick length => last seen position
84	let backticks = state.inline_ext.get_or_insert_default::<CodePairCache<MARKER>>();
85	let opener_len = pos - state.pos;
86
87	if backticks.scanned && backticks.max.get(opener_len).copied().unwrap_or(0) <= state.pos {
88	// performance note: adding entire sequence into pending is 5x faster,
89	// but it will interfere with other rules working on the same char;
90	// and it is extremely rare that user would put a thousand "`" in text
91	return None;
92	}
93
94	let mut match_start;
95	let mut match_end = pos;
96
97	// Nothing found in the cache, scan until the end of the line (or until marker is found)
98	while let Some(p) = state.src[match_end..state.pos_max].find(MARKER) {
99	match_start = match_end + p;
100
101	// scan marker length
102	match_end = match_start + 1;
103	chars = state.src[match_end..state.pos_max].chars();
104
105	while Some(MARKER) == chars.next() {
106	match_end += 1;
107	}
108
109	let closer_len = match_end - match_start;
110
111	if closer_len == opener_len {
112	// Found matching closer length.
113	let mut content = state.src[pos..match_start].to_owned().replace('\n', " ");
114	if content.starts_with(' ') && content.ends_with(' ') && content.len() > 2 {
115	content[1..content.len() - 1].to_owned().clone_into(&mut content);
116	pos += 1;
117	match_start -= 1;
118	}
119
120	let f = state.md.ext.get::<CodePairConfig<MARKER>>().unwrap().0;
121	let mut node = f(opener_len);
122
123	let mut inner_node = Node::new(Text { content });
124	inner_node.srcmap = state.get_map(pos, match_start);
125	node.children.push(inner_node);
126
127	return Some((node, match_end - state.pos));
128	}
129
130	// Some different length found, put it in cache as upper limit of where closer can be found
131	let backticks = state.inline_ext.get_mut::<CodePairCache<MARKER>>().unwrap();
132	while backticks.max.len() <= closer_len { backticks.max.push(0); }
133	backticks.max[closer_len] = match_start;
134	}
135
136	// Scanned through the end, didn't find anything
137	let backticks = state.inline_ext.get_mut::<CodePairCache<MARKER>>().unwrap();
138	backticks.scanned = true;
139
140	None
141	}
142	}

crates/markdown-it/src/generics/inline/emph_pair.rs created+390

...	@@ -0,0 +1,390 @@
1	//! Structure similar to `emphasis` with configurable markers of fixed length.
2	//!
3	//! There are many structures in various markdown flavors that
4	//! can be implemented with this, namely:
5	//!
6	//! - `emphasis` or `_emphasis_` -> `<em>emphasis</em>`
7	//! - `strong` or `__strong__` -> `<strong>strong</strong>`
8	//! - `~~strikethrough~~` -> `<s>strikethrough</s>`
9	//! - `==marked==` -> `<mark>marked</mark>`
10	//! - `++inserted++` -> `<ins>inserted</ins>`
11	//! - `~subscript~` -> `<sub>subscript</sub>`
12	//! - `^superscript^` -> `<sup>superscript</sup>`
13	//!
14	//! You add a custom structure by using [add_with] function, which takes following arguments:
15	//! - `MARKER` - marker character
16	//! - `LENGTH` - length of the opening/closing marker (can be 1, 2 or 3)
17	//! - `CAN_SPLIT_WORD` - whether this structure can be found in the middle of the word
18	//! (for example, note the difference between `foobarbaz` and `foo_bar_baz`
19	//! in CommonMark - first one is an emphasis, second one isn't)
20	//! - `md` - parser instance
21	//! - `f` - function that should return your custom [Node]
22	//!
23	//! Here is an example of implementing superscript in your custom code:
24	//!
25	//! ```rust
26	//! use markdown_it::generics::inline::emph_pair;
27	//! use markdown_it::{MarkdownIt, Node, NodeValue, Renderer};
28	//!
29	//! #[derive(Debug)]
30	//! struct Superscript;
31	//! impl NodeValue for Superscript {
32	//! fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
33	//! fmt.open("sup", &node.attrs);
34	//! fmt.contents(&node.children);
35	//! fmt.close("sup");
36	//! }
37	//! }
38	//!
39	//! let md = &mut MarkdownIt::new();
40	//! emph_pair::add_with::<'^', 1, true>(md, \|\| Node::new(Superscript));
41	//!
42	//! let html = md.parse("e^iπ^+1=0").render();
43	//! assert_eq!(html.trim(), "e<sup>iπ</sup>+1=0");
44	//! ```
45	//!
46	//! Note that these structures have lower priority than the rest of the rules,
47	//! e.g. `` foo`barbaz` `` is parsed as `foo<code>barbaz</code>`.
48	//!
49	use std::cmp::min;
50
51	use crate::common::sourcemap::SourcePos;
52	use crate::parser::core::CoreRule;
53	use crate::parser::extset::{MarkdownItExt, NodeExt};
54	use crate::parser::inline::builtin::InlineParserRule;
55	use crate::parser::inline::{InlineRule, InlineState, Text};
56	use crate::{MarkdownIt, Node, NodeValue};
57
58	#[derive(Debug, Default)]
59	struct PairConfig<const MARKER: char> {
60	inserted: bool,
61	fns: [Option<fn() -> Node>; 3],
62	}
63	impl<const MARKER: char> MarkdownItExt for PairConfig<MARKER> {}
64
65	#[derive(Debug, Default)]
66	struct OpenersBottom<const MARKER: char>([usize; 6]);
67	impl<const MARKER: char> NodeExt for OpenersBottom<MARKER> {}
68
69	#[derive(Debug, Clone)]
70	#[doc(hidden)]
71	pub struct EmphMarker {
72	// Starting marker
73	pub marker: char,
74
75	// Total length of these series of delimiters.
76	pub length: usize,
77
78	// Remaining length that's not already matched to other delimiters.
79	pub remaining: usize,
80
81	// Boolean flags that determine if this delimiter could open or close
82	// an emphasis.
83	pub open: bool,
84	pub close: bool,
85
86	// Inline position (offset into the stripped inline text) where this
87	// delimiter starts. Stored so that `run` can compute the correct
88	// inline-coordinate token length when the delimiter spans multiple
89	// block-quote continuation lines (where srcmap offsets include the
90	// stripped `> ` bytes and therefore exceed the inline position).
91	pub inline_pos: usize,
92	}
93
94	// this node is supposed to be replaced by actual emph or text node
95	impl NodeValue for EmphMarker {}
96
97	pub fn add_with<const MARKER: char, const LENGTH: u8, const CAN_SPLIT_WORD: bool>(
98	md: &mut MarkdownIt,
99	f: fn() -> Node,
100	) {
101	let pair_config = md.ext.get_or_insert_default::<PairConfig<MARKER>>();
102	pair_config.fns[LENGTH as usize - 1] = Some(f);
103
104	if !pair_config.inserted {
105	pair_config.inserted = true;
106	md.inline
107	.add_rule::<EmphPairScanner<MARKER, CAN_SPLIT_WORD>>();
108	}
109
110	if !md.has_rule::<FragmentsJoin>() {
111	md.add_rule::<FragmentsJoin>()
112	.before_all()
113	.after::<InlineParserRule>();
114	}
115	}
116
117	#[doc(hidden)]
118	pub struct EmphPairScanner<const MARKER: char, const CAN_SPLIT_WORD: bool>;
119	impl<const MARKER: char, const CAN_SPLIT_WORD: bool> InlineRule
120	for EmphPairScanner<MARKER, CAN_SPLIT_WORD>
121	{
122	const MARKER: char = MARKER;
123
124	// this rule works on a closing marker, so for technical reasons any rules trying to skip it
125	// should see just plain text
126	fn check(_: &mut InlineState) -> Option<usize> {
127	None
128	}
129
130	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
131	let mut chars = state.src[state.pos..state.pos_max].chars();
132	if chars.next().unwrap() != MARKER {
133	return None;
134	}
135
136	let scanned = state.scan_delims(state.pos, CAN_SPLIT_WORD);
137	let inline_closer_start = state.pos;
138	let mut node = Node::new(EmphMarker {
139	marker: MARKER,
140	length: scanned.length,
141	remaining: scanned.length,
142	open: scanned.can_open,
143	close: scanned.can_close,
144	inline_pos: state.pos,
145	});
146	node.srcmap = state.get_map(state.pos, state.pos + scanned.length);
147	let (node, opener_inline_pos) = scan_and_match_delimiters::<MARKER>(state, node);
148	// backtrack to keep correct source maps
149	state.pos += scanned.length;
150	// Compute token_len in inline coordinates. Using srcmap byte offsets
151	// (map.1 - map.0) is incorrect when the token spans multiple blockquote
152	// continuation lines because the srcmap reflects the original file bytes
153	// (which include the stripped `> ` prefixes) rather than the shorter
154	// inline text. When a match was found we use the opener's stored inline
155	// position; when no match was found the token is only the scanned
156	// delimiter itself.
157	let token_len = match opener_inline_pos {
158	Some(oip) => state.pos - oip,
159	None => scanned.length,
160	};
161	// Sanity: keep state.pos valid (should never underflow, but guard anyway)
162	debug_assert!(
163	state.pos >= token_len,
164	"emph backtrack underflow: pos={} token_len={} closer_start={}",
165	state.pos,
166	token_len,
167	inline_closer_start
168	);
169	state.pos -= token_len;
170	Some((node, token_len))
171	}
172	}
173
174	/// Assuming last token is a closing delimiter we just inserted,
175	/// try to find opener(s). If any are found, move stuff to nested emph node.
176	///
177	/// Returns `(node, opener_inline_pos)`. `opener_inline_pos` is `Some` when a
178	/// match was found; the value is the `inline_pos` field of the matched opener.
179	fn scan_and_match_delimiters<const MARKER: char>(
180	state: &mut InlineState,
181	mut closer_token: Node,
182	) -> (Node, Option<usize>) {
183	if state.node.children.is_empty() {
184	return (closer_token, None);
185	} // must have at least opener and closer
186
187	let mut closer = closer_token.cast_mut::<EmphMarker>().unwrap().clone();
188	if !closer.close {
189	return (closer_token, None);
190	}
191
192	// Previously calculated lower bounds (previous fails)
193	// for each marker, each delimiter length modulo 3,
194	// and for whether this closer can be an opener;
195	// https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460
196	let openers_for_marker = state
197	.node
198	.ext
199	.get_or_insert_default::<OpenersBottom<MARKER>>();
200	let openers_parameter = (closer.open as usize) * 3 + closer.length % 3;
201
202	let min_opener_idx = openers_for_marker.0[openers_parameter];
203
204	let mut idx = state.node.children.len() - 1;
205	let mut new_min_opener_idx = idx;
206	let mut matched_opener_inline_pos: Option<usize> = None;
207	while idx > min_opener_idx {
208	idx -= 1;
209
210	let Some(opener) = state.node.children[idx].cast::<EmphMarker>() else {
211	continue;
212	};
213
214	let mut opener = opener.clone();
215	if opener.open && opener.marker == closer.marker && !is_odd_match(&opener, &closer) {
216	while closer.remaining > 0 && opener.remaining > 0 {
217	let max_marker_len = min(3, min(opener.remaining, closer.remaining));
218	let mut matched_rule = None;
219	let fns = &state.md.ext.get::<PairConfig<MARKER>>().unwrap().fns;
220	for marker_len in (1..=max_marker_len).rev() {
221	if let Some(f) = fns[marker_len - 1] {
222	matched_rule = Some((marker_len, f));
223	break;
224	}
225	}
226
227	// If matched_fn isn't found, it can only mean that function is defined for larger marker
228	// than we have (e.g. function defined for *, we have ).
229	// Treat this as "marker not found".
230	if matched_rule.is_none() {
231	break;
232	}
233
234	let (marker_len, marker_fn) = matched_rule.unwrap();
235
236	closer.remaining -= marker_len;
237	opener.remaining -= marker_len;
238
239	let mut new_token = marker_fn();
240	new_token.children = state.node.children.split_off(idx + 1);
241
242	// cut marker_len chars from start, i.e. "12345" -> "345"
243	let mut end_map_pos = 0;
244	if let Some(map) = closer_token.srcmap {
245	let (start, end) = map.get_byte_offsets();
246	closer_token.srcmap = Some(SourcePos::new(start + marker_len, end));
247	end_map_pos = start + marker_len;
248	}
249
250	// cut marker_len chars from end, i.e. "12345" -> "123"
251	let mut start_map_pos = 0;
252	let opener_token = state.node.children.last_mut().unwrap();
253	if let Some(map) = opener_token.srcmap {
254	let (start, end) = map.get_byte_offsets();
255	opener_token.srcmap = Some(SourcePos::new(start, end - marker_len));
256	start_map_pos = end - marker_len;
257	}
258
259	new_token.srcmap = state.get_map(start_map_pos, end_map_pos);
260
261	// remove empty node as a small optimization so we can do less work later
262	if opener.remaining == 0 {
263	state.node.children.pop();
264	}
265
266	new_min_opener_idx = 0;
267	if matched_opener_inline_pos.is_none() {
268	matched_opener_inline_pos = Some(opener.inline_pos);
269	}
270	state.node.children.push(new_token);
271	}
272	}
273
274	if opener.remaining > 0 {
275	state.node.children[idx].replace(opener);
276	} // otherwise node was already deleted
277	}
278
279	if new_min_opener_idx != 0 {
280	// If match for this delimiter run failed, we want to set lower bound for
281	// future lookups. This is required to make sure algorithm has linear
282	// complexity.
283	//
284	// See details here:
285	// https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
286	//
287	let openers_for_marker = state
288	.node
289	.ext
290	.get_or_insert_default::<OpenersBottom<MARKER>>();
291	openers_for_marker.0[openers_parameter] = new_min_opener_idx;
292	}
293
294	// remove empty node as a small optimization so we can do less work later
295	if closer.remaining > 0 {
296	closer_token.replace(closer);
297	(closer_token, matched_opener_inline_pos)
298	} else {
299	(
300	state.node.children.pop().unwrap(),
301	matched_opener_inline_pos,
302	)
303	}
304	}
305
306	fn is_odd_match(opener: &EmphMarker, closer: &EmphMarker) -> bool {
307	// from spec:
308	//
309	// If one of the delimiters can both open and close emphasis, then the
310	// sum of the lengths of the delimiter runs containing the opening and
311	// closing delimiters must not be a multiple of 3 unless both lengths
312	// are multiples of 3.
313	//
314	#[allow(clippy::collapsible_if)]
315	if opener.close \|\| closer.open {
316	if (opener.length + closer.length) % 3 == 0 {
317	if opener.length % 3 != 0 \|\| closer.length % 3 != 0 {
318	return true;
319	}
320	}
321	}
322
323	false
324	}
325
326	#[doc(hidden)]
327	pub struct FragmentsJoin;
328	impl CoreRule for FragmentsJoin {
329	fn run(node: &mut Node, _: &MarkdownIt) {
330	node.walk_mut(\|node, _\| fragments_join(node));
331	}
332	}
333
334	/// Clean up tokens after emphasis and strikethrough postprocessing:
335	/// merge adjacent text nodes into one and re-calculate all token levels
336	///
337	/// This is necessary because initially emphasis delimiter markers (*, _, ~)
338	/// are treated as their own separate text tokens. Then emphasis rule either
339	/// leaves them as text (needed to merge with adjacent text) or turns them
340	/// into opening/closing tags (which messes up levels inside).
341	///
342	fn fragments_join(node: &mut Node) {
343	// replace all emph markers with text tokens
344	for token in node.children.iter_mut() {
345	if let Some(data) = token.cast::<EmphMarker>() {
346	let content = data.marker.to_string().repeat(data.remaining);
347	token.replace(Text { content });
348	}
349	}
350
351	// collapse adjacent text tokens
352	for idx in 1..node.children.len() {
353	let (tokens1, tokens2) = node.children.split_at_mut(idx);
354
355	let token1 = tokens1.last_mut().unwrap();
356	let Some(t1_data) = token1.cast_mut::<Text>() else {
357	continue;
358	};
359
360	let token2 = tokens2.first_mut().unwrap();
361	let Some(t2_data) = token2.cast_mut::<Text>() else {
362	continue;
363	};
364
365	// concat contents
366	let t2_content = std::mem::take(&mut t2_data.content);
367	t1_data.content += &t2_content;
368
369	// adjust source maps
370	if let Some(map1) = token1.srcmap {
371	if let Some(map2) = token2.srcmap {
372	token1.srcmap = Some(SourcePos::new(
373	map1.get_byte_offsets().0,
374	map2.get_byte_offsets().1,
375	));
376	}
377	}
378
379	node.children.swap(idx - 1, idx);
380	}
381
382	// remove all empty tokens
383	node.children.retain(\|token\| {
384	if let Some(data) = token.cast::<Text>() {
385	!data.content.is_empty()
386	} else {
387	true
388	}
389	});
390	}

crates/markdown-it/src/generics/inline/full_link.rs created+440

...	@@ -0,0 +1,440 @@
1	//! Structure similar to `[link](<to> "stuff")` with configurable prefix.
2	//!
3	//! There are two structures in CommonMark that match this syntax:
4	//! - links - `[text](<href> "title")`
5	//! - images - `![alt](<src> "title")`
6	//!
7	//! You can add custom rules like `~[foo](<bar> "baz")`. Let us know if
8	//! you come up with fun use case to add as an example!
9	//!
10	//! Add a custom structure by using [add_prefix] function, which takes following arguments:
11	//! - `PREFIX` - marker character before label (`!` in case of images)
12	//! - `ENABLE_NESTED` - allow nested links inside
13	//! - `md` - parser instance
14	//! - `f` - function that should return your custom [Node] given href and title
15	//!
16	use std::collections::HashMap;
17
18	use crate::common::utils::unescape_all;
19	use crate::parser::extset::{InlineRootExt, MarkdownItExt};
20	use crate::parser::inline::{InlineRule, InlineState};
21	use crate::plugins::cmark::block::reference::ReferenceMap;
22	use crate::{MarkdownIt, Node};
23
24	#[derive(Debug)]
25	struct LinkCfg<const PREFIX: char>(fn (Option<String>, Option<String>) -> Node);
26	impl<const PREFIX: char> MarkdownItExt for LinkCfg<PREFIX> {}
27
28	/// adds custom rule with no prefix
29	pub fn add<const ENABLE_NESTED: bool>(
30	md: &mut MarkdownIt,
31	f: fn (url: Option<String>, title: Option<String>) -> Node
32	) {
33	md.ext.insert(LinkCfg::<'\0'>(f));
34	md.inline.add_rule::<LinkScanner<ENABLE_NESTED>>();
35	if !md.inline.has_rule::<LinkScannerEnd>() {
36	md.inline.add_rule::<LinkScannerEnd>();
37	}
38	}
39
40	/// adds custom rule with given `PREFIX` character
41	pub fn add_prefix<const PREFIX: char, const ENABLE_NESTED: bool>(
42	md: &mut MarkdownIt,
43	f: fn (url: Option<String>, title: Option<String>) -> Node
44	) {
45	md.ext.insert(LinkCfg::<PREFIX>(f));
46	md.inline.add_rule::<LinkPrefixScanner<PREFIX, ENABLE_NESTED>>();
47	if !md.inline.has_rule::<LinkScannerEnd>() {
48	md.inline.add_rule::<LinkScannerEnd>();
49	}
50	}
51
52	#[doc(hidden)]
53	pub struct LinkScanner<const ENABLE_NESTED: bool>;
54	impl<const ENABLE_NESTED: bool> InlineRule for LinkScanner<ENABLE_NESTED> {
55	const MARKER: char = '[';
56
57	fn check(state: &mut InlineState) -> Option<usize> {
58	let mut chars = state.src[state.pos..state.pos_max].chars();
59	if chars.next().unwrap() != '[' { return None; }
60	rule_check(state, ENABLE_NESTED, 0)
61	}
62
63	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
64	let mut chars = state.src[state.pos..state.pos_max].chars();
65	if chars.next().unwrap() != '[' { return None; }
66	let f = state.md.ext.get::<LinkCfg<'\0'>>().unwrap().0;
67	rule_run(state, ENABLE_NESTED, 0, f)
68	}
69	}
70
71	#[doc(hidden)]
72	pub struct LinkPrefixScanner<const PREFIX: char, const ENABLE_NESTED: bool>;
73	impl<const PREFIX: char, const ENABLE_NESTED: bool> InlineRule for LinkPrefixScanner<PREFIX, ENABLE_NESTED> {
74	const MARKER: char = PREFIX;
75
76	fn check(state: &mut InlineState) -> Option<usize> {
77	let mut chars = state.src[state.pos..state.pos_max].chars();
78	if chars.next() != Some(PREFIX) { return None; }
79	if chars.next() != Some('[') { return None; }
80	rule_check(state, ENABLE_NESTED, 1)
81	}
82
83	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
84	let mut chars = state.src[state.pos..state.pos_max].chars();
85	if chars.next() != Some(PREFIX) { return None; }
86	if chars.next() != Some('[') { return None; }
87	let f = state.md.ext.get::<LinkCfg<PREFIX>>().unwrap().0;
88	rule_run(state, ENABLE_NESTED, 1, f)
89	}
90	}
91
92	#[doc(hidden)]
93	/// this rule makes sure that parser is stopped on "]" character,
94	/// but it actually doesn't do anything
95	pub struct LinkScannerEnd;
96	impl InlineRule for LinkScannerEnd {
97	const MARKER: char = ']';
98
99	fn check(_: &mut InlineState) -> Option<usize> { None }
100	fn run(_: &mut InlineState) -> Option<(Node, usize)> { None }
101	}
102
103	fn rule_check(state: &mut InlineState, enable_nested: bool, offset: usize) -> Option<usize> {
104	if let Some(result) = parse_link(state, state.pos + offset, enable_nested) {
105	Some(result.end - state.pos)
106	} else {
107	None
108	}
109	}
110
111	fn rule_run(
112	state: &mut InlineState,
113	enable_nested: bool,
114	offset: usize,
115	f: fn (Option<String>, Option<String>) -> Node
116	) -> Option<(Node, usize)> {
117	let start = state.pos;
118	let result = parse_link(state, state.pos + offset, enable_nested)?;
119
120	//
121	// We found the end of the link, and know for a fact it's a valid link;
122	// so all that's left to do is to call tokenizer.
123	//
124	let old_node = std::mem::replace(&mut state.node, f(result.href, result.title));
125	let max = state.pos_max;
126
127	state.link_level += 1;
128	state.pos = result.label_start;
129	state.pos_max = result.label_end;
130	state.md.inline.tokenize(state);
131	state.pos = start;
132	state.pos_max = max;
133	state.link_level -= 1;
134
135	let node = std::mem::replace(&mut state.node, old_node);
136	Some((node, result.end - state.pos))
137	}
138
139	#[derive(Debug, Default)]
140	struct LinkLabelScanCache(HashMap<(usize, bool), Option<usize>>);
141	impl InlineRootExt for LinkLabelScanCache {}
142
143
144	// Parse link label
145	//
146	// this function assumes that first character ("[") already matches;
147	// returns the end of the label
148	fn parse_link_label(state: &mut InlineState, start: usize, enable_nested: bool) -> Option<usize> {
149	let cache = state.inline_ext.get_or_insert_default::<LinkLabelScanCache>();
150	if let Some(&cached) = cache.0.get(&(start, enable_nested)) {
151	return cached;
152	}
153
154	let old_pos = state.pos;
155	let mut found = false;
156	let mut label_end = None;
157	let mut level = 1;
158
159	state.pos = start + 1;
160
161	while let Some(ch) = state.src[state.pos..state.pos_max].chars().next() {
162	if ch == ']' {
163	level -= 1;
164	if level == 0 {
165	found = true;
166	break;
167	}
168	}
169
170	let prev_pos = state.pos;
171	state.md.inline.skip_token(state);
172	if ch == '[' {
173	if prev_pos == state.pos - 1 {
174	// increase level if we find text `[`, which is not a part of any token
175	level += 1;
176
177	let cache = state.inline_ext.get_or_insert_default::<LinkLabelScanCache>();
178	if let Some(&cached) = cache.0.get(&(prev_pos, enable_nested)) {
179	// maybe cache appeared as a result of skip_token
180	if let Some(cached_pos) = cached {
181	state.pos = cached_pos;
182	} else {
183	break;
184	}
185	}
186
187	} else if !enable_nested {
188	break;
189	}
190	}
191	}
192
193	if found {
194	label_end = Some(state.pos);
195	}
196
197	// restore old state
198	state.pos = old_pos;
199
200	let cache = state.inline_ext.get_or_insert_default::<LinkLabelScanCache>();
201	cache.0.insert((start, enable_nested), label_end);
202
203	label_end
204	}
205
206
207	pub struct ParseLinkFragmentResult {
208	/// end position
209	pub pos: usize,
210	/// number of linebreaks inside
211	pub lines: usize,
212	/// parsed result
213	pub str: String,
214	}
215
216
217	/// Helper function used to parse `<href>` part of the links with optional brackets.
218	pub fn parse_link_destination(str: &str, start: usize, max: usize) -> Option<ParseLinkFragmentResult> {
219	let mut chars = str[start..max].chars().peekable();
220	let mut pos = start;
221
222	if let Some('<') = chars.peek() {
223	chars.next(); // skip '<'
224	pos += 1;
225	loop {
226	match chars.next() {
227	Some('\n' \| '<') \| None => return None,
228	Some('>') => {
229	return Some(ParseLinkFragmentResult {
230	pos: pos + 1,
231	lines: 0,
232	str: unescape_all(&str[start + 1..pos]).into_owned(),
233	});
234	}
235	Some('\\') => {
236	match chars.next() {
237	None => return None,
238	Some(x) => pos += 1 + x.len_utf8(),
239	}
240	}
241	Some(x) => {
242	pos += x.len_utf8();
243	}
244	}
245	}
246	} else {
247	let mut level : u32 = 0;
248	loop {
249	match chars.next() {
250	// space + ascii control characters
251	Some('\0'..=' ' \| '\x7f') \| None => break,
252	Some('\\') => {
253	match chars.next() {
254	Some(' ') \| None => break,
255	Some(x) => pos += 1 + x.len_utf8(),
256	}
257	}
258	Some('(') => {
259	level += 1;
260	if level > 32 { return None; }
261	pos += 1;
262	}
263	Some(')') => {
264	if level == 0 { break; }
265	level -= 1;
266	pos += 1;
267	}
268	Some(x) => {
269	pos += x.len_utf8();
270	}
271	}
272	}
273
274	if level != 0 { return None; }
275
276	Some(ParseLinkFragmentResult {
277	pos,
278	lines: 0,
279	str: unescape_all(&str[start..pos]).into_owned(),
280	})
281	}
282	}
283
284
285	/// Helper function used to parse `"title"` part of the links (with `'title'` or `(title)` alternative syntax).
286	pub fn parse_link_title(str: &str, start: usize, max: usize) -> Option<ParseLinkFragmentResult> {
287	let mut chars = str[start..max].chars();
288	let mut pos = start + 1;
289	let mut lines = 0;
290
291	let marker = match chars.next() {
292	Some('"') => '"',
293	Some('\'') => '\'',
294	Some('(') => ')',
295	None \| Some(_) => return None,
296	};
297
298	loop {
299	match chars.next() {
300	Some(ch) if ch == marker => {
301	return Some(ParseLinkFragmentResult {
302	pos: pos + 1,
303	lines,
304	str: unescape_all(&str[start + 1..pos]).into_owned(),
305	});
306	}
307	Some('(') if marker == ')' => {
308	return None;
309	}
310	Some('\n') => {
311	pos += 1;
312	lines += 1;
313	}
314	Some('\\') => {
315	match chars.next() {
316	None => return None,
317	Some(x) => pos += 1 + x.len_utf8(),
318	}
319	}
320	Some(x) => {
321	pos += x.len_utf8();
322	}
323	None => {
324	return None;
325	}
326	}
327	}
328	}
329
330	struct ParseLinkResult {
331	pub label_start: usize,
332	pub label_end: usize,
333	pub href: Option<String>,
334	pub title: Option<String>,
335	pub end: usize,
336	}
337
338	// Parses [link](<to> "stuff")
339	//
340	// this function assumes that first character ("[") already matches
341	//
342	fn parse_link(state: &mut InlineState, pos: usize, enable_nested: bool) -> Option<ParseLinkResult> {
343	let label_end = parse_link_label(state, pos, enable_nested)?;
344	let label_start = pos + 1;
345	let mut pos = label_end + 1;
346	let mut chars = state.src[pos..state.pos_max].chars();
347	let mut href = None;
348	let mut title = None;
349
350	if let Some('(') = chars.next() {
351	//
352	// Inline link
353	//
354
355	// [link]( <href> "title" )
356	// ^^ skipping these spaces
357	pos += 1;
358	while let Some(' ' \| '\t' \| '\n') = chars.next() {
359	pos += 1;
360	}
361
362	// [link]( <href> "title" )
363	// ^^^^^^ parsing link destination
364	if let Some(res) = parse_link_destination(&state.src, pos, state.pos_max) {
365	let href_candidate = state.md.link_formatter.normalize_link(&res.str);
366	if state.md.link_formatter.validate_link(&href_candidate).is_some() {
367	pos = res.pos;
368	href = Some(href_candidate);
369	}
370
371	// [link]( <href> "title" )
372	// ^^ skipping these spaces
373	let mut chars = state.src[pos..state.pos_max].chars();
374	while let Some(' ' \| '\t' \| '\n') = chars.next() {
375	pos += 1;
376	}
377
378	if let Some(res) = parse_link_title(&state.src, pos, state.pos_max) {
379	title = Some(res.str);
380	pos = res.pos;
381
382	// [link]( <href> "title" )
383	// ^^ skipping these spaces
384	let mut chars = state.src[pos..state.pos_max].chars();
385	while let Some(' ' \| '\t' \| '\n') = chars.next() {
386	pos += 1;
387	}
388	}
389	}
390
391	if let Some(')') = state.src[pos..state.pos_max].chars().next() {
392	return Some(ParseLinkResult {
393	label_start,
394	label_end,
395	href,
396	title,
397	end: pos + 1,
398	})
399	}
400	}
401
402	//
403	// Link reference
404	//
405	// TODO: check if I have any references?
406	pos = label_end + 1;
407	let mut maybe_label = None;
408
409	match state.src[pos..state.pos_max].chars().next() {
410	Some('[') => {
411	if let Some(x) = parse_link_label(state, pos, false) {
412	maybe_label = Some(&state.src[pos + 1..x]);
413	pos = x + 1;
414	} else {
415	pos = label_end + 1;
416	}
417	}
418	_ => pos = label_end + 1,
419	}
420
421	let references = state.root_ext.get::<ReferenceMap>()?;
422
423	// covers label === '' and label === undefined
424	// (collapsed reference link and shortcut reference link respectively)
425	let label = if matches!(maybe_label, None \| Some("")) {
426	&state.src[label_start..label_end]
427	} else {
428	maybe_label.unwrap()
429	};
430
431	let (destination, title) = references.get(label)?;
432
433	Some(ParseLinkResult {
434	label_start,
435	label_end,
436	href: Some(destination.to_owned()),
437	title: title.map(\|s\| s.to_owned()),
438	end: pos,
439	})
440	}

crates/markdown-it/src/generics/inline/mod.rs created+4

...	@@ -0,0 +1,4 @@
1	//! Generic inline-level structures.
2	pub mod code_pair;
3	pub mod emph_pair;
4	pub mod full_link;

crates/markdown-it/src/generics/mod.rs created+12

...	@@ -0,0 +1,12 @@
1	//! Use these to build your own markdown syntax.
2	//!
3	//! Some markdown structures are very similar under the hood, for example:
4	//! - `emphasis`, `^supertext^` and `~~strikethrough~~`
5	//! - `[link]()` and `![image]()`
6	//!
7	//! In order to reuse the code between all those, a notion of generic
8	//! markdown structures was created. If you want to use syntax like
9	//! `=this=` or `++that++`, you only need to specify a character marker
10	//! and a renderer function, these rules will figure out the rest.
11	//!
12	pub mod inline;

crates/markdown-it/src/lib.rs created+29

...	@@ -0,0 +1,29 @@
1	// for bragging rights
2	#![forbid(unsafe_code)]
3	//
4	// useful asserts that's off by default
5	#![warn(clippy::manual_assert)]
6	#![warn(clippy::semicolon_if_nothing_returned)]
7	//
8	// these are often intentionally not collapsed for readability
9	#![allow(clippy::collapsible_else_if)]
10	#![allow(clippy::collapsible_if)]
11	#![allow(clippy::collapsible_match)]
12	//
13	// these are intentional in bevy systems: nobody is directly calling those,
14	// so extra arguments don't decrease readability
15	#![allow(clippy::too_many_arguments)]
16	#![allow(clippy::type_complexity)]
17	//
18	// just a style choice that clippy has no business complaining about
19	#![allow(clippy::uninlined_format_args)]
20
21	pub mod common;
22	pub mod examples;
23	pub mod generics;
24	pub mod parser;
25	pub mod plugins;
26
27	pub use parser::main::MarkdownIt;
28	pub use parser::node::{Node, NodeValue};
29	pub use parser::renderer::Renderer;

crates/markdown-it/src/parser/block/builtin/block_parser.rs created+23

...	@@ -0,0 +1,23 @@
1	use crate::parser::core::{CoreRule, Root};
2	use crate::{MarkdownIt, Node};
3
4	pub fn add(md: &mut MarkdownIt) {
5	md.add_rule::<BlockParserRule>()
6	.before_all();
7	}
8
9	pub struct BlockParserRule;
10	impl CoreRule for BlockParserRule {
11	fn run(root: &mut Node, md: &MarkdownIt) {
12	let mut node = std::mem::take(root);
13	let data = node.cast_mut::<Root>().unwrap();
14	let source = std::mem::take(&mut data.content);
15	let mut ext = std::mem::take(&mut data.ext);
16
17	node = md.block.parse(source.as_str(), node, md, &mut ext);
18	let data = node.cast_mut::<Root>().unwrap();
19	data.content = source;
20	data.ext = ext;
21	*root = node;
22	}
23	}

crates/markdown-it/src/parser/block/builtin/mod.rs created+9

...	@@ -0,0 +1,9 @@
1	use crate::MarkdownIt;
2
3	pub(super) mod block_parser;
4
5	pub use block_parser::BlockParserRule;
6
7	pub fn add(md: &mut MarkdownIt) {
8	block_parser::add(md);
9	}

crates/markdown-it/src/parser/block/mod.rs created+127

...	@@ -0,0 +1,127 @@
1	//! Block rule chain
2	mod state;
3	pub use state::*;
4
5	mod rule;
6	pub use rule::*;
7
8	#[doc(hidden)]
9	pub mod builtin;
10
11	use crate::common::ruler::Ruler;
12	use crate::common::TypeKey;
13	use crate::parser::extset::RootExtSet;
14	use crate::parser::inline::InlineRoot;
15	use crate::parser::node::NodeEmpty;
16	use crate::{MarkdownIt, Node};
17
18	type RuleFns = (
19	fn (&mut BlockState) -> Option<()>,
20	fn (&mut BlockState) -> Option<(Node, usize)>,
21	);
22
23	#[derive(Debug, Default)]
24	/// Block-level tokenizer.
25	pub struct BlockParser {
26	ruler: Ruler<TypeKey, RuleFns>,
27	}
28
29	impl BlockParser {
30	pub fn new() -> Self {
31	Self::default()
32	}
33
34	/// Generate tokens for input range
35	///
36	pub fn tokenize(&self, state: &mut BlockState) {
37	stacker::maybe_grow(641024, 10241024, \|\| {
38	let mut has_empty_lines = false;
39
40	while state.line < state.line_max {
41	state.line = state.skip_empty_lines(state.line);
42	if state.line >= state.line_max { break; }
43
44	// Termination condition for nested calls.
45	// Nested calls currently used for blockquotes & lists
46	if state.line_indent(state.line) < 0 { break; }
47
48	// If nesting level exceeded - skip tail to the end. That's not ordinary
49	// situation and we should not care about content.
50	if state.level >= state.md.max_nesting {
51	state.line = state.line_max;
52	break;
53	}
54
55	// Try all possible rules.
56	// On success, rule should:
57	//
58	// - update `state.line`
59	// - update `state.tokens`
60	// - return true
61	let mut ok = None;
62
63	for rule in self.ruler.iter() {
64	ok = rule.1(state);
65	if ok.is_some() {
66	break;
67	}
68	}
69
70	if let Some((mut node, len)) = ok {
71	state.line += len;
72	if !node.is::<NodeEmpty>() {
73	node.srcmap = state.get_map(state.line - len, state.line - 1);
74	state.node.children.push(node);
75	}
76	} else {
77	// this can only happen if user disables paragraph rule
78	// push text as is, this behavior can change in the future;
79	// users should always have some kind of default block rule
80	let mut content = state.get_line(state.line).to_owned();
81	content.push('\n');
82	let node = Node::new(InlineRoot::new(
83	content,
84	vec![(0, state.line_offsets[state.line].first_nonspace)],
85	));
86	state.node.children.push(node);
87	state.line += 1;
88	}
89
90	// set state.tight if we had an empty line before current tag
91	// i.e. latest empty line should not count
92	state.tight = !has_empty_lines;
93
94	// paragraph might "eat" one newline after it in nested lists
95	if state.is_empty(state.line - 1) {
96	has_empty_lines = true;
97	}
98
99	if state.line < state.line_max && state.is_empty(state.line) {
100	has_empty_lines = true;
101	state.line += 1;
102	}
103	}
104	});
105	}
106
107	/// Process input string and push block tokens into `out_tokens`
108	///
109	pub fn parse(&self, src: &str, node: Node, md: &MarkdownIt, root_ext: &mut RootExtSet) -> Node {
110	let mut state = BlockState::new(src, md, root_ext, node);
111	self.tokenize(&mut state);
112	state.node
113	}
114
115	pub fn add_rule<T: BlockRule>(&mut self) -> RuleBuilder<RuleFns> {
116	let item = self.ruler.add(TypeKey::of::<T>(), (T::check, T::run));
117	RuleBuilder::new(item)
118	}
119
120	pub fn has_rule<T: BlockRule>(&mut self) -> bool {
121	self.ruler.contains(TypeKey::of::<T>())
122	}
123
124	pub fn remove_rule<T: BlockRule>(&mut self) {
125	self.ruler.remove(TypeKey::of::<T>());
126	}
127	}

crates/markdown-it/src/parser/block/rule.rs created+13

...	@@ -0,0 +1,13 @@
1	use crate::parser::core::rule_builder;
2	use crate::Node;
3
4	/// Each member of block rule chain must implement this trait
5	pub trait BlockRule : 'static {
6	fn check(state: &mut super::BlockState) -> Option<()> {
7	Self::run(state).map(\|_\| ())
8	}
9
10	fn run(state: &mut super::BlockState) -> Option<(Node, usize)>;
11	}
12
13	rule_builder!(BlockRule);

crates/markdown-it/src/parser/block/state.rs created+272

...	@@ -0,0 +1,272 @@
1	// Parser state class
2	//
3	use crate::common::sourcemap::SourcePos;
4	use crate::common::utils::calc_right_whitespace_with_tabstops;
5	use crate::parser::extset::RootExtSet;
6	use crate::{MarkdownIt, Node};
7
8	#[derive(Debug)]
9	#[readonly::make]
10	/// Sandbox object containing data required to parse block structures.
11	pub struct BlockState<'a, 'b> where 'b: 'a {
12	/// Markdown source.
13	#[readonly]
14	pub src: &'b str,
15
16	/// Link to parser instance.
17	#[readonly]
18	pub md: &'a MarkdownIt,
19
20	pub root_ext: &'b mut RootExtSet,
21
22	/// Current node, your rule is supposed to add children to it.
23	pub node: Node,
24
25	pub line_offsets: Vec<LineOffset>,
26
27	/// Current block content indent (for example, if we are
28	/// inside a list, it would be positioned after list marker).
29	pub blk_indent: usize,
30
31	/// Current line in src.
32	pub line: usize,
33
34	/// Maximum allowed line in src.
35	pub line_max: usize,
36
37	/// True if there are no empty lines between paragraphs, used to
38	/// toggle loose/tight mode for lists.
39	pub tight: bool,
40
41	/// indent of the current list block.
42	pub list_indent: Option<u32>,
43
44	pub level: u32,
45	}
46
47	/// Holds start/end/etc. positions for a specific source text line.
48	#[derive(Debug, Clone)]
49	pub struct LineOffset {
50	/// `line_start` is the actual start of the line.
51	///
52	/// # const IGNORE : &str = stringify! {
53	/// " > blockquote\r\n"
54	/// ^-- it will always point here (must not be modified by rules)
55	/// # };
56	pub line_start: usize,
57
58	/// `line_end` is first newline character after the line,
59	/// or position after string length if there aren't any newlines left.
60	///
61	/// # const IGNORE : &str = stringify! {
62	/// " > blockquote\r\n"
63	/// ^-- it will point here
64	/// # };
65	pub line_end: usize,
66
67	/// `first_nonspace` is the byte offset of the first non-space character in
68	/// the current line.
69	///
70	/// # const IGNORE : &str = stringify! {
71	/// " > blockquote\r\n"
72	/// ^-- it will point here when paragraph is parsed
73	/// ^----- it is initially pointed here
74	/// # };
75	///
76	/// It will be modified by rules (list and blockquote), chars before it
77	/// must be treated as whitespaces.
78	///
79	pub first_nonspace: usize,
80
81	/// `indent_nonspace` is the indent (amount of virtual spaces from start)
82	/// of first non-space character in the current line, taking into account
83	/// tab expansion.
84	///
85	/// For example, in case of ` \t foo`, indent is 5 (tab ends at multiple of 4,
86	/// then one space after it). Only tabs and spaces are counted for it,
87	/// so no funny unicode business (if cmark supported unicode spaces, they'd
88	/// be counted as 1 each regardless of utf8 width).
89	///
90	/// You should compare `indent_nonspace` with `state.blkindent` when determining
91	/// real indent after taking into account lists.
92	///
93	/// Most block rules in commonmark are indented 0..=3, and >=4 is code block.
94	/// Special value of ident_nonspace=-1 is used by this library as a sign
95	/// that this rule can only be a paragraph continuation (used in blockquotes),
96	/// so you must take into account that any math can end up negative.
97	///
98	pub indent_nonspace: i32,
99	}
100
101	impl<'a, 'b> BlockState<'a, 'b> {
102	pub fn new(src: &'b str, md: &'a MarkdownIt, root_ext: &'b mut RootExtSet, node: Node) -> Self {
103	let mut result = Self {
104	src,
105	md,
106	root_ext,
107	node,
108	line_offsets: Vec::new(),
109	blk_indent: 0,
110	line: 0,
111	line_max: 0,
112	tight: false,
113	list_indent: None,
114	level: 0,
115	};
116
117	result.generate_caches();
118	result
119	}
120
121	fn generate_caches(&mut self) {
122	// Create caches
123	// Generate markers.
124	let mut chars = self.src.chars().peekable();
125	let mut indent_found = false;
126	let mut indent = 0;
127	let mut offset = 0;
128	let mut start = 0;
129	let mut pos = 0;
130
131	loop {
132	match chars.next() {
133	Some(ch @ (' ' \| '\t')) if !indent_found => {
134	indent += 1;
135	offset += if ch == '\t' { 4 - offset % 4 } else { 1 };
136	pos += 1;
137	}
138	ch @ (Some('\n' \| '\r') \| None) => {
139	self.line_offsets.push(LineOffset {
140	line_start: start,
141	line_end: pos,
142	first_nonspace: start + indent,
143	indent_nonspace: offset,
144	});
145
146	if ch == Some('\r') && chars.peek() == Some(&'\n') {
147	// treat CR+LF as one linebreak
148	chars.next();
149	pos += 1;
150	}
151
152	indent_found = false;
153	indent = 0;
154	offset = 0;
155	start = pos + 1;
156	pos += 1;
157
158	if ch.is_none() \|\| chars.peek().is_none() {
159	break;
160	}
161	}
162	Some(ch) => {
163	indent_found = true;
164	pos += ch.len_utf8();
165	}
166	}
167	}
168
169	self.line_max = self.line_offsets.len();
170	}
171
172	#[must_use]
173	pub fn test_rules_at_line(&mut self) -> bool {
174	for rule in self.md.block.ruler.iter() {
175	if rule.0(self).is_some() {
176	return true;
177	}
178	}
179	false
180	}
181
182	#[must_use]
183	#[inline]
184	pub fn is_empty(&self, line: usize) -> bool {
185	if let Some(offsets) = self.line_offsets.get(line) {
186	offsets.first_nonspace >= offsets.line_end
187	} else {
188	false
189	}
190	}
191
192	pub fn skip_empty_lines(&self, from: usize) -> usize {
193	let mut line = from;
194	while line != self.line_max && self.is_empty(line) {
195	line += 1;
196	}
197	line
198	}
199
200	/// return line indent of specific line, taking into account blockquotes and lists;
201	/// it may be negative if a text has less indentation than current list item
202	#[must_use]
203	#[inline]
204	pub fn line_indent(&self, line: usize) -> i32 {
205	if line < self.line_max {
206	self.line_offsets[line].indent_nonspace - self.blk_indent as i32
207	} else {
208	0
209	}
210	}
211
212	/// return a single line, trimming initial spaces
213	#[must_use]
214	#[inline]
215	pub fn get_line(&self, line: usize) -> &str {
216	if line < self.line_max {
217	let pos = self.line_offsets[line].first_nonspace;
218	let max = self.line_offsets[line].line_end;
219	&self.src[pos..max]
220	} else {
221	""
222	}
223	}
224
225	/// Cut a range of lines begin..end (not including end) from the source without preceding indent.
226	/// Returns a string (lines) plus a mapping (start of each line in result -> start of each line in source).
227	pub fn get_lines(&self, begin: usize, end: usize, indent: usize, keep_last_lf: bool) -> (String, Vec<(usize, usize)>) {
228	debug_assert!(begin <= end);
229
230	let mut line = begin;
231	let mut result = String::new();
232	let mut mapping = Vec::new();
233
234	while line < end {
235	let offsets = &self.line_offsets[line];
236	let last = offsets.line_end;
237	let add_last_lf = line + 1 < end \|\| keep_last_lf;
238
239	let (num_spaces, first) = calc_right_whitespace_with_tabstops(
240	&self.src[offsets.line_start..offsets.first_nonspace],
241	offsets.indent_nonspace - indent as i32
242	);
243
244	mapping.push(( result.len(), offsets.line_start+first ));
245	result += &" ".repeat(num_spaces);
246	result += &self.src[offsets.line_start+first..last];
247	if add_last_lf { result.push('\n'); }
248	line += 1;
249	}
250
251	( result, mapping )
252	}
253
254	#[must_use]
255	#[inline]
256	pub fn get_map(&self, start_line: usize, end_line: usize) -> Option<SourcePos> {
257	debug_assert!(start_line <= end_line);
258
259	Some(SourcePos::new(
260	self.line_offsets[start_line].first_nonspace,
261	self.line_offsets[end_line].line_end
262	))
263	}
264
265	#[must_use]
266	#[inline]
267	pub fn get_map_from_offsets(&self, start_pos: usize, end_pos: usize) -> Option<SourcePos> {
268	debug_assert!(start_pos <= end_pos);
269
270	Some(SourcePos::new(start_pos, end_pos))
271	}
272	}

crates/markdown-it/src/parser/core/mod.rs created+6

...	@@ -0,0 +1,6 @@
1	//! Core rule chain
2	mod rule;
3	pub use rule::*;
4
5	mod root;
6	pub use root::*;

crates/markdown-it/src/parser/core/root.rs created+21

...	@@ -0,0 +1,21 @@
1	use crate::parser::extset::RootExtSet;
2	use crate::{Node, NodeValue, Renderer};
3
4	#[derive(Debug)]
5	/// Root node of the AST.
6	pub struct Root {
7	pub content: String,
8	pub ext: RootExtSet,
9	}
10
11	impl Root {
12	pub fn new(content: String) -> Self {
13	Self { content, ext: RootExtSet::new() }
14	}
15	}
16
17	impl NodeValue for Root {
18	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
19	fmt.contents(&node.children);
20	}
21	}

crates/markdown-it/src/parser/core/rule.rs created+55

...	@@ -0,0 +1,55 @@
1	use crate::{MarkdownIt, Node};
2
3	/// Each member of core rule chain must implement this trait
4	pub trait CoreRule : 'static {
5	fn run(root: &mut Node, md: &MarkdownIt);
6	}
7
8	macro_rules! rule_builder {
9	($var: ident) => {
10	/// Adjust positioning of a newly added rule in the chain.
11	pub struct RuleBuilder<'a, T> {
12	item: &'a mut crate::common::ruler::RuleItem<crate::common::TypeKey, T>
13	}
14
15	impl<'a, T> RuleBuilder<'a, T> {
16	pub(crate) fn new(item: &'a mut crate::common::ruler::RuleItem<crate::common::TypeKey, T>) -> Self {
17	Self { item }
18	}
19
20	pub fn before<U: $var>(self) -> Self {
21	self.item.before(crate::common::TypeKey::of::<U>());
22	self
23	}
24
25	pub fn after<U: $var>(self) -> Self {
26	self.item.after(crate::common::TypeKey::of::<U>());
27	self
28	}
29
30	pub fn before_all(self) -> Self {
31	self.item.before_all();
32	self
33	}
34
35	pub fn after_all(self) -> Self {
36	self.item.after_all();
37	self
38	}
39
40	pub fn alias<U: $var>(self) -> Self {
41	self.item.alias(crate::common::TypeKey::of::<U>());
42	self
43	}
44
45	pub fn require<U: $var>(self) -> Self {
46	self.item.require(crate::common::TypeKey::of::<U>());
47	self
48	}
49	}
50	};
51	}
52
53	rule_builder!(CoreRule);
54
55	pub(crate) use rule_builder;

crates/markdown-it/src/parser/extset.rs created+232

...	@@ -0,0 +1,232 @@
1	//! Extension sets
2	//!
3	//! These things allow you to put custom data inside internal markdown-it structures.
4	//!
5	use downcast_rs::{impl_downcast, Downcast};
6	use std::fmt::Debug;
7
8	/// Extension set member for the entire parser (only writable at init).
9	pub trait MarkdownItExt : Debug + Downcast + Send + Sync {}
10	impl_downcast!(MarkdownItExt);
11	extension_set!(MarkdownItExtSet, MarkdownItExt);
12
13	/// Extension set member for an arbitrary AST node.
14	pub trait NodeExt : Debug + Downcast + Send + Sync {}
15	impl_downcast!(NodeExt);
16	extension_set!(NodeExtSet, NodeExt);
17
18	/// Extension set member for an inline context.
19	pub trait InlineRootExt : Debug + Downcast + Send + Sync {}
20	impl_downcast!(InlineRootExt);
21	extension_set!(InlineRootExtSet, InlineRootExt);
22
23	/// Extension set member for a block context.
24	pub trait RootExt : Debug + Downcast + Send + Sync {}
25	impl_downcast!(RootExt);
26	extension_set!(RootExtSet, RootExt);
27
28	/// Extension set member for a renderer context.
29	pub trait RenderExt : Debug + Downcast + Send + Sync {}
30	impl_downcast!(RenderExt);
31	extension_set!(RenderExtSet, RenderExt);
32
33	// see https://github.com/malobre/erased_set for inspiration and API
34	// see https://lucumr.pocoo.org/2022/1/7/as-any-hack/ for additional impl details
35	macro_rules! extension_set {
36	($name: ident, $trait: ident) => {
37	#[derive(Debug, Default)]
38	pub struct $name(::std::collections::HashMap<crate::common::TypeKey, Box<dyn $trait>>);
39
40	impl $name {
41	#[must_use]
42	pub fn new() -> Self {
43	Self::default()
44	}
45
46	#[must_use]
47	pub fn is_empty(&self) -> bool {
48	self.0.is_empty()
49	}
50
51	#[must_use]
52	pub fn len(&self) -> usize {
53	self.0.len()
54	}
55
56	pub fn clear(&mut self) {
57	self.0.clear();
58	}
59
60	#[must_use]
61	pub fn contains<T: 'static>(&self) -> bool {
62	let key = crate::common::TypeKey::of::<T>();
63	self.0.contains_key(&key)
64	}
65
66	#[must_use]
67	pub fn get<T: $trait>(&self) -> Option<&T> {
68	let key = crate::common::TypeKey::of::<T>();
69	let result = self.0.get(&key)?;
70	result.downcast_ref::<T>()
71	}
72
73	#[must_use]
74	pub fn get_mut<T: $trait>(&mut self) -> Option<&mut T> {
75	let key = crate::common::TypeKey::of::<T>();
76	let result = self.0.get_mut(&key)?;
77	result.downcast_mut::<T>()
78	}
79
80	pub fn get_or_insert<T: $trait>(&mut self, value: T) -> &mut T {
81	let key = crate::common::TypeKey::of::<T>();
82	let result = self.0.entry(key).or_insert_with(\|\| Box::new(value));
83	result.downcast_mut::<T>().unwrap()
84	}
85
86	pub fn get_or_insert_with<T: $trait>(&mut self, f: impl FnOnce() -> T) -> &mut T {
87	let key = crate::common::TypeKey::of::<T>();
88	let result = self.0.entry(key).or_insert_with(\|\| Box::new(f()));
89	result.downcast_mut::<T>().unwrap()
90	}
91
92	pub fn get_or_insert_default<T: $trait + Default>(&mut self) -> &mut T {
93	let key = crate::common::TypeKey::of::<T>();
94	let result = self.0.entry(key).or_insert_with(\|\| Box::<T>::default());
95	result.downcast_mut::<T>().unwrap()
96	}
97
98	pub fn insert<T: $trait>(&mut self, value: T) -> Option<T> {
99	let key = crate::common::TypeKey::of::<T>();
100	let result = self.0.insert(key, Box::new(value))?;
101	Some(*result.downcast::<T>().unwrap())
102	}
103
104	pub fn remove<T: $trait>(&mut self) -> Option<T> {
105	let key = crate::common::TypeKey::of::<T>();
106	let result = self.0.remove(&key)?;
107	Some(*result.downcast::<T>().unwrap())
108	}
109	}
110	}
111	}
112
113	pub(crate) use extension_set;
114
115	#[cfg(test)]
116	mod tests {
117	use super::extension_set;
118	use downcast_rs::{Downcast, impl_downcast};
119	use std::fmt::Debug;
120
121	pub trait TestExt : Debug + Downcast + Send + Sync {}
122	impl_downcast!(TestExt);
123
124	extension_set!(TestExtSet, TestExt);
125
126	impl<T: Debug + Downcast + Send + Sync> TestExt for T {}
127
128	#[test]
129	fn empty_set() {
130	let set = TestExtSet::new();
131	assert_eq!(set.len(), 0);
132	assert!(set.is_empty());
133	}
134
135	#[test]
136	fn insert_elements() {
137	let mut set = TestExtSet::new();
138	set.insert(42u8);
139	assert_eq!(set.len(), 1);
140	assert!(!set.is_empty());
141	set.insert(42u16);
142	assert_eq!(set.len(), 2);
143	assert!(!set.is_empty());
144	}
145
146	#[test]
147	fn contains() {
148	let mut set = TestExtSet::new();
149	set.insert(42u8);
150	assert!(!set.contains::<u16>());
151	set.insert(42u16);
152	assert!(set.contains::<u16>());
153	set.remove::<u16>();
154	assert!(!set.contains::<u16>());
155	}
156
157	#[test]
158	fn get() {
159	let mut set = TestExtSet::new();
160	set.insert(42u8);
161	assert_eq!(set.get::<u16>(), None);
162	set.insert(42u16);
163	set.insert(123u16);
164	assert_eq!(set.get::<u16>(), Some(&123u16));
165	}
166
167	#[test]
168	fn get_mut() {
169	let mut set = TestExtSet::new();
170	set.insert(42u16);
171	*set.get_mut::<u16>().unwrap() = 123u16;
172	assert_eq!(set.get::<u16>(), Some(&123u16));
173	}
174
175	#[test]
176	fn or_insert() {
177	let mut set = TestExtSet::new();
178	set.insert(123u8);
179	assert_eq!(set.get_or_insert(0u8), &mut 123u8);
180	assert_eq!(set.get_or_insert_default::<u8>(), &mut 123u8);
181	assert_eq!(set.get_or_insert_with(\|\| 0u8), &mut 123u8);
182	set.clear();
183	assert_eq!(set.get_or_insert(10u8), &mut 10u8);
184	set.clear();
185	assert_eq!(set.get_or_insert_with(\|\| 20u8), &mut 20u8);
186	set.clear();
187	assert_eq!(set.get_or_insert_default::<u8>(), &mut 0u8);
188	}
189
190	#[test]
191	fn different_types_stored_once() {
192	let mut set = TestExtSet::new();
193	set.insert("foo");
194	set.insert("bar");
195	set.insert("quux");
196	assert_eq!(set.len(), 1);
197	}
198
199	#[test]
200	fn zero_sized_types() {
201	#[derive(Debug, PartialEq, Eq)]
202	struct A;
203	#[derive(Debug, PartialEq, Eq)]
204	struct B;
205	let mut set = TestExtSet::new();
206	set.insert(A);
207	set.insert(B);
208	assert_eq!(set.len(), 2);
209	assert_eq!(set.get::<A>(), Some(&A));
210	}
211
212	#[test]
213	fn clear() {
214	let mut set = TestExtSet::new();
215	set.insert(42u8);
216	set.insert(42u16);
217	assert_eq!(set.len(), 2);
218	set.clear();
219	assert_eq!(set.len(), 0);
220	}
221
222	#[test]
223	fn debug() {
224	let mut set = TestExtSet::new();
225	set.insert(42);
226	set.insert("test");
227	let str = format!("{:?}", set);
228	// there are no guarantees about field order, so check both
229	assert!(str == "TestExtSet({i32: 42, &str: \"test\"})" \|\|
230	str == "TestExtSet({&str: \"test\", i32: 42})");
231	}
232	}

crates/markdown-it/src/parser/inline/builtin/inline_parser.rs created+80

...	@@ -0,0 +1,80 @@
1	use crate::parser::block::builtin::BlockParserRule;
2	use crate::parser::core::{CoreRule, Root};
3	use crate::parser::extset::{InlineRootExtSet, RootExtSet};
4	use crate::{MarkdownIt, Node, NodeValue};
5
6	#[derive(Debug)]
7	/// Temporary node which gets replaced with inline nodes when
8	/// [InlineParser](crate::parser::inline::InlineParser) is called.
9	pub struct InlineRoot {
10	pub content: String,
11	pub mapping: Vec<(usize, usize)>,
12	pub ext: InlineRootExtSet,
13	}
14
15	impl InlineRoot {
16	pub fn new(content: String, mapping: Vec<(usize, usize)>) -> Self {
17	Self { content, mapping, ext: InlineRootExtSet::new() }
18	}
19	}
20
21	// this token is supposed to be replaced by one or many actual tokens by inline rule
22	impl NodeValue for InlineRoot {}
23
24	pub fn add(md: &mut MarkdownIt) {
25	md.add_rule::<InlineParserRule>()
26	.after::<BlockParserRule>()
27	.before_all();
28	}
29
30	pub struct InlineParserRule;
31	impl CoreRule for InlineParserRule {
32	fn run(root: &mut Node, md: &MarkdownIt) {
33	fn walk_recursive(node: &mut Node, md: &MarkdownIt, root_ext: &mut RootExtSet) {
34	let mut idx = 0;
35	while idx < node.children.len() {
36	let child = &mut node.children[idx];
37	if let Some(data) = child.cast_mut::<InlineRoot>() {
38	let content = std::mem::take(&mut data.content);
39	let mapping = std::mem::take(&mut data.mapping);
40	let mut inline_ext = std::mem::take(&mut data.ext);
41
42	let mut root = std::mem::take(child);
43	root.ext = std::mem::take(&mut node.ext);
44	root.children = Vec::new();
45	root = md.inline.parse(content, mapping, root, md, root_ext, &mut inline_ext);
46
47	let len = root.children.len();
48	node.children.splice(idx..=idx, std::mem::take(&mut root.children));
49	node.ext = std::mem::take(&mut root.ext);
50	idx += len;
51	} else {
52	stacker::maybe_grow(641024, 10241024, \|\| {
53	walk_recursive(child, md, root_ext);
54	});
55	idx += 1;
56	}
57	}
58	}
59
60	let data = root.cast_mut::<Root>().unwrap();
61	let mut root_ext = std::mem::take(&mut data.ext);
62
63	// this is invalid if input only contains reference;
64	// so if user disables block parser, he must insert smth like this instead
65	/*if root.children.is_empty() {
66	// block parser disabled, parse as if input was one big inline block
67	let data = root.cast_mut::<Root>().unwrap();
68	let node = Node::new(InlineRoot {
69	content: data.content.clone(),
70	mapping: vec![(0, 0)],
71	});
72	root.children.push(node);
73	}*/
74
75	walk_recursive(root, md, &mut root_ext);
76
77	let data = root.cast_mut::<Root>().unwrap();
78	data.ext = root_ext;
79	}
80	}

crates/markdown-it/src/parser/inline/builtin/mod.rs created+12

...	@@ -0,0 +1,12 @@
1	use crate::MarkdownIt;
2
3	pub(super) mod inline_parser;
4	pub(super) mod skip_text;
5
6	pub use inline_parser::InlineParserRule;
7	pub use skip_text::TextScanner;
8
9	pub fn add(md: &mut MarkdownIt) {
10	skip_text::add(md);
11	inline_parser::add(md);
12	}

crates/markdown-it/src/parser/inline/builtin/skip_text.rs created+140

...	@@ -0,0 +1,140 @@
1	//! Skip text characters for text token, place those to pending buffer
2	//! and increment current pos
3	//!
4	use regex::{self, Regex};
5
6	use crate::parser::inline::{InlineRule, InlineState};
7	use crate::{MarkdownIt, Node, NodeValue, Renderer};
8
9	#[derive(Debug)]
10	/// Plain text AST node.
11	pub struct Text {
12	pub content: String
13	}
14
15	impl NodeValue for Text {
16	fn render(&self, _: &Node, fmt: &mut dyn Renderer) {
17	fmt.text(&self.content);
18	}
19	}
20
21	#[derive(Debug)]
22	/// Escaped text AST node (backslash escapes and entities).
23	pub struct TextSpecial {
24	pub content: String,
25	pub markup: String,
26	pub info: &'static str,
27	}
28
29	impl NodeValue for TextSpecial {
30	fn render(&self, _: &Node, fmt: &mut dyn Renderer) {
31	fmt.text(&self.content);
32	}
33	}
34
35	pub fn add(md: &mut MarkdownIt) {
36	md.inline.add_rule::<TextScanner>()
37	.before_all();
38	}
39
40	#[derive(Debug)]
41	pub(crate) enum TextScannerImpl {
42	SkipPunct,
43	SkipRegex(Regex),
44	}
45
46	/// Rule to skip pure text
47	/// '{}$%@~+=:' reserved for extensions
48	///
49	/// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, \|, }, or ~
50	///
51	/// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
52	/// http://spec.commonmark.org/0.15/#ascii-punctuation-character
53	///
54	pub struct TextScanner;
55
56	impl TextScanner {
57	fn choose_text_impl(charmap: Vec<char>) -> TextScannerImpl {
58	let mut can_use_punct = true;
59	for ch in charmap.iter() {
60	match ch {
61	'\n' \| '!' \| '#' \| '$' \| '%' \| '&' \| '*' \| '+' \| '-' \|
62	':' \| '<' \| '=' \| '>' \| '@' \| '[' \| '\\' \| ']' \| '^' \|
63	'_' \| '`' \| '{' \| '}' \| '~' => {},
64	_ => {
65	can_use_punct = false;
66	break;
67	}
68	}
69	}
70
71	if can_use_punct {
72	TextScannerImpl::SkipPunct
73	} else {
74	TextScannerImpl::SkipRegex(
75	Regex::new(
76	// [] panics on "unclosed character class", but it cannot happen here
77	// (we'd use punct rule instead)
78	&format!("^[^{}]+", charmap.into_iter().map(
79	\|c\| regex::escape(&c.to_string())
80	).collect::<String>())
81	).unwrap()
82	)
83	}
84	}
85
86	fn find_text_length(state: &mut InlineState) -> usize {
87	let text_impl = state.md.inline.text_impl.get_or_init(
88	\|\| Self::choose_text_impl(state.md.inline.text_charmap.keys().copied().collect())
89	);
90
91	let mut len = 0;
92
93	match text_impl {
94	TextScannerImpl::SkipPunct => {
95	let mut chars = state.src[state.pos..state.pos_max].chars();
96
97	loop {
98	match chars.next() {
99	Some(
100	'\n' \| '!' \| '#' \| '$' \| '%' \| '&' \| '*' \| '+' \| '-' \|
101	':' \| '<' \| '=' \| '>' \| '@' \| '[' \| '\\' \| ']' \| '^' \|
102	'_' \| '`' \| '{' \| '}' \| '~'
103	) => {
104	break;
105	}
106	Some(chr) => {
107	len += chr.len_utf8();
108	}
109	None => { break; }
110	}
111	}
112	}
113	TextScannerImpl::SkipRegex(re) => {
114	if let Some(capture) = re.find(&state.src[state.pos..state.pos_max]) {
115	len = capture.end();
116	}
117	}
118	}
119
120	len
121	}
122	}
123
124	impl InlineRule for TextScanner {
125	const MARKER: char = '\0';
126
127	fn check(state: &mut InlineState) -> Option<usize> {
128	let len = Self::find_text_length(state);
129	if len == 0 { return None; }
130	Some(len)
131	}
132
133	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
134	let len = Self::find_text_length(state);
135	if len == 0 { return None; }
136	state.trailing_text_push(state.pos, state.pos + len);
137	state.pos += len;
138	Some((Node::default(), 0))
139	}
140	}

crates/markdown-it/src/parser/inline/mod.rs created+162

...	@@ -0,0 +1,162 @@
1	//! Inline rule chain
2	use once_cell::sync::OnceCell;
3	use std::collections::HashMap;
4
5	mod state;
6	pub use state::*;
7
8	mod rule;
9	pub use rule::*;
10
11	#[doc(hidden)]
12	pub mod builtin;
13
14	pub use builtin::inline_parser::InlineRoot;
15	pub use builtin::skip_text::{Text, TextSpecial};
16	use builtin::skip_text::TextScannerImpl;
17
18	use crate::{MarkdownIt, Node};
19	use crate::common::TypeKey;
20	use crate::common::ruler::Ruler;
21	use crate::parser::extset::{InlineRootExtSet, RootExtSet};
22
23	use super::node::NodeEmpty;
24
25	type RuleFns = (
26	fn (&mut InlineState) -> Option<usize>,
27	fn (&mut InlineState) -> Option<(Node, usize)>,
28	);
29
30	#[derive(Debug, Default)]
31	/// Inline-level tokenizer.
32	pub struct InlineParser {
33	ruler: Ruler<TypeKey, RuleFns>,
34	text_charmap: HashMap<char, Vec<TypeKey>>,
35	text_impl: OnceCell<TextScannerImpl>,
36	}
37
38	impl InlineParser {
39	pub fn new() -> Self {
40	Self::default()
41	}
42
43	/// Skip single token by running all rules in validation mode;
44	/// returns `true` if any rule reported success
45	///
46	pub fn skip_token(&self, state: &mut InlineState) {
47	stacker::maybe_grow(641024, 10241024, \|\| {
48	let mut ok = None;
49
50	if state.level < state.md.max_nesting {
51	for rule in self.ruler.iter() {
52	ok = rule.0(state);
53	if ok.is_some() {
54	break;
55	}
56	}
57	} else {
58	// Too much nesting, just skip until the end of the paragraph.
59	//
60	// NOTE: this will cause links to behave incorrectly in the following case,
61	// when an amount of `[` is exactly equal to `maxNesting + 1`:
62	//
63	// [[[[[[[[[[[[[[[[[[[[[foo]()
64	//
65	// TODO: remove this workaround when CM standard will allow nested links
66	// (we can replace it by preventing links from being parsed in
67	// validation mode)
68	//
69	state.pos = state.pos_max;
70	}
71
72	if let Some(len) = ok {
73	state.pos += len;
74	} else {
75	let ch = state.src[state.pos..state.pos_max].chars().next().unwrap();
76	state.pos += ch.len_utf8();
77	}
78	});
79	}
80
81	/// Generate tokens for input range
82	///
83	pub fn tokenize(&self, state: &mut InlineState) {
84	stacker::maybe_grow(641024, 10241024, \|\| {
85	let end = state.pos_max;
86
87	while state.pos < end {
88	// Try all possible rules.
89	// On success, rule should:
90	//
91	// - update `state.pos`
92	// - update `state.tokens`
93	// - return true
94	let mut ok = None;
95
96	if state.level < state.md.max_nesting {
97	for rule in self.ruler.iter() {
98	ok = rule.1(state);
99	if ok.is_some() {
100	break;
101	}
102	}
103	}
104
105	if let Some((mut node, len)) = ok {
106	state.pos += len;
107	if !node.is::<NodeEmpty>() {
108	node.srcmap = state.get_map(state.pos - len, state.pos);
109	state.node.children.push(node);
110	if state.pos >= end { break; }
111	}
112	continue;
113	}
114
115	let ch = state.src[state.pos..state.pos_max].chars().next().unwrap();
116	let len = ch.len_utf8();
117	state.trailing_text_push(state.pos, state.pos + len);
118	state.pos += len;
119	}
120	});
121	}
122
123	/// Process input string and push inline tokens into `out_tokens`
124	///
125	pub fn parse(
126	&self,
127	src: String,
128	srcmap: Vec<(usize, usize)>,
129	node: Node,
130	md: &MarkdownIt,
131	root_ext: &mut RootExtSet,
132	inline_ext: &mut InlineRootExtSet,
133	) -> Node {
134	let mut state = InlineState::new(src, srcmap, md, root_ext, inline_ext, node);
135	self.tokenize(&mut state);
136	state.node
137	}
138
139	pub fn add_rule<T: InlineRule>(&mut self) -> RuleBuilder<RuleFns> {
140	if T::MARKER != '\0' {
141	let charvec = self.text_charmap.entry(T::MARKER).or_default();
142	charvec.push(TypeKey::of::<T>());
143	}
144
145	let item = self.ruler.add(TypeKey::of::<T>(), (T::check, T::run));
146	RuleBuilder::new(item)
147	}
148
149	pub fn has_rule<T: InlineRule>(&mut self) -> bool {
150	self.ruler.contains(TypeKey::of::<T>())
151	}
152
153	pub fn remove_rule<T: InlineRule>(&mut self) {
154	if T::MARKER != '\0' {
155	let mut charvec = self.text_charmap.remove(&T::MARKER).unwrap_or_default();
156	charvec.retain(\|x\| *x != TypeKey::of::<T>());
157	self.text_charmap.insert(T::MARKER, charvec);
158	}
159
160	self.ruler.remove(TypeKey::of::<T>());
161	}
162	}

crates/markdown-it/src/parser/inline/rule.rs created+15

...	@@ -0,0 +1,15 @@
1	use crate::parser::core::rule_builder;
2	use crate::Node;
3
4	/// Each member of inline rule chain must implement this trait
5	pub trait InlineRule : 'static {
6	const MARKER: char;
7
8	fn check(state: &mut super::InlineState) -> Option<usize> {
9	Self::run(state).map(\|(_node, len)\| len)
10	}
11
12	fn run(state: &mut super::InlineState) -> Option<(Node, usize)>;
13	}
14
15	rule_builder!(InlineRule);

crates/markdown-it/src/parser/inline/state.rs created+244

...	@@ -0,0 +1,244 @@
1	// Inline parser state
2	//
3	use crate::common::sourcemap::SourcePos;
4	use crate::common::utils::is_punct_char;
5	use crate::parser::extset::{InlineRootExtSet, RootExtSet};
6	use crate::parser::inline::Text;
7	use crate::{MarkdownIt, Node};
8
9	#[derive(Debug, Clone, Copy)]
10	/// Information about emphasis delimiter run returned from [InlineState::scan_delims].
11	pub struct DelimiterRun {
12	/// Starting marker character.
13	pub marker: char,
14
15	/// Boolean flag that determines if this delimiter could open an emphasis.
16	pub can_open: bool,
17
18	/// Boolean flag that determines if this delimiter could open an emphasis.
19	pub can_close: bool,
20
21	/// Total length of scanned delimiters.
22	pub length: usize,
23	}
24
25	#[derive(Debug)]
26	#[readonly::make]
27	/// Sandbox object containing data required to parse inline structures.
28	pub struct InlineState<'a, 'b> where 'b: 'a {
29	/// Markdown source.
30	#[readonly]
31	pub src: String,
32
33	/// Link to parser instance.
34	#[readonly]
35	pub md: &'a MarkdownIt,
36
37	/// Current node, your rule is supposed to add children to it.
38	pub node: Node,
39
40	/// For each line, it holds offset of the start of the line in original
41	/// markdown source and offset of the start of the line in `src`.
42	pub srcmap: Vec<(usize, usize)>,
43	pub root_ext: &'b mut RootExtSet,
44	pub inline_ext: &'b mut InlineRootExtSet,
45
46	/// Current byte offset in `src`, it must respect char boundaries.
47	pub pos: usize,
48
49	/// Maximum allowed byte offset in `src`, it must respect char boundaries.
50	pub pos_max: usize,
51
52	/// Counter used to disable inline linkifier execution
53	/// inside raw html and markdown links.
54	pub link_level: i32,
55
56	/// Counter used to prevent recursion by image and link rules.
57	pub level: u32,
58	}
59
60	impl<'a, 'b> InlineState<'a, 'b> {
61	pub fn new(
62	src: String,
63	srcmap: Vec<(usize, usize)>,
64	md: &'a MarkdownIt,
65	root_ext: &'b mut RootExtSet,
66	inline_ext: &'b mut InlineRootExtSet,
67	node: Node,
68	) -> Self {
69	let mut result = Self {
70	pos: 0,
71	pos_max: src.len(),
72	src,
73	srcmap,
74	root_ext,
75	inline_ext,
76	md,
77	node,
78	link_level: 0,
79	level: 0,
80	};
81
82	result.trim_src();
83	result
84	}
85
86	fn trim_src(&mut self) {
87	let mut chars = self.src.as_bytes().iter();
88	while let Some(b' ' \| b'\t') = chars.next_back() {
89	self.pos_max -= 1;
90	}
91	while let Some(b' ' \| b'\t') = chars.next() {
92	self.pos += 1;
93	}
94	}
95
96	pub fn trailing_text_push(&mut self, start: usize, end: usize) {
97	if let Some(text) = self.node.children.last_mut()
98	.and_then(\|t\| t.cast_mut::<Text>()) {
99	text.content.push_str(&self.src[start..end]);
100
101	if let Some(map) = self.node.children.last_mut().unwrap().srcmap {
102	let (map_start, _) = map.get_byte_offsets();
103	let map_end = self.get_source_pos_for(end);
104	self.node.children.last_mut().unwrap().srcmap = Some(SourcePos::new(map_start, map_end));
105	}
106	} else {
107	let mut node = Node::new(Text { content: self.src[start..end].to_owned() });
108	node.srcmap = self.get_map(start, end);
109	self.node.children.push(node);
110	}
111	}
112
113	pub fn trailing_text_pop(&mut self, count: usize) {
114	if count == 0 { return; }
115
116	let mut node = self.node.children.pop().unwrap();
117	let text = node.cast_mut::<Text>().unwrap();
118	if text.content.len() == count {
119	// do nothing, just remove the node
120	drop(node);
121	} else {
122	// modify the token and reinsert it later
123	text.content.truncate(text.content.len() - count);
124	if let Some(map) = node.srcmap {
125	let (map_start, map_end) = map.get_byte_offsets();
126	let map_end = self.get_source_pos_for(map_end - count);
127	node.srcmap = Some(SourcePos::new(map_start, map_end));
128	}
129	self.node.children.push(node);
130	}
131	}
132
133	#[must_use]
134	pub fn trailing_text_get(&self) -> &str {
135	if let Some(text) = self.node.children.last()
136	.and_then(\|t\| t.cast::<Text>()) {
137	text.content.as_str()
138	} else {
139	""
140	}
141	}
142
143	/// Scan a sequence of emphasis-like markers, and determine whether
144	/// it can start an emphasis sequence or end an emphasis sequence.
145	///
146	/// - start - position to scan from (it should point at a valid marker);
147	/// - can_split_word - determine if these markers can be found inside a word
148	///
149	#[must_use]
150	pub fn scan_delims(&self, start: usize, can_split_word: bool) -> DelimiterRun {
151	let mut left_flanking = true;
152	let mut right_flanking = true;
153
154	let last_char = if start > 0 {
155	self.src[..start].chars().next_back().unwrap()
156	} else {
157	// treat beginning of the line as a whitespace
158	' '
159	};
160
161	let mut chars = self.src[start..self.pos_max].chars();
162	let marker = chars.next().unwrap();
163	let next_char;
164	let mut count = 1;
165
166	loop {
167	match chars.next() {
168	None => {
169	next_char = ' ';
170	break;
171	}
172	Some(x) => {
173	if x != marker {
174	// treat end of the line as a whitespace
175	next_char = x;
176	break;
177	}
178	}
179	}
180	count += 1;
181	}
182
183	let is_last_punct_char = last_char.is_ascii_punctuation() \|\| is_punct_char(last_char);
184	let is_next_punct_char = next_char.is_ascii_punctuation() \|\| is_punct_char(next_char);
185
186	let is_last_whitespace = last_char.is_whitespace();
187	let is_next_whitespace = next_char.is_whitespace();
188
189	#[allow(clippy::collapsible_if)]
190	if is_next_whitespace {
191	left_flanking = false;
192	} else if is_next_punct_char {
193	if !(is_last_whitespace \|\| is_last_punct_char) {
194	left_flanking = false;
195	}
196	}
197
198	#[allow(clippy::collapsible_if)]
199	if is_last_whitespace {
200	right_flanking = false;
201	} else if is_last_punct_char {
202	if !(is_next_whitespace \|\| is_next_punct_char) {
203	right_flanking = false;
204	}
205	}
206
207	let can_open;
208	let can_close;
209
210	if !can_split_word {
211	can_open = left_flanking && (!right_flanking \|\| is_last_punct_char);
212	can_close = right_flanking && (!left_flanking \|\| is_next_punct_char);
213	} else {
214	can_open = left_flanking;
215	can_close = right_flanking;
216	}
217
218	DelimiterRun {
219	marker,
220	can_open,
221	can_close,
222	length: count
223	}
224	}
225
226	#[must_use]
227	fn get_source_pos_for(&self, pos: usize) -> usize {
228	let line = match self.srcmap.binary_search_by(\|x\| x.0.cmp(&pos)) {
229	Ok(x) => x,
230	Err(x) => x - 1,
231	};
232	self.srcmap[line].1 + (pos - self.srcmap[line].0)
233	}
234
235	#[must_use]
236	pub fn get_map(&self, start_pos: usize, end_pos: usize) -> Option<SourcePos> {
237	debug_assert!(start_pos <= end_pos);
238
239	Some(SourcePos::new(
240	self.get_source_pos_for(start_pos),
241	self.get_source_pos_for(end_pos)
242	))
243	}
244	}

crates/markdown-it/src/parser/linkfmt.rs created+100

...	@@ -0,0 +1,100 @@
1	//! Link validator and formatter
2
3	use once_cell::sync::Lazy;
4	use regex::Regex;
5	use std::fmt::Debug;
6
7	pub trait LinkFormatter : Debug + Send + Sync {
8	/// Validate link url, return `Some(())` if it is allowed
9	/// and `None` if it is a security risk.
10	fn validate_link(&self, url: &str) -> Option<()>;
11
12	/// Encode link url to a machine-readable format,
13	/// which includes url-encoding, punycode, etc.
14	fn normalize_link(&self, url: &str) -> String;
15
16	/// Decode link url to a human-readable format.
17	fn normalize_link_text(&self, url: &str) -> String;
18	}
19
20	/// Default link validator and formatter for markdown-it.
21	///
22	/// This validator can prohibit more than really needed to prevent XSS. It's a
23	/// tradeoff to keep code simple and to be secure by default.
24	///
25	/// If you need different setup - override validator method as you wish. Or
26	/// replace it with dummy function and use external sanitizer.
27	///
28	#[derive(Default, Debug)]
29	pub struct MDLinkFormatter;
30
31	impl MDLinkFormatter {
32	pub fn new() -> Self {
33	Self
34	}
35	}
36
37	impl LinkFormatter for MDLinkFormatter {
38	fn validate_link(&self, url: &str) -> Option<()> {
39	// url should be normalized at this point, and existing entities are decoded
40	static BAD_PROTO_RE : Lazy<Regex> = Lazy::new(\|\|
41	Regex::new(r#"(?i)^(vbscript\|javascript\|file\|data):"#).unwrap()
42	);
43
44	static GOOD_DATA_RE : Lazy<Regex> = Lazy::new(\|\|
45	Regex::new(r#"(?i)^data:image/(gif\|png\|jpeg\|webp);"#).unwrap()
46	);
47
48	if !BAD_PROTO_RE.is_match(url) \|\| GOOD_DATA_RE.is_match(url) {
49	Some(())
50	} else {
51	None
52	}
53	}
54
55	fn normalize_link(&self, url: &str) -> String {
56	mdurl::urlencode::encode(url, mdurl::urlencode::ENCODE_DEFAULT_CHARS, true).into()
57	}
58
59	fn normalize_link_text(&self, url: &str) -> String {
60	url.to_owned()
61	}
62	}
63
64
65	#[cfg(test)]
66	mod tests {
67	use super::LinkFormatter;
68	use super::MDLinkFormatter;
69
70	#[test]
71	fn should_allow_normal_urls() {
72	let fmt = MDLinkFormatter::new();
73	assert!(fmt.validate_link("http://example.org").is_some());
74	assert!(fmt.validate_link("HTTPS://example.org").is_some());
75	}
76
77	#[test]
78	fn should_allow_plain_text() {
79	let fmt = MDLinkFormatter::new();
80	assert!(fmt.validate_link("javascript").is_some());
81	assert!(fmt.validate_link("/javascript:link").is_some());
82	}
83
84	#[test]
85	fn should_not_allow_some_protocols() {
86	let fmt = MDLinkFormatter::new();
87	assert!(fmt.validate_link("javascript:alert(1)").is_none());
88	assert!(fmt.validate_link("JAVASCRIPT:alert(1)").is_none());
89	assert!(fmt.validate_link("vbscript:alert(1)").is_none());
90	assert!(fmt.validate_link("VbScript:alert(1)").is_none());
91	assert!(fmt.validate_link("file:///123").is_none());
92	}
93
94	#[test]
95	fn should_not_allow_data_url_except_whitelisted() {
96	let fmt = MDLinkFormatter::new();
97	assert!(fmt.validate_link("data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7").is_some());
98	assert!(fmt.validate_link("data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K").is_none());
99	}
100	}

crates/markdown-it/src/parser/main.rs created+90

...	@@ -0,0 +1,90 @@
1	use derivative::Derivative;
2
3	use crate::common::ruler::Ruler;
4	use crate::common::sourcemap::SourcePos;
5	use crate::common::TypeKey;
6	use crate::parser::block::{self, BlockParser};
7	use crate::parser::core::{Root, *};
8	use crate::parser::extset::MarkdownItExtSet;
9	use crate::parser::inline::{self, InlineParser};
10	use crate::parser::linkfmt::{LinkFormatter, MDLinkFormatter};
11	use crate::Node;
12
13	type RuleFn = fn (&mut Node, &MarkdownIt);
14
15	#[derive(Derivative)]
16	#[derivative(Debug)]
17	/// Main parser struct, created once and reused for parsing multiple documents.
18	pub struct MarkdownIt {
19	/// Block-level tokenizer.
20	pub block: BlockParser,
21
22	/// Inline-level tokenizer.
23	pub inline: InlineParser,
24
25	/// Link validator and formatter.
26	pub link_formatter: Box<dyn LinkFormatter>,
27
28	/// Storage for custom data used in plugins.
29	pub ext: MarkdownItExtSet,
30
31	/// Maximum depth of the generated AST, exists to prevent recursion
32	/// (if markdown source reaches this depth, deeply nested structures
33	/// will be parsed as plain text).
34	/// TODO: doesn't work
35	#[doc(hidden)]
36	pub max_nesting: u32,
37
38	/// Maximum allowed indentation for syntax blocks
39	/// default i32::MAX, indented code blocks will set this to 4
40	pub max_indent: i32,
41
42	ruler: Ruler<TypeKey, RuleFn>,
43	}
44
45	impl MarkdownIt {
46	pub fn new() -> Self {
47	Self::default()
48	}
49
50	pub fn parse(&self, src: &str) -> Node {
51	let mut node = Node::new(Root::new(src.to_owned()));
52	node.srcmap = Some(SourcePos::new(0, src.len()));
53
54	for rule in self.ruler.iter() {
55	rule(&mut node, self);
56	debug_assert!(node.is::<Root>(), "root node of the AST must always be Root");
57	}
58	node
59	}
60
61	pub fn add_rule<T: CoreRule>(&mut self) -> RuleBuilder<RuleFn> {
62	let item = self.ruler.add(TypeKey::of::<T>(), T::run);
63	RuleBuilder::new(item)
64	}
65
66	pub fn has_rule<T: CoreRule>(&mut self) -> bool {
67	self.ruler.contains(TypeKey::of::<T>())
68	}
69
70	pub fn remove_rule<T: CoreRule>(&mut self) {
71	self.ruler.remove(TypeKey::of::<T>());
72	}
73	}
74
75	impl Default for MarkdownIt {
76	fn default() -> Self {
77	let mut md = Self {
78	block: BlockParser::new(),
79	inline: InlineParser::new(),
80	link_formatter: Box::new(MDLinkFormatter::new()),
81	ext: MarkdownItExtSet::new(),
82	max_nesting: 100,
83	ruler: Ruler::new(),
84	max_indent: i32::MAX,
85	};
86	block::builtin::add(&mut md);
87	inline::builtin::add(&mut md);
88	md
89	}
90	}

crates/markdown-it/src/parser/mod.rs created+45

...	@@ -0,0 +1,45 @@
1	//! Parser itself + stuff that allows you to extend it.
2	//!
3	//! In order to understand how this parser works, you need to understand the concept
4	//! of Rule Chains. "Rule Chain" is an ordered set of functions that get executed
5	//! sequentially. This is an example of a Rule Chain:
6	//!
7	//! ```rust
8	//! let rules : Vec<fn(&mut String)> = vec![
9	//! \|s\| { s.push_str("hello"); },
10	//! \|s\| { s.push(','); },
11	//! \|s\| { s.push(' '); },
12	//! \|s\| { s.push_str("world"); },
13	//! \|s\| { s.push('!'); },
14	//! ];
15	//! dbg!(rules.iter().fold(String::new(), \|mut s, f\| { f(&mut s); s }));
16	//! ```
17	//!
18	//! The example above builds a string using 5 independent functions. You can extend
19	//! it by pushing your own function in that vector that manipulate the state (String)
20	//! in any way you like.
21	//!
22	//! MarkdownIt parser consists of three Rule Chains:
23	//! - [inline] (where functions get executed on every character)
24	//! - [block] (where functions get executed on every line)
25	//! - [core] (where functions get executed once per document)
26	//!
27	//! You can extend each one of these chains by using
28	//! [md.inline.add_rule](inline::InlineParser::add_rule),
29	//! [md.block.add_rule](block::BlockParser::add_rule) or
30	//! [md.add_rule](crate::MarkdownIt::add_rule) respectively.
31	//!
32	//! These are examples of the rules in each chain (view source to see implementation):
33	//! - [inline rule](crate::plugins::cmark::inline::autolink) - autolink
34	//! - [block rule](crate::plugins::cmark::block::hr) - thematic break
35	//! - [core rule](crate::plugins::sourcepos) - source mapping
36	//!
37	pub mod block;
38	pub mod core;
39	pub mod extset;
40	pub mod inline;
41	pub mod linkfmt;
42
43	pub(super) mod main;
44	pub(super) mod node;
45	pub(super) mod renderer;

crates/markdown-it/src/parser/node.rs created+229

...	@@ -0,0 +1,229 @@
1	use downcast_rs::{impl_downcast, Downcast};
2	use std::any::TypeId;
3	use std::fmt::Debug;
4
5	use crate::common::sourcemap::SourcePos;
6	use crate::common::TypeKey;
7	use crate::parser::extset::NodeExtSet;
8	use crate::parser::inline::Text;
9	use crate::parser::renderer::HTMLRenderer;
10	use crate::plugins::cmark::inline::newline::Softbreak;
11	use crate::Renderer;
12
13	/// Single node in the CommonMark AST.
14	#[derive(Debug)]
15	#[readonly::make]
16	pub struct Node {
17	/// Array of child nodes.
18	pub children: Vec<Node>,
19
20	/// Source mapping info.
21	pub srcmap: Option<SourcePos>,
22
23	/// Custom data specific to this token.
24	pub ext: NodeExtSet,
25
26	/// Additional attributes to be added to resulting html.
27	pub attrs: Vec<(&'static str, String)>,
28
29	/// Type name, used for debugging.
30	#[readonly]
31	pub node_type: TypeKey,
32
33	/// Storage for arbitrary token-specific data.
34	#[readonly]
35	pub node_value: Box<dyn NodeValue>,
36	}
37
38	impl Node {
39	/// Create a new [Node](Node) with a custom value.
40	pub fn new<T: NodeValue>(value: T) -> Self {
41	Self {
42	children: Vec::new(),
43	srcmap: None,
44	attrs: Vec::new(),
45	ext: NodeExtSet::new(),
46	node_type: TypeKey::of::<T>(),
47	node_value: Box::new(value),
48	}
49	}
50
51	/// Return std::any::type_name() of node value.
52	pub fn name(&self) -> &'static str {
53	self.node_type.name
54	}
55
56	/// Check that this node value is of given type.
57	pub fn is<T: NodeValue>(&self) -> bool {
58	self.node_type.id == TypeId::of::<T>()
59	}
60
61	/// Downcast node value to specific type.
62	pub fn cast<T: NodeValue>(&self) -> Option<&T> {
63	if self.node_type.id == TypeId::of::<T>() {
64	Some(self.node_value.downcast_ref::<T>().unwrap())
65	// performance note: `node_type.id` improves walk speed by a LOT by removing indirection
66	// (~5% of overall program speed), so having type id duplicated in Node is very beneficial;
67	// we can also remove extra check with downcast_unchecked, but it doesn't do much
68	//Some(unsafe { &(&self.node_value as const dyn NodeValue as const T) })
69	} else {
70	None
71	}
72	}
73
74	/// Downcast node value to specific type.
75	pub fn cast_mut<T: NodeValue>(&mut self) -> Option<&mut T> {
76	if self.node_type.id == TypeId::of::<T>() {
77	Some(self.node_value.downcast_mut::<T>().unwrap())
78	// performance note: see above
79	//Some(unsafe { &mut (&mut self.node_value as mut dyn NodeValue as mut T) })
80	} else {
81	None
82	}
83	}
84
85	/// Render this node to HTML.
86	pub fn render(&self) -> String {
87	let mut fmt = HTMLRenderer::<false>::new();
88	fmt.render(self);
89	fmt.into()
90	}
91
92	/// Render this node to XHTML, it adds slash to self-closing tags like this: `<img />`.
93	///
94	/// This mode exists for compatibility with CommonMark tests.
95	pub fn xrender(&self) -> String {
96	let mut fmt = HTMLRenderer::<true>::new();
97	fmt.render(self);
98	fmt.into()
99	}
100
101	/// Replace custom value with another value (this is roughly equivalent
102	/// to replacing the entire node and copying children and sourcemaps).
103	pub fn replace<T: NodeValue>(&mut self, value: T) {
104	self.node_type = TypeKey::of::<T>();
105	self.node_value = Box::new(value);
106	}
107
108	/// Execute function `f` recursively on every member of AST tree
109	/// (using preorder deep-first search).
110	pub fn walk<'a>(&'a self, mut f: impl FnMut(&'a Node, u32)) {
111	// performance note: this is faster than emulating recursion using vec stack
112	fn walk_recursive<'b>(node: &'b Node, depth: u32, f: &mut impl FnMut(&'b Node, u32)) {
113	f(node, depth);
114	for n in node.children.iter() {
115	stacker::maybe_grow(641024, 10241024, \|\| {
116	walk_recursive(n, depth + 1, f);
117	});
118	}
119	}
120
121	walk_recursive(self, 0, &mut f);
122	}
123
124	/// Execute function `f` recursively on every member of AST tree
125	/// (using preorder deep-first search).
126	pub fn walk_mut(&mut self, mut f: impl FnMut(&mut Node, u32)) {
127	// performance note: this is faster than emulating recursion using vec stack
128	fn walk_recursive(node: &mut Node, depth: u32, f: &mut impl FnMut(&mut Node, u32)) {
129	f(node, depth);
130	for n in node.children.iter_mut() {
131	stacker::maybe_grow(641024, 10241024, \|\| {
132	walk_recursive(n, depth + 1, f);
133	});
134	}
135	}
136
137	walk_recursive(self, 0, &mut f);
138	}
139
140	/// Execute function `f` recursively on every member of AST tree
141	/// (using postorder deep-first search).
142	pub fn walk_post(&self, mut f: impl FnMut(&Node, u32)) {
143	fn walk_recursive(node: &Node, depth: u32, f: &mut impl FnMut(&Node, u32)) {
144	for n in node.children.iter() {
145	stacker::maybe_grow(641024, 10241024, \|\| {
146	walk_recursive(n, depth + 1, f);
147	});
148	}
149	f(node, depth);
150	}
151
152	walk_recursive(self, 0, &mut f);
153	}
154
155	/// Execute function `f` recursively on every member of AST tree
156	/// (using postorder deep-first search).
157	pub fn walk_post_mut(&mut self, mut f: impl FnMut(&mut Node, u32)) {
158	fn walk_recursive(node: &mut Node, depth: u32, f: &mut impl FnMut(&mut Node, u32)) {
159	for n in node.children.iter_mut() {
160	stacker::maybe_grow(641024, 10241024, \|\| {
161	walk_recursive(n, depth + 1, f);
162	});
163	}
164	f(node, depth);
165	}
166
167	walk_recursive(self, 0, &mut f);
168	}
169
170	/// Walk recursively through child nodes and collect all text nodes
171	/// into a single string.
172	pub fn collect_text(&self) -> String {
173	let mut result = String::new();
174
175	self.walk(\|node, _\| {
176	if let Some(text) = node.cast::<Text>() {
177	result.push_str(text.content.as_str());
178	} else if node.is::<Softbreak>() {
179	result.push('\n');
180	}
181	});
182
183	result
184	}
185	}
186
187	impl Drop for Node {
188	fn drop(&mut self) {
189	self.walk_post_mut(\|node, _\| {
190	drop(std::mem::take(&mut node.children));
191	});
192	}
193	}
194
195	#[derive(Debug)]
196	#[doc(hidden)]
197	pub struct NodeEmpty;
198	impl NodeValue for NodeEmpty {}
199
200	impl Default for Node {
201	/// Create empty Node. Empty node should only be used as placeholder for functions like
202	/// std::mem::take, and it cannot be rendered.
203	fn default() -> Self {
204	Node::new(NodeEmpty)
205	}
206	}
207
208	/// Contents of the specific AST node.
209	pub trait NodeValue : Debug + Downcast {
210	/// Output HTML corresponding to this node using Renderer API.
211	///
212	/// Example implementation looks like this:
213	/// ```rust
214	/// # const IGNORE : &str = stringify! {
215	/// fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
216	/// fmt.open("div", &[]);
217	/// fmt.contents(&node.children);
218	/// fmt.close("div");
219	/// fmt.cr();
220	/// }
221	/// # };
222	/// ```
223	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
224	let _ = fmt;
225	unimplemented!("{} doesn't implement render", node.name());
226	}
227	}
228
229	impl_downcast!(NodeValue);

crates/markdown-it/src/parser/renderer.rs created+154

...	@@ -0,0 +1,154 @@
1	use std::collections::HashMap;
2	use std::fmt::Debug;
3
4	use crate::common::utils::escape_html;
5	use crate::parser::extset::RenderExtSet;
6	use crate::Node;
7
8	/// Each node outputs its HTML using this API.
9	///
10	/// Renderer is a struct that walks through AST and collects HTML from each node
11	/// into internal buffer.
12	pub trait Renderer {
13	/// Write opening html tag with attributes, e.g. `<a href="url">`.
14	fn open(&mut self, tag: &str, attrs: &[(&str, String)]);
15	/// Write closing html tag, e.g. `</a>`.
16	fn close(&mut self, tag: &str);
17	/// Write self-closing html tag with attributes, e.g. `<img src="url"/>`.
18	fn self_close(&mut self, tag: &str, attrs: &[(&str, String)]);
19	/// Loop through child nodes and render each one.
20	fn contents(&mut self, nodes: &[Node]);
21	/// Write line break (`\n`). Default renderer ignores it if last char in the buffer is `\n` already.
22	fn cr(&mut self);
23	/// Write plain text with escaping, `<div>` -> `<div>`.
24	fn text(&mut self, text: &str);
25	/// Write plain text without escaping, `<div>` -> `<div>`.
26	fn text_raw(&mut self, text: &str);
27	/// Extension set to store custom stuff.
28	fn ext(&mut self) -> &mut RenderExtSet;
29	}
30
31	#[derive(Debug, Default)]
32	/// Default HTML/XHTML renderer.
33	pub(crate) struct HTMLRenderer<const XHTML: bool> {
34	result: String,
35	ext: RenderExtSet,
36	}
37
38	impl<const XHTML: bool> HTMLRenderer<XHTML> {
39	pub fn new() -> Self {
40	Self {
41	result: String::new(),
42	ext: RenderExtSet::new(),
43	}
44	}
45
46	pub fn render(&mut self, node: &Node) {
47	node.node_value.render(node, self);
48	}
49
50	fn make_attr(&mut self, name: &str, value: &str) {
51	self.result.push(' ');
52	self.result.push_str(&escape_html(name));
53	self.result.push('=');
54	self.result.push('"');
55	self.result.push_str(&escape_html(value));
56	self.result.push('"');
57	}
58
59	fn make_attrs(&mut self, attrs: &[(&str, String)]) {
60	let mut attr_hash = HashMap::new();
61	let mut attr_order = Vec::with_capacity(attrs.len());
62
63	for (name, value) in attrs {
64	let entry = attr_hash.entry(*name).or_insert(Vec::new());
65	entry.push(value.as_str());
66	attr_order.push(*name);
67	}
68
69	for name in attr_order {
70	let Some(value) = attr_hash.remove(name) else { continue; };
71
72	if name == "class" {
73	self.make_attr(name, &value.join(" "));
74	} else if name == "style" {
75	self.make_attr(name, &value.join(";"));
76	} else {
77	for v in value {
78	self.make_attr(name, v);
79	}
80	}
81	}
82	}
83	}
84
85	impl<const XHTML: bool> From<HTMLRenderer<XHTML>> for String {
86	fn from(f: HTMLRenderer<XHTML>) -> Self {
87	#[cold]
88	fn replace_null(input: String) -> String {
89	input.replace('\0', "\u{FFFD}")
90	}
91
92	if f.result.contains('\0') {
93	// U+0000 must be replaced with U+FFFD as per commonmark spec,
94	// we do it at the very end in order to avoid messing with byte offsets
95	// for source maps (since "\0".len() != "\u{FFFD}".len())
96	replace_null(f.result)
97	} else {
98	f.result
99	}
100	}
101	}
102
103	impl<const XHTML: bool> Renderer for HTMLRenderer<XHTML> {
104	fn open(&mut self, tag: &str, attrs: &[(&str, String)]) {
105	self.result.push('<');
106	self.result.push_str(tag);
107	self.make_attrs(attrs);
108	self.result.push('>');
109	}
110
111	fn close(&mut self, tag: &str) {
112	self.result.push('<');
113	self.result.push('/');
114	self.result.push_str(tag);
115	self.result.push('>');
116	}
117
118	fn self_close(&mut self, tag: &str, attrs: &[(&str, String)]) {
119	self.result.push('<');
120	self.result.push_str(tag);
121	self.make_attrs(attrs);
122	if XHTML {
123	self.result.push(' ');
124	self.result.push('/');
125	}
126	self.result.push('>');
127	}
128
129	fn contents(&mut self, nodes: &[Node]) {
130	for node in nodes.iter() {
131	self.render(node);
132	}
133	}
134
135	fn cr(&mut self) {
136	// only push '\n' if last character isn't it
137	match self.result.as_bytes().last() {
138	Some(b'\n') \| None => {}
139	Some(_) => self.result.push('\n')
140	}
141	}
142
143	fn text(&mut self, text: &str) {
144	self.result.push_str(&escape_html(text));
145	}
146
147	fn text_raw(&mut self, text: &str) {
148	self.result.push_str(text);
149	}
150
151	fn ext(&mut self) -> &mut RenderExtSet {
152	&mut self.ext
153	}
154	}

crates/markdown-it/src/plugins/cmark/block/blockquote.rs created+168

...	@@ -0,0 +1,168 @@
1	//! Block quotes
2	//!
3	//! `> looks like this`
4	//!
5	//! <https://spec.commonmark.org/0.30/#block-quotes>
6	use crate::common::utils::find_indent_of;
7	use crate::parser::block::{BlockRule, BlockState};
8	use crate::{MarkdownIt, Node, NodeValue, Renderer};
9
10	#[derive(Debug)]
11	pub struct Blockquote;
12
13	impl NodeValue for Blockquote {
14	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
15	fmt.cr();
16	fmt.open("blockquote", &node.attrs);
17	fmt.cr();
18	fmt.contents(&node.children);
19	fmt.cr();
20	fmt.close("blockquote");
21	fmt.cr();
22	}
23	}
24
25	pub fn add(md: &mut MarkdownIt) {
26	md.block.add_rule::<BlockquoteScanner>();
27	}
28
29	#[doc(hidden)]
30	pub struct BlockquoteScanner;
31	impl BlockRule for BlockquoteScanner {
32	fn check(state: &mut BlockState) -> Option<()> {
33
34	if state.line_indent(state.line) >= state.md.max_indent { return None; }
35
36	// check the block quote marker
37	let Some('>') = state.get_line(state.line).chars().next() else { return None; };
38
39	Some(())
40	}
41
42	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
43	Self::check(state)?;
44
45	let mut old_line_offsets = Vec::new();
46	let start_line = state.line;
47	let mut next_line = state.line;
48	let mut last_line_empty = false;
49
50	// Search the end of the block
51	//
52	// Block ends with either:
53	// 1. an empty line outside:
54	// ```
55	// > test
56	//
57	// ```
58	// 2. an empty line inside:
59	// ```
60	// >
61	// test
62	// ```
63	// 3. another tag:
64	// ```
65	// > test
66	// - - -
67	// ```
68	while next_line < state.line_max {
69	// check if it's outdented, i.e. it's inside list item and indented
70	// less than said list item:
71	//
72	// ```
73	// 1. anything
74	// > current blockquote
75	// 2. checking this line
76	// ```
77	let is_outdented = state.line_indent(next_line) < 0;
78	let line = state.get_line(next_line).to_owned();
79	let mut chars = line.chars();
80
81	match chars.next() {
82	None => {
83	// Case 1: line is not inside the blockquote, and this line is empty.
84	break;
85	}
86	Some('>') if !is_outdented => {
87	// This line is inside the blockquote.
88
89	// set offset past spaces and ">"
90	let offsets = &state.line_offsets[next_line];
91	let pos_after_marker = offsets.first_nonspace + 1;
92
93	old_line_offsets.push(state.line_offsets[next_line].clone());
94
95	let ( mut indent_after_marker, first_nonspace ) = find_indent_of(
96	&state.src[offsets.line_start..offsets.line_end],
97	pos_after_marker - offsets.line_start);
98
99	last_line_empty = first_nonspace == offsets.line_end - offsets.line_start;
100
101	// skip one optional space after '>'
102	if matches!(chars.next(), Some(' ' \| '\t')) {
103	indent_after_marker -= 1;
104	}
105
106	state.line_offsets[next_line].indent_nonspace = indent_after_marker as i32;
107	state.line_offsets[next_line].first_nonspace = first_nonspace + state.line_offsets[next_line].line_start;
108	next_line += 1;
109	continue;
110	}
111	_ => {}
112	}
113
114	// Case 2: line is not inside the blockquote, and the last line was empty.
115	if last_line_empty { break; }
116
117	// Case 3: another tag found.
118	state.line = next_line;
119
120	if state.test_rules_at_line() {
121	// Quirk to enforce "hard termination mode" for paragraphs;
122	// normally if you call `nodeize(state, startLine, nextLine)`,
123	// paragraphs will look below nextLine for paragraph continuation,
124	// but if blockquote is terminated by another tag, they shouldn't
125	//state.line_max = next_line;
126
127	if state.blk_indent != 0 {
128	// state.blkIndent was non-zero, we now set it to zero,
129	// so we need to re-calculate all offsets to appear as
130	// if indent wasn't changed
131	old_line_offsets.push(state.line_offsets[next_line].clone());
132	state.line_offsets[next_line].indent_nonspace -= state.blk_indent as i32;
133	}
134
135	break;
136	}
137
138	old_line_offsets.push(state.line_offsets[next_line].clone());
139
140	// A negative indentation means that this is a paragraph continuation
141	//
142	state.line_offsets[next_line].indent_nonspace = -1;
143	next_line += 1;
144	}
145
146	let old_indent = state.blk_indent;
147	state.blk_indent = 0;
148
149	let old_node = std::mem::replace(&mut state.node, Node::new(Blockquote));
150	let old_line_max = state.line_max;
151	state.line = start_line;
152	state.line_max = next_line;
153	state.md.block.tokenize(state);
154	next_line = state.line;
155	state.line = start_line;
156	state.line_max = old_line_max;
157
158	// Restore original tShift; this might not be necessary since the parser
159	// has already been here, but just to make sure we can do that.
160	for (idx, line_offset) in old_line_offsets.iter_mut().enumerate() {
161	std::mem::swap(&mut state.line_offsets[idx + start_line], line_offset);
162	}
163	state.blk_indent = old_indent;
164
165	let node = std::mem::replace(&mut state.node, old_node);
166	Some((node, next_line - start_line))
167	}
168	}

crates/markdown-it/src/plugins/cmark/block/code.rs created+69

...	@@ -0,0 +1,69 @@
1	//! Indented code block
2	//!
3	//! Parses anything indented with 4 spaces.
4	//!
5	//! <https://spec.commonmark.org/0.30/#indented-code-block>
6	use crate::parser::block::{BlockRule, BlockState};
7	use crate::{MarkdownIt, Node, NodeValue, Renderer};
8
9	const CODE_INDENT: i32 = 4;
10
11	#[derive(Debug)]
12	pub struct CodeBlock {
13	pub content: String,
14	}
15
16	impl NodeValue for CodeBlock {
17	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
18	fmt.cr();
19	fmt.open("pre", &[]);
20	fmt.open("code", &node.attrs);
21	fmt.text(&self.content);
22	fmt.close("code");
23	fmt.close("pre");
24	fmt.cr();
25	}
26	}
27
28	pub fn add(md: &mut MarkdownIt) {
29	md.block.add_rule::<CodeScanner>();
30	md.max_indent = CODE_INDENT;
31	}
32
33	#[doc(hidden)]
34	pub struct CodeScanner;
35	impl BlockRule for CodeScanner {
36	fn check(_: &mut BlockState) -> Option<()> {
37	None
38	}
39
40	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
41	if state.line_indent(state.line) < CODE_INDENT { return None; }
42
43	let mut next_line = state.line + 1;
44	let mut last = next_line;
45
46	while next_line < state.line_max {
47	if state.is_empty(next_line) {
48	next_line += 1;
49	continue;
50	}
51
52	if state.line_indent(next_line) >= CODE_INDENT {
53	next_line += 1;
54	last = next_line;
55	continue;
56	}
57
58	break;
59	}
60
61	let (mut content, _mapping) = state.get_lines(state.line, last, CODE_INDENT as usize + state.blk_indent, false);
62	content += "\n";
63
64	let node = Node::new(CodeBlock { content });
65	//node.srcmap = state.get_map_from_offsets(mapping[0].1, state.line_offsets[last - 1].line_end);
66
67	Some((node, last - state.line))
68	}
69	}

crates/markdown-it/src/plugins/cmark/block/fence.rs created+164

...	@@ -0,0 +1,164 @@
1	//! Code fence
2	//!
3	//! ` ```lang ` or `~~~lang`
4	//!
5	//! <https://spec.commonmark.org/0.30/#code-fence>
6	use crate::common::utils::unescape_all;
7	use crate::parser::block::{BlockRule, BlockState};
8	use crate::parser::extset::MarkdownItExt;
9	use crate::{MarkdownIt, Node, NodeValue, Renderer};
10
11	#[derive(Debug)]
12	pub struct CodeFence {
13	pub info: String,
14	pub marker: char,
15	pub marker_len: usize,
16	pub content: String,
17	pub lang_prefix: &'static str,
18	}
19
20	impl NodeValue for CodeFence {
21	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
22	let info = unescape_all(&self.info);
23	let mut split = info.split_whitespace();
24	let lang_name = split.next().unwrap_or("");
25	let mut attrs = node.attrs.clone();
26	let class;
27
28	if !lang_name.is_empty() {
29	class = format!("{}{}", self.lang_prefix, lang_name);
30	attrs.push(("class", class));
31	}
32
33	fmt.cr();
34	fmt.open("pre", &[]);
35	fmt.open("code", &attrs);
36	fmt.text(&self.content);
37	fmt.close("code");
38	fmt.close("pre");
39	fmt.cr();
40	}
41	}
42
43	#[derive(Debug, Clone, Copy)]
44	struct FenceSettings(&'static str);
45	impl MarkdownItExt for FenceSettings {}
46
47	impl Default for FenceSettings {
48	fn default() -> Self {
49	Self("language-")
50	}
51	}
52
53	pub fn add(md: &mut MarkdownIt) {
54	md.block.add_rule::<FenceScanner>();
55	}
56
57	pub fn set_lang_prefix(md: &mut MarkdownIt, lang_prefix: &'static str) {
58	md.ext.insert(FenceSettings(lang_prefix));
59	}
60
61	#[doc(hidden)]
62	pub struct FenceScanner;
63
64	impl FenceScanner {
65	fn get_header<'a>(state: &'a mut BlockState) -> Option<(char, usize, &'a str)> {
66
67	if state.line_indent(state.line) >= state.md.max_indent { return None; }
68
69	let line = state.get_line(state.line);
70	let mut chars = line.chars();
71
72	let marker = chars.next()?;
73	if marker != '~' && marker != '`' { return None; }
74
75	// scan marker length
76	let mut len = 1;
77	while Some(marker) == chars.next() { len += 1; }
78
79	if len < 3 { return None; }
80
81	let params = &line[len..];
82
83	if marker == '`' && params.contains(marker) { return None; }
84
85	Some((marker, len, params))
86	}
87	}
88
89	impl BlockRule for FenceScanner {
90	fn check(state: &mut BlockState) -> Option<()> {
91	Self::get_header(state).map(\|_\| ())
92	}
93
94	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
95	let (marker, len, params) = Self::get_header(state)?;
96	let params = params.to_owned();
97
98	let mut next_line = state.line;
99	let mut have_end_marker = false;
100
101	// search end of block
102	'outer: loop {
103	next_line += 1;
104	if next_line >= state.line_max {
105	// unclosed block should be autoclosed by end of document.
106	// also block seems to be autoclosed by end of parent
107	break;
108	}
109
110	let line = state.get_line(next_line);
111
112	if !line.is_empty() && state.line_indent(next_line) < 0 {
113	// non-empty line with negative indent should stop the list:
114	// - ```
115	// test
116	break;
117	}
118
119	let mut chars = line.chars().peekable();
120
121	if Some(marker) != chars.next() { continue; }
122
123	if state.line_indent(next_line) >= state.md.max_indent {
124	continue;
125	}
126
127	// scan marker length
128	let mut len_end = 1;
129	while Some(&marker) == chars.peek() {
130	chars.next();
131	len_end += 1;
132	}
133
134	// closing code fence must be at least as long as the opening one
135	if len_end < len { continue; }
136
137	// make sure tail has spaces only
138	loop {
139	match chars.next() {
140	Some(' ' \| '\t') => {},
141	Some(_) => continue 'outer,
142	None => {
143	have_end_marker = true;
144	break 'outer;
145	}
146	}
147	}
148	}
149
150	// If a fence has heading spaces, they should be removed from its inner block
151	let indent = state.line_offsets[state.line].indent_nonspace;
152	let (content, _) = state.get_lines(state.line + 1, next_line, indent as usize, true);
153
154	let lang_prefix = state.md.ext.get::<FenceSettings>().copied().unwrap_or_default().0;
155	let node = Node::new(CodeFence {
156	info: params,
157	marker,
158	marker_len: len,
159	content,
160	lang_prefix,
161	});
162	Some((node, next_line - state.line + if have_end_marker { 1 } else { 0 }))
163	}
164	}

crates/markdown-it/src/plugins/cmark/block/heading.rs created+87

...	@@ -0,0 +1,87 @@
1	//! ATX heading
2	//!
3	//! `# h1`, `## h2`, etc.
4	//!
5	//! <https://spec.commonmark.org/0.30/#atx-heading>
6	use crate::parser::block::{BlockRule, BlockState};
7	use crate::parser::inline::InlineRoot;
8	use crate::{MarkdownIt, Node, NodeValue, Renderer};
9
10	#[derive(Debug)]
11	pub struct ATXHeading {
12	pub level: u8,
13	}
14
15	impl NodeValue for ATXHeading {
16	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
17	static TAG : [&str; 6] = [ "h1", "h2", "h3", "h4", "h5", "h6" ];
18	debug_assert!(self.level >= 1 && self.level <= 6);
19
20	fmt.cr();
21	fmt.open(TAG[self.level as usize - 1], &node.attrs);
22	fmt.contents(&node.children);
23	fmt.close(TAG[self.level as usize - 1]);
24	fmt.cr();
25	}
26	}
27
28	pub fn add(md: &mut MarkdownIt) {
29	md.block.add_rule::<HeadingScanner>();
30	}
31
32	#[doc(hidden)]
33	pub struct HeadingScanner;
34	impl BlockRule for HeadingScanner {
35	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
36
37	if state.line_indent(state.line) >= state.md.max_indent { return None; }
38
39	let line = state.get_line(state.line);
40	let Some('#') = line.chars().next() else { return None; };
41
42	let text_pos;
43
44	// count heading level
45	let mut level = 0u8;
46	let mut chars = line.char_indices();
47	loop {
48	match chars.next() {
49	Some((_, '#')) => {
50	level += 1;
51	if level > 6 { return None; }
52	}
53	Some((x, ' ' \| '\t')) => {
54	text_pos = x;
55	break;
56	}
57	None => {
58	text_pos = level as usize;
59	break;
60	}
61	Some(_) => return None,
62	}
63	}
64
65	// Let's cut tails like ' ### ' from the end of string
66
67	let mut chars_back = chars.rev().peekable();
68	while let Some((_, ' ' \| '\t')) = chars_back.peek() { chars_back.next(); }
69	while let Some((_, '#')) = chars_back.peek() { chars_back.next(); }
70
71	let text_max = match chars_back.next() {
72	// ## foo ##
73	Some((last_pos, ' ' \| '\t')) => last_pos + 1,
74	// ## foo##
75	Some(_) => line.len(),
76	// ## ## (already consumed the space)
77	None => text_pos,
78	};
79
80	let content = line[text_pos..text_max].to_owned();
81	let mapping = vec![(0, state.line_offsets[state.line].first_nonspace + text_pos)];
82
83	let mut node = Node::new(ATXHeading { level });
84	node.children.push(Node::new(InlineRoot::new(content, mapping)));
85	Some((node, 1))
86	}
87	}

crates/markdown-it/src/plugins/cmark/block/hr.rs created+55

...	@@ -0,0 +1,55 @@
1	//! Thematic breaks
2	//!
3	//! `***`, `---`, `___`
4	//!
5	//! <https://spec.commonmark.org/0.30/#thematic-breaks>
6	use crate::parser::block::{BlockRule, BlockState};
7	use crate::{MarkdownIt, Node, NodeValue, Renderer};
8
9	#[derive(Debug)]
10	pub struct ThematicBreak {
11	pub marker: char,
12	pub marker_len: usize,
13	}
14
15	impl NodeValue for ThematicBreak {
16	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
17	fmt.cr();
18	fmt.self_close("hr", &node.attrs);
19	fmt.cr();
20	}
21	}
22
23	pub fn add(md: &mut MarkdownIt) {
24	md.block.add_rule::<HrScanner>();
25	}
26
27	#[doc(hidden)]
28	pub struct HrScanner;
29	impl BlockRule for HrScanner {
30	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
31
32	if state.line_indent(state.line) >= state.md.max_indent { return None; }
33
34	let mut chars = state.get_line(state.line).chars();
35
36	// Check hr marker
37	let marker = chars.next()?;
38	if marker != '*' && marker != '-' && marker != '_' { return None; }
39
40	// markers can be mixed with spaces, but there should be at least 3 of them
41	let mut cnt = 1;
42	for ch in chars {
43	if ch == marker {
44	cnt += 1;
45	} else if ch != ' ' && ch != '\t' {
46	return None;
47	}
48	}
49
50	if cnt < 3 { return None; }
51
52	let node = Node::new(ThematicBreak { marker, marker_len: cnt });
53	Some((node, 1))
54	}
55	}

crates/markdown-it/src/plugins/cmark/block/lheading.rs created+104

...	@@ -0,0 +1,104 @@
1	//! Setext headings
2	//!
3	//! Paragraph underlined with `===` or `---`.
4	//!
5	//! <https://spec.commonmark.org/0.30/#setext-headings>
6	use crate::parser::block::{BlockRule, BlockState};
7	use crate::parser::inline::InlineRoot;
8	use crate::plugins::cmark::block::paragraph::ParagraphScanner;
9	use crate::{MarkdownIt, Node, NodeValue, Renderer};
10
11	#[derive(Debug)]
12	pub struct SetextHeader {
13	pub level: u8,
14	pub marker: char,
15	}
16
17	impl NodeValue for SetextHeader {
18	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
19	static TAG : [&str; 2] = [ "h1", "h2" ];
20	debug_assert!(self.level >= 1 && self.level <= 2);
21
22	fmt.cr();
23	fmt.open(TAG[self.level as usize - 1], &node.attrs);
24	fmt.contents(&node.children);
25	fmt.close(TAG[self.level as usize - 1]);
26	fmt.cr();
27	}
28	}
29
30	pub fn add(md: &mut MarkdownIt) {
31	md.block.add_rule::<LHeadingScanner>()
32	.before::<ParagraphScanner>()
33	.after_all();
34	}
35
36	#[doc(hidden)]
37	pub struct LHeadingScanner;
38	impl BlockRule for LHeadingScanner {
39	fn check(_: &mut BlockState) -> Option<()> {
40	None // can't interrupt any tags
41	}
42
43	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
44
45	if state.line_indent(state.line) >= state.md.max_indent { return None; }
46
47	let start_line = state.line;
48	let mut next_line = start_line;
49	let mut level = 0;
50
51	'outer: loop {
52	next_line += 1;
53
54	if next_line >= state.line_max \|\| state.is_empty(next_line) { break; }
55
56	// this may be a code block normally, but after paragraph
57	// it's considered a lazy continuation regardless of what's there
58	if state.line_indent(next_line) >= state.md.max_indent { continue; }
59
60	//
61	// Check for underline in setext header
62	//
63	if state.line_indent(next_line) >= 0 {
64	let mut chars = state.get_line(next_line).chars().peekable();
65	if let Some(marker @ ('-' \| '=')) = chars.next() {
66	while Some(&marker) == chars.peek() { chars.next(); }
67	while let Some(' ' \| '\t') = chars.peek() { chars.next(); }
68	if chars.next().is_none() {
69	level = if marker == '=' { 1 } else { 2 };
70	break 'outer;
71	}
72	}
73	}
74
75	// quirk for blockquotes, this line should already be checked by that rule
76	if state.line_offsets[next_line].indent_nonspace < 0 { continue; }
77
78	// Some tags can terminate paragraph without empty line.
79	let old_state_line = state.line;
80	state.line = next_line;
81	if state.test_rules_at_line() {
82	state.line = old_state_line;
83	break 'outer;
84	}
85	state.line = old_state_line;
86	}
87
88
89	if level == 0 {
90	// Didn't find valid underline
91	return None;
92	}
93
94	let (content, mapping) = state.get_lines(start_line, next_line, state.blk_indent, false);
95
96	let mut node = Node::new(SetextHeader {
97	level,
98	marker: if level == 2 { '-' } else { '=' }
99	});
100	node.children.push(Node::new(InlineRoot::new(content, mapping)));
101
102	Some((node, next_line + 1 - start_line))
103	}
104	}

crates/markdown-it/src/plugins/cmark/block/list.rs created+370

...	@@ -0,0 +1,370 @@
1	//! Ordered and bullet lists
2	//!
3	//! This plugin parses both kinds of lists (bullet and ordered) as well as list items.
4	//!
5	//! looks like `1. this` or `- this`
6	//!
7	//! - <https://spec.commonmark.org/0.30/#lists>
8	//! - <https://spec.commonmark.org/0.30/#list-items>
9	use crate::common::utils::find_indent_of;
10	use crate::parser::block::{BlockRule, BlockState};
11	use crate::plugins::cmark::block::hr::HrScanner;
12	use crate::plugins::cmark::block::paragraph::Paragraph;
13	use crate::{MarkdownIt, Node, NodeValue, Renderer};
14
15	#[derive(Debug)]
16	pub struct OrderedList {
17	pub start: u32,
18	pub marker: char,
19	}
20
21	impl NodeValue for OrderedList {
22	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
23	let mut attrs = node.attrs.clone();
24	let start;
25	if self.start != 1 {
26	start = self.start.to_string();
27	attrs.push(("start", start));
28	}
29	fmt.cr();
30	fmt.open("ol", &attrs);
31	fmt.cr();
32	fmt.contents(&node.children);
33	fmt.cr();
34	fmt.close("ol");
35	fmt.cr();
36	}
37	}
38
39	#[derive(Debug)]
40	pub struct BulletList {
41	pub marker: char,
42	}
43
44	impl NodeValue for BulletList {
45	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
46	fmt.cr();
47	fmt.open("ul", &node.attrs);
48	fmt.cr();
49	fmt.contents(&node.children);
50	fmt.cr();
51	fmt.close("ul");
52	fmt.cr();
53	}
54	}
55
56	#[derive(Debug)]
57	pub struct ListItem;
58
59	impl NodeValue for ListItem {
60	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
61	fmt.open("li", &node.attrs);
62	fmt.contents(&node.children);
63	fmt.close("li");
64	fmt.cr();
65	}
66	}
67
68	pub fn add(md: &mut MarkdownIt) {
69	md.block.add_rule::<ListScanner>()
70	.after::<HrScanner>();
71	}
72
73	#[doc(hidden)]
74	pub struct ListScanner;
75
76	impl ListScanner {
77	// Search `[-+*][\n ]`, returns next pos after marker on success
78	// or -1 on fail.
79	fn skip_bullet_list_marker(src: &str) -> Option<usize> {
80	let mut chars = src.chars();
81
82	let Some('*' \| '-' \| '+') = chars.next() else { return None; };
83
84	match chars.next() {
85	Some(' ' \| '\t') \| None => Some(1),
86	Some(_) => None, // " -test " - is not a list item
87	}
88	}
89
90	// Search `\d+[.)][\n ]`, returns next pos after marker on success
91	// or -1 on fail.
92	fn skip_ordered_list_marker(src: &str) -> Option<usize> {
93	let mut chars = src.chars();
94	let Some('0'..='9') = chars.next() else { return None; };
95
96	let mut pos = 1;
97	loop {
98	pos += 1;
99	match chars.next() {
100	Some('0'..='9') => {
101	// List marker should have no more than 9 digits
102	// (prevents integer overflow in browsers)
103	if pos >= 10 { return None; }
104	}
105	Some(')' \| '.') => {
106	// found valid marker
107	break;
108	}
109	Some(_) \| None => { return None; }
110	}
111	}
112
113	match chars.next() {
114	Some(' ' \| '\t') \| None => Some(pos),
115	Some(_) => None, // " 1.test " - is not a list item
116	}
117	}
118
119	fn mark_tight_paragraphs(nodes: &mut Vec<Node>) {
120	let mut idx = 0;
121	while idx < nodes.len() {
122	if nodes[idx].is::<Paragraph>() {
123	let children = std::mem::take(&mut nodes[idx].children);
124	let len = children.len();
125	nodes.splice(idx..idx+1, children);
126	idx += len;
127	} else {
128	idx += 1;
129	}
130	}
131	}
132
133	fn find_marker(state: &mut BlockState, silent: bool) -> Option<(usize, Option<u32>, char)> {
134
135	if state.line_indent(state.line) >= state.md.max_indent { return None; }
136
137	// Special case:
138	// - item 1
139	// - item 2
140	// - item 3
141	// - item 4
142	// - this one is a paragraph continuation
143	if let Some(list_indent) = state.list_indent {
144	let indent_nonspace = state.line_offsets[state.line].indent_nonspace;
145	if indent_nonspace - list_indent as i32 >= state.md.max_indent &&
146	indent_nonspace < state.blk_indent as i32 {
147	return None;
148	}
149	}
150
151	let mut is_terminating_paragraph = false;
152
153	// limit conditions when list can interrupt
154	// a paragraph (validation mode only)
155	if silent {
156	// Next list item should still terminate previous list item;
157	//
158	// This code can fail if plugins use blkIndent as well as lists,
159	// but I hope the spec gets fixed long before that happens.
160	//
161	if state.line_indent(state.line) >= 0 {
162	is_terminating_paragraph = true;
163	}
164	}
165
166	let current_line = state.get_line(state.line);
167
168	let marker_value;
169	let pos_after_marker;
170
171	// Detect list type and position after marker
172	if let Some(p) = Self::skip_ordered_list_marker(current_line) {
173	pos_after_marker = p;
174	let int = str::parse(&current_line[..pos_after_marker - 1]).unwrap();
175	marker_value = Some(int);
176
177	// If we're starting a new ordered list right after
178	// a paragraph, it should start with 1.
179	if is_terminating_paragraph && int != 1 { return None; }
180
181	} else if let Some(p) = Self::skip_bullet_list_marker(current_line) {
182	pos_after_marker = p;
183	marker_value = None;
184	} else {
185	return None;
186	}
187
188	// If we're starting a new unordered list right after
189	// a paragraph, first line should not be empty.
190	if is_terminating_paragraph {
191	let mut chars = current_line[pos_after_marker..].chars();
192	loop {
193	match chars.next() {
194	Some(' ' \| '\t') => {},
195	Some(_) => break,
196	None => return None,
197	}
198	}
199	}
200
201	// We should terminate list on style change. Remember first one to compare.
202	let marker_char = current_line[..pos_after_marker].chars().next_back().unwrap();
203
204	Some((pos_after_marker, marker_value, marker_char))
205	}
206	}
207
208	impl BlockRule for ListScanner {
209	fn check(state: &mut BlockState) -> Option<()> {
210	if state.node.is::<BulletList>() \|\| state.node.is::<OrderedList>() { return None; }
211
212	Self::find_marker(state, true).map(\|_\| ())
213	}
214
215	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
216	let (mut pos_after_marker, marker_value, marker_char) = Self::find_marker(state, false)?;
217
218	let new_node = if let Some(int) = marker_value {
219	Node::new(OrderedList {
220	start: int,
221	marker: marker_char
222	})
223	} else {
224	Node::new(BulletList {
225	marker: marker_char
226	})
227	};
228
229	let old_node = std::mem::replace(&mut state.node, new_node);
230
231	//
232	// Iterate list items
233	//
234
235	let start_line = state.line;
236	let mut next_line = state.line;
237	let mut prev_empty_end = false;
238	let mut tight = true;
239	let mut current_line;
240
241	while next_line < state.line_max {
242	let offsets = &state.line_offsets[next_line];
243	let initial = offsets.indent_nonspace as usize + pos_after_marker;
244
245	let ( mut indent_after_marker, first_nonspace ) = find_indent_of(
246	&state.src[offsets.line_start..offsets.line_end],
247	pos_after_marker + offsets.first_nonspace - offsets.line_start);
248
249	let reached_end_of_line = first_nonspace == offsets.line_end - offsets.line_start;
250	let indent_nonspace = initial + indent_after_marker;
251
252	#[allow(clippy::if_same_then_else)]
253	if reached_end_of_line {
254	// trimming space in "- \n 3" case, indent is 1 here
255	indent_after_marker = 1;
256	} else if indent_after_marker as i32 > state.md.max_indent {
257	// If we have more than the max indent, the indent is 1
258	// (the rest is just indented code block)
259	indent_after_marker = 1;
260	}
261
262	// " - test"
263	// ^^^^^ - calculating total length of this thing
264	let indent = initial + indent_after_marker;
265
266	// Run subparser & write tokens
267	let old_node = std::mem::replace(&mut state.node, Node::new(ListItem));
268
269	// change current state, then restore it after parser subcall
270	let old_tight = state.tight;
271	let old_lineoffset = offsets.clone();
272
273	// - example list
274	// ^ listIndent position will be here
275	// ^ blkIndent position will be here
276	//
277	let old_list_indent = state.list_indent;
278	state.list_indent = Some(state.blk_indent as u32);
279	state.blk_indent = indent;
280
281	state.tight = true;
282	state.line_offsets[next_line].first_nonspace = first_nonspace + state.line_offsets[next_line].line_start;
283	state.line_offsets[next_line].indent_nonspace = indent_nonspace as i32;
284
285	if reached_end_of_line && state.is_empty(next_line + 1) {
286	// workaround for this case
287	// (list item is empty, list terminates before "foo"):
288	// ~~~~~~~~
289	// -
290	//
291	// foo
292	// ~~~~~~~~
293	state.line = if state.line + 2 < state.line_max {
294	state.line + 2
295	} else {
296	state.line_max
297	}
298	} else {
299	state.line = next_line;
300	state.md.block.tokenize(state);
301	}
302
303	// If any of list item is tight, mark list as tight
304	if !state.tight \|\| prev_empty_end {
305	tight = false;
306	}
307
308	// Item become loose if finish with empty line,
309	// but we should filter last element, because it means list finish
310	prev_empty_end = (state.line - next_line) > 1 && state.is_empty(state.line - 1);
311
312	state.blk_indent = state.list_indent.unwrap() as usize;
313	state.list_indent = old_list_indent;
314	state.line_offsets[next_line] = old_lineoffset;
315	state.tight = old_tight;
316
317	let end_line = state.line;
318	let mut node = std::mem::replace(&mut state.node, old_node);
319	node.srcmap = state.get_map(next_line, end_line - 1);
320	state.node.children.push(node);
321	next_line = state.line;
322
323	if next_line >= state.line_max { break; }
324
325	//
326	// Try to check if list is terminated or continued.
327	//
328	if state.line_indent(next_line) < 0 { break; }
329
330	if state.line_indent(next_line) >= state.md.max_indent { break; }
331
332	// fail if terminating block found
333	if state.test_rules_at_line() { break; }
334
335	current_line = state.get_line(state.line).to_owned();
336
337	// fail if list has another type
338	#[allow(clippy::collapsible_else_if)]
339	if marker_value.is_some() {
340	if let Some(p) = Self::skip_ordered_list_marker(&current_line) {
341	pos_after_marker = p;
342	} else {
343	break;
344	}
345	} else {
346	if let Some(p) = Self::skip_bullet_list_marker(&current_line) {
347	pos_after_marker = p;
348	} else {
349	break;
350	}
351	}
352
353	let next_marker_char = current_line[..pos_after_marker].chars().next_back().unwrap();
354	if next_marker_char != marker_char { break; }
355	}
356
357	// mark paragraphs tight if needed
358	if tight {
359	for child in state.node.children.iter_mut() {
360	debug_assert!(child.is::<ListItem>());
361	Self::mark_tight_paragraphs(&mut child.children);
362	}
363	}
364
365	// Finalize list
366	state.line = start_line;
367	let node = std::mem::replace(&mut state.node, old_node);
368	Some((node, next_line - state.line))
369	}
370	}

crates/markdown-it/src/plugins/cmark/block/mod.rs created+10

...	@@ -0,0 +1,10 @@
1	//! Block-level CommonMark structures.
2	pub mod blockquote;
3	pub mod code;
4	pub mod fence;
5	pub mod heading;
6	pub mod hr;
7	pub mod lheading;
8	pub mod list;
9	pub mod paragraph;
10	pub mod reference;

crates/markdown-it/src/plugins/cmark/block/paragraph.rs created+68

...	@@ -0,0 +1,68 @@
1	//! Paragraph
2	//!
3	//! This is the default rule if nothing else matches.
4	//!
5	//! <https://spec.commonmark.org/0.30/#paragraph>
6	use crate::parser::block::{BlockRule, BlockState};
7	use crate::parser::inline::InlineRoot;
8	use crate::{MarkdownIt, Node, NodeValue, Renderer};
9
10	pub fn add(md: &mut MarkdownIt) {
11	md.block.add_rule::<ParagraphScanner>()
12	.after_all();
13	}
14
15	#[derive(Debug)]
16	pub struct Paragraph;
17
18	impl NodeValue for Paragraph {
19	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
20	fmt.cr();
21	fmt.open("p", &node.attrs);
22	fmt.contents(&node.children);
23	fmt.close("p");
24	fmt.cr();
25	}
26	}
27
28	#[doc(hidden)]
29	pub struct ParagraphScanner;
30	impl BlockRule for ParagraphScanner {
31	fn check(_: &mut BlockState) -> Option<()> {
32	None // can't interrupt anything
33	}
34
35	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
36	let start_line = state.line;
37	let mut next_line = start_line;
38
39	// jump line-by-line until empty one or EOF
40	'outer: loop {
41	next_line += 1;
42
43	if next_line >= state.line_max \|\| state.is_empty(next_line) { break; }
44
45	// this may be a code block normally, but after paragraph
46	// it's considered a lazy continuation regardless of what's there
47	if state.line_indent(next_line) >= state.md.max_indent { continue; }
48
49	// quirk for blockquotes, this line should already be checked by that rule
50	if state.line_offsets[next_line].indent_nonspace < 0 { continue; }
51
52	// Some tags can terminate paragraph without empty line.
53	let old_state_line = state.line;
54	state.line = next_line;
55	if state.test_rules_at_line() {
56	state.line = old_state_line;
57	break 'outer;
58	}
59	state.line = old_state_line;
60	}
61
62	let (content, mapping) = state.get_lines(start_line, next_line, state.blk_indent, false);
63
64	let mut node = Node::new(Paragraph);
65	node.children.push(Node::new(InlineRoot::new(content, mapping)));
66	Some((node, next_line - start_line))
67	}
68	}

crates/markdown-it/src/plugins/cmark/block/reference.rs created+374

...	@@ -0,0 +1,374 @@
1	//! Link reference definition
2	//!
3	//! `[label]: /url "title"`
4	//!
5	//! <https://spec.commonmark.org/0.30/#link-reference-definition>
6	//!
7	//! This plugin parses markdown link references. Check documentation on [ReferenceMap]
8	//! to see how you can use and/or extend it if you have external source for references.
9	//!
10	use derivative::Derivative;
11	use derive_more::{Deref, DerefMut};
12	use downcast_rs::{impl_downcast, Downcast};
13	use std::collections::HashMap;
14	use std::fmt::Debug;
15
16	use crate::common::utils::normalize_reference;
17	use crate::generics::inline::full_link;
18	use crate::parser::block::{BlockRule, BlockState};
19	use crate::parser::extset::RootExt;
20	use crate::{MarkdownIt, Node, NodeValue};
21
22	/// Storage for parsed references
23	///
24	/// if you have some external source for your link references, you can add them like this:
25	///
26	/// ```rust
27	/// use markdown_it::parser::block::builtin::BlockParserRule;
28	/// use markdown_it::parser::core::{CoreRule, Root};
29	/// use markdown_it::plugins::cmark::block::reference::{ReferenceMap, DefaultReferenceMap, CustomReferenceMap};
30	/// use markdown_it::{MarkdownIt, Node};
31	///
32	/// let md = &mut MarkdownIt::new();
33	/// markdown_it::plugins::cmark::add(md);
34	///
35	/// #[derive(Debug, Default)]
36	/// struct RefMapOverride(DefaultReferenceMap);
37	/// impl CustomReferenceMap for RefMapOverride {
38	/// fn get(&self, label: &str) -> Option<(&str, Option<&str>)> {
39	/// // override a specific link
40	/// if label == "rust" {
41	/// return Some((
42	/// "https://www.rust-lang.org/",
43	/// Some("The Rust Language"),
44	/// ));
45	/// }
46	///
47	/// self.0.get(label)
48	/// }
49	///
50	/// fn insert(&mut self, label: String, destination: String, title: Option<String>) -> bool {
51	/// self.0.insert(label, destination, title)
52	/// }
53	/// }
54	///
55	/// struct AddCustomReferences;
56	/// impl CoreRule for AddCustomReferences {
57	/// fn run(root: &mut Node, _: &MarkdownIt) {
58	/// let data = root.cast_mut::<Root>().unwrap();
59	/// data.ext.insert(ReferenceMap::new(RefMapOverride::default()));
60	/// }
61	/// }
62	///
63	/// md.add_rule::<AddCustomReferences>()
64	/// .before::<BlockParserRule>();
65	///
66	/// let html = md.parse("[rust]").render();
67	/// assert_eq!(
68	/// html.trim(),
69	/// r#"<p><a href="https://www.rust-lang.org/" title="The Rust Language">rust</a></p>"#
70	/// );
71	/// ```
72	///
73	/// You can also view all references that user created by adding the following rule:
74	///
75	/// ```rust
76	/// use markdown_it::parser::core::{CoreRule, Root};
77	/// use markdown_it::plugins::cmark::block::reference::{ReferenceMap, DefaultReferenceMap};
78	/// use markdown_it::{MarkdownIt, Node};
79	///
80	/// let md = &mut MarkdownIt::new();
81	/// markdown_it::plugins::cmark::add(md);
82	///
83	/// let ast = md.parse("[hello]: world");
84	/// let root = ast.node_value.downcast_ref::<Root>().unwrap();
85	/// let refmap = root.ext.get::<ReferenceMap>()
86	/// .map(\|m\| m.downcast_ref::<DefaultReferenceMap>().expect("expect references to be handled by default map"));
87	///
88	/// let mut labels = vec![];
89	/// if let Some(refmap) = refmap {
90	/// for (label, _dest, _title) in refmap.iter() {
91	/// labels.push(label);
92	/// }
93	/// }
94	///
95	/// assert_eq!(labels, ["hello"]);
96	/// ```
97	///
98	#[derive(Debug, Deref, DerefMut)]
99	#[deref(forward)]
100	#[deref_mut(forward)]
101	pub struct ReferenceMap(Box<dyn CustomReferenceMap>);
102
103	impl ReferenceMap {
104	pub fn new(custom_map: impl CustomReferenceMap + 'static) -> Self {
105	Self(Box::new(custom_map))
106	}
107	}
108
109	impl Default for ReferenceMap {
110	fn default() -> Self {
111	Self::new(DefaultReferenceMap::new())
112	}
113	}
114
115	impl RootExt for ReferenceMap {}
116
117	pub trait CustomReferenceMap : Debug + Downcast + Send + Sync {
118	/// Insert new element to the reference map. You may return false if it's not a valid label to stop parsing.
119	fn insert(&mut self, label: String, destination: String, title: Option<String>) -> bool;
120
121	/// Get an element referenced by `label` from the map, returns destination and optional title.
122	fn get(&self, label: &str) -> Option<(&str, Option<&str>)>;
123	}
124
125	impl_downcast!(CustomReferenceMap);
126
127	#[derive(Default, Debug)]
128	pub struct DefaultReferenceMap(HashMap<ReferenceMapKey, ReferenceMapEntry>);
129
130	impl DefaultReferenceMap {
131	pub fn new() -> Self {
132	Self::default()
133	}
134
135	pub fn iter(&self) -> impl Iterator<Item = (&str, &str, Option<&str>)> {
136	Box::new(self.0.iter().map(\|(a, b)\| {
137	(a.label.as_str(), b.destination.as_str(), b.title.as_deref())
138	}))
139	}
140	}
141
142	impl CustomReferenceMap for DefaultReferenceMap {
143	fn insert(&mut self, label: String, destination: String, title: Option<String>) -> bool {
144	let Some(key) = ReferenceMapKey::new(label) else { return false; };
145	self.0.entry(key)
146	.or_insert(ReferenceMapEntry::new(destination, title));
147	true
148	}
149
150	fn get(&self, label: &str) -> Option<(&str, Option<&str>)> {
151	let key = ReferenceMapKey::new(label.to_owned())?;
152	self.0.get(&key)
153	.map(\|r\| (r.destination.as_str(), r.title.as_deref()))
154	}
155	}
156
157	#[derive(Derivative)]
158	#[derivative(Debug, Default, Hash, PartialEq, Eq)]
159	/// Reference label
160	struct ReferenceMapKey {
161	#[derivative(PartialEq = "ignore")]
162	#[derivative(Hash = "ignore")]
163	pub label: String,
164	normalized: String,
165	}
166
167	impl ReferenceMapKey {
168	pub fn new(label: String) -> Option<Self> {
169	let normalized = normalize_reference(&label);
170
171	if normalized.is_empty() {
172	// CommonMark 0.20 disallows empty labels
173	return None;
174	}
175
176	Some(Self { label, normalized })
177	}
178	}
179
180	#[derive(Debug, Default)]
181	/// Reference value
182	struct ReferenceMapEntry {
183	pub destination: String,
184	pub title: Option<String>,
185	}
186
187	impl ReferenceMapEntry {
188	pub fn new(destination: String, title: Option<String>) -> Self {
189	Self { destination, title }
190	}
191	}
192
193	/// Add plugin that parses markdown link references
194	pub fn add(md: &mut MarkdownIt) {
195	md.block.add_rule::<ReferenceScanner>();
196	}
197
198	#[derive(Debug)]
199	pub struct Definition {
200	pub label: String,
201	pub destination: String,
202	pub title: Option<String>,
203	}
204	impl NodeValue for Definition {
205	fn render(&self, _: &Node, _: &mut dyn crate::Renderer) {}
206	}
207
208	#[doc(hidden)]
209	pub struct ReferenceScanner;
210	impl BlockRule for ReferenceScanner {
211	fn check(_: &mut BlockState) -> Option<()> {
212	None // can't interrupt anything
213	}
214
215	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
216
217	if state.line_indent(state.line) >= state.md.max_indent { return None; }
218
219	let mut chars = state.get_line(state.line).chars();
220
221	let Some('[') = chars.next() else { return None; };
222
223	// Simple check to quickly interrupt scan on [link](url) at the start of line.
224	// Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54
225	loop {
226	match chars.next() {
227	Some('\\') => { chars.next(); },
228	Some(']') => {
229	if let Some(':') = chars.next() {
230	break;
231	} else {
232	return None;
233	}
234	}
235	Some(_) => {},
236	None => break,
237	}
238	}
239
240	let start_line = state.line;
241	let mut next_line = start_line;
242
243	// jump line-by-line until empty one or EOF
244	'outer: loop {
245	next_line += 1;
246
247	if next_line >= state.line_max \|\| state.is_empty(next_line) { break; }
248
249	// this may be a code block normally, but after paragraph
250	// it's considered a lazy continuation regardless of what's there
251	if state.line_indent(next_line) >= state.md.max_indent { continue; }
252
253	// quirk for blockquotes, this line should already be checked by that rule
254	if state.line_offsets[next_line].indent_nonspace < 0 { continue; }
255
256	// Some tags can terminate paragraph without empty line.
257	let old_state_line = state.line;
258	state.line = next_line;
259	if state.test_rules_at_line() {
260	state.line = old_state_line;
261	break 'outer;
262	}
263	state.line = old_state_line;
264	}
265
266	let (str_before_trim, _) = state.get_lines(start_line, next_line, state.blk_indent, false);
267	let str = str_before_trim.trim();
268	let mut chars = str.char_indices();
269	chars.next(); // skip '['
270	let label_end;
271	let mut lines = 0;
272
273	loop {
274	match chars.next() {
275	Some((_, '[')) => return None,
276	Some((p, ']')) => {
277	label_end = p;
278	break;
279	}
280	Some((_, '\n')) => lines += 1,
281	Some((_, '\\')) => {
282	if let Some((_, '\n')) = chars.next() {
283	lines += 1;
284	}
285	}
286	Some(_) => {},
287	None => return None,
288	}
289	}
290
291	let Some((_, ':')) = chars.next() else { return None; };
292
293	// [label]: destination 'title'
294	// ^^^ skip optional whitespace here
295	let mut pos = label_end + 2;
296	while let Some((_, ch @ (' ' \| '\t' \| '\n'))) = chars.next() {
297	if ch == '\n' { lines += 1; }
298	pos += 1;
299	}
300
301	// [label]: destination 'title'
302	// ^^^^^^^^^^^ parse this
303	let href;
304	if let Some(res) = full_link::parse_link_destination(str, pos, str.len()) {
305	if pos == res.pos { return None; }
306	href = state.md.link_formatter.normalize_link(&res.str);
307	state.md.link_formatter.validate_link(&href)?;
308	pos = res.pos;
309	lines += res.lines;
310	} else {
311	return None;
312	}
313
314	// save cursor state, we could require to rollback later
315	let dest_end_pos = pos;
316	let dest_end_lines = lines;
317
318	// [label]: destination 'title'
319	// ^^^ skipping those spaces
320	let start = pos;
321	let mut chars = str[pos..].chars();
322	while let Some(ch @ (' ' \| '\t' \| '\n')) = chars.next() {
323	if ch == '\n' { lines += 1; }
324	pos += 1;
325	}
326
327	// [label]: destination 'title'
328	// ^^^^^^^ parse this
329	let mut title = None;
330	if pos != start {
331	if let Some(res) = full_link::parse_link_title(str, pos, str.len()) {
332	title = Some(res.str);
333	pos = res.pos;
334	lines += res.lines;
335	} else {
336	pos = dest_end_pos;
337	lines = dest_end_lines;
338	}
339	}
340
341	// skip trailing spaces until the rest of the line
342	let mut chars = str[pos..].chars();
343	loop {
344	match chars.next() {
345	Some(' ' \| '\t') => pos += 1,
346	Some('\n') \| None => break,
347	Some(_) if title.is_some() => {
348	// garbage at the end of the line after title,
349	// but it could still be a valid reference if we roll back
350	title = None;
351	pos = dest_end_pos;
352	lines = dest_end_lines;
353	chars = str[pos..].chars();
354	}
355	Some(_) => {
356	// garbage at the end of the line
357	return None;
358	}
359	}
360	}
361
362	let references = state.root_ext.get_or_insert_default::<ReferenceMap>();
363	if !references.insert(str[1..label_end].to_owned(), href.clone(), title.clone()) { return None; }
364
365	Some((Node::new(
366	Definition {
367	label: str[1..label_end].to_owned(),
368	destination: href,
369	title
370	}),
371	lines + 1
372	))
373	}
374	}

crates/markdown-it/src/plugins/cmark/inline/autolink.rs created+87

...	@@ -0,0 +1,87 @@
1	//! Autolinks
2	//!
3	//! `<https://example.org>`
4	//!
5	//! <https://spec.commonmark.org/0.30/#autolinks>
6	use once_cell::sync::Lazy;
7	use regex::Regex;
8
9	use crate::parser::inline::{InlineRule, InlineState, TextSpecial};
10	use crate::{MarkdownIt, Node, NodeValue, Renderer};
11
12	#[derive(Debug)]
13	pub struct Autolink {
14	pub url: String,
15	}
16
17	impl NodeValue for Autolink {
18	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
19	let mut attrs = node.attrs.clone();
20	attrs.push(("href", self.url.clone()));
21
22	fmt.open("a", &attrs);
23	fmt.contents(&node.children);
24	fmt.close("a");
25	}
26	}
27
28	pub fn add(md: &mut MarkdownIt) {
29	md.inline.add_rule::<AutolinkScanner>();
30	}
31
32	static AUTOLINK_RE : Lazy<Regex> = Lazy::new(\|\| {
33	Regex::new(r"^([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)$").unwrap()
34	});
35
36	static EMAIL_RE : Lazy<Regex> = Lazy::new(\|\| {
37	Regex::new(r"^([a-zA-Z0-9.!#$%&'+/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?))$").unwrap()
38	});
39
40	#[doc(hidden)]
41	pub struct AutolinkScanner;
42	impl InlineRule for AutolinkScanner {
43	const MARKER: char = '<';
44
45	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
46	let mut chars = state.src[state.pos..state.pos_max].chars();
47	if chars.next().unwrap() != '<' { return None; }
48
49	let mut pos = state.pos + 2;
50
51	loop {
52	match chars.next() {
53	Some('<') \| None => return None,
54	Some('>') => break,
55	Some(x) => pos += x.len_utf8(),
56	}
57	}
58
59	let url = &state.src[state.pos+1..pos-1];
60	let is_autolink = AUTOLINK_RE.is_match(url);
61	let is_email = EMAIL_RE.is_match(url);
62
63	if !is_autolink && !is_email { return None; }
64
65	let full_url = if is_autolink {
66	state.md.link_formatter.normalize_link(url)
67	} else {
68	state.md.link_formatter.normalize_link(&("mailto:".to_owned() + url))
69	};
70
71	state.md.link_formatter.validate_link(&full_url)?;
72
73	let content = state.md.link_formatter.normalize_link_text(url);
74
75	let mut inner_node = Node::new(TextSpecial {
76	content: content.clone(),
77	markup: content,
78	info: "autolink",
79	});
80	inner_node.srcmap = state.get_map(state.pos + 1, pos - 1);
81
82	let mut node = Node::new(Autolink { url: full_url });
83	node.children.push(inner_node);
84
85	Some((node, pos - state.pos))
86	}
87	}

crates/markdown-it/src/plugins/cmark/inline/backticks.rs created+28

...	@@ -0,0 +1,28 @@
1	//! Code spans
2	//!
3	//! `` `looks like this` ``
4	//!
5	//! <https://spec.commonmark.org/0.30/#code-span>
6	use crate::generics::inline::code_pair;
7	use crate::{MarkdownIt, Node, NodeValue, Renderer};
8
9	#[derive(Debug)]
10	pub struct CodeInline {
11	pub marker: char,
12	pub marker_len: usize,
13	}
14
15	impl NodeValue for CodeInline {
16	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
17	fmt.open("code", &node.attrs);
18	fmt.contents(&node.children);
19	fmt.close("code");
20	}
21	}
22
23	pub fn add(md: &mut MarkdownIt) {
24	code_pair::add_with::<'`'>(md, \|len\| Node::new(CodeInline {
25	marker: '`',
26	marker_len: len,
27	}));
28	}

crates/markdown-it/src/plugins/cmark/inline/emphasis.rs created+40

...	@@ -0,0 +1,40 @@
1	//! Emphasis and strong emphasis
2	//!
3	//! looks like `this` or `__that__`
4	//!
5	//! <https://spec.commonmark.org/0.30/#emphasis-and-strong-emphasis>
6	use crate::generics::inline::emph_pair;
7	use crate::{MarkdownIt, Node, NodeValue, Renderer};
8
9	#[derive(Debug)]
10	pub struct Em {
11	pub marker: char
12	}
13
14	impl NodeValue for Em {
15	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
16	fmt.open("em", &node.attrs);
17	fmt.contents(&node.children);
18	fmt.close("em");
19	}
20	}
21
22	#[derive(Debug)]
23	pub struct Strong {
24	pub marker: char
25	}
26
27	impl NodeValue for Strong {
28	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
29	fmt.open("strong", &node.attrs);
30	fmt.contents(&node.children);
31	fmt.close("strong");
32	}
33	}
34
35	pub fn add(md: &mut MarkdownIt) {
36	emph_pair::add_with::<'', 1, true> (md, \|\| Node::new(Em { marker: '' }));
37	emph_pair::add_with::<'_', 1, false> (md, \|\| Node::new(Em { marker: '_' }));
38	emph_pair::add_with::<'', 2, true> (md, \|\| Node::new(Strong { marker: '' }));
39	emph_pair::add_with::<'_', 2, false> (md, \|\| Node::new(Strong { marker: '_' }));
40	}

crates/markdown-it/src/plugins/cmark/inline/entity.rs created+85

...	@@ -0,0 +1,85 @@
1	//! Entity and numeric character references
2	//!
3	//! `{`, `¯`, `"`
4	//!
5	//! <https://spec.commonmark.org/0.30/#entity-and-numeric-character-references>
6	use once_cell::sync::Lazy;
7	use regex::Regex;
8
9	use crate::common::utils::{get_entity_from_str, is_valid_entity_code};
10	use crate::parser::inline::{InlineRule, InlineState, TextSpecial};
11	use crate::{MarkdownIt, Node};
12
13	pub fn add(md: &mut MarkdownIt) {
14	md.inline.add_rule::<EntityScanner>();
15	}
16
17	static DIGITAL_RE : Lazy<Regex> = Lazy::new(\|\| {
18	Regex::new("(?i)^&#((?:x[a-f0-9]{1,6}\|[0-9]{1,7}));").unwrap()
19	});
20
21	static NAMED_RE : Lazy<Regex> = Lazy::new(\|\| {
22	Regex::new("(?i)^&([a-z][a-z0-9]{1,31});").unwrap()
23	});
24
25	#[doc(hidden)]
26	pub struct EntityScanner;
27
28	impl EntityScanner {
29	fn parse_digital_entity(state: &mut InlineState) -> Option<(Node, usize)> {
30	let capture = DIGITAL_RE.captures(&state.src[state.pos..])?;
31	let entity_len = capture[0].len();
32	let entity = &capture[1];
33	#[allow(clippy::from_str_radix_10)]
34	let code = if entity.starts_with('x') \|\| entity.starts_with('X') {
35	u32::from_str_radix(&entity[1..], 16).unwrap()
36	} else {
37	u32::from_str_radix(entity, 10).unwrap()
38	};
39
40	let content_str = if is_valid_entity_code(code) {
41	char::from_u32(code).unwrap().into()
42	} else {
43	'\u{FFFD}'.into()
44	};
45
46	let markup_str = capture[0].to_owned();
47
48	let node = Node::new(TextSpecial {
49	content: content_str,
50	markup: markup_str,
51	info: "entity",
52	});
53	Some((node, entity_len))
54	}
55
56	fn parse_named_entity(state: &mut InlineState) -> Option<(Node, usize)> {
57	let capture = NAMED_RE.captures(&state.src[state.pos..])?;
58	let str = get_entity_from_str(&capture[0])?;
59	let entity_len = capture[0].len();
60	let markup_str = capture[0].to_owned();
61	let content_str = (*str).to_owned();
62
63	let node = Node::new(TextSpecial {
64	content: content_str,
65	markup: markup_str,
66	info: "entity",
67	});
68	Some((node, entity_len))
69	}
70	}
71
72	impl InlineRule for EntityScanner {
73	const MARKER: char = '&';
74
75	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
76	let mut chars = state.src[state.pos..state.pos_max].chars();
77	if chars.next().unwrap() != '&' { return None; }
78
79	if let Some('#') = chars.next() {
80	Self::parse_digital_entity(state)
81	} else {
82	Self::parse_named_entity(state)
83	}
84	}
85	}

crates/markdown-it/src/plugins/cmark/inline/escape.rs created+57

...	@@ -0,0 +1,57 @@
1	//! Backslash escapes
2	//!
3	//! Allows escapes like `\hello`, also processes hard breaks at the end
4	//! of the line.
5	//!
6	//! <https://spec.commonmark.org/0.30/#backslash-escapes>
7	use crate::parser::inline::{InlineRule, InlineState, TextSpecial};
8	use crate::plugins::cmark::inline::newline::Hardbreak;
9	use crate::{MarkdownIt, Node};
10
11	pub fn add(md: &mut MarkdownIt) {
12	md.inline.add_rule::<EscapeScanner>();
13	}
14
15	#[doc(hidden)]
16	pub struct EscapeScanner;
17	impl InlineRule for EscapeScanner {
18	const MARKER: char = '\\';
19
20	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
21	let mut chars = state.src[state.pos..state.pos_max].chars();
22	if chars.next().unwrap() != '\\' { return None; }
23
24	match chars.next() {
25	Some('\n') => {
26	// skip leading whitespaces from next line
27	let mut len = 2;
28	while let Some(' ' \| '\t') = chars.next() {
29	len += 1;
30	}
31	Some((Node::new(Hardbreak), len))
32	}
33	Some(chr) => {
34	let start = state.pos;
35	let end = state.pos + 1 + chr.len_utf8();
36
37	let mut orig_str = "\\".to_owned();
38	orig_str.push(chr);
39
40	let content_str = match chr {
41	'\\' \| '!' \| '"' \| '#' \| '$' \| '%' \| '&' \| '\'' \| '(' \| ')' \|
42	'*' \| '+' \| ',' \| '.' \| '/' \| ':' \| ';' \| '<' \| '=' \| '>' \| '?' \|
43	'@' \| '[' \| ']' \| '^' \| '_' \| '`' \| '{' \| '\|' \| '}' \| '~' \| '-' => chr.into(),
44	_ => orig_str.clone()
45	};
46
47	let node = Node::new(TextSpecial {
48	content: content_str,
49	markup: orig_str,
50	info: "escape",
51	});
52	Some((node, end - start))
53	}
54	None => None
55	}
56	}
57	}

crates/markdown-it/src/plugins/cmark/inline/image.rs created+34

...	@@ -0,0 +1,34 @@
1	//! Images
2	//!
3	//! `![image](<src> "title")`
4	//!
5	//! <https://spec.commonmark.org/0.30/#images>
6	use crate::generics::inline::full_link;
7	use crate::{MarkdownIt, Node, NodeValue, Renderer};
8
9	#[derive(Debug)]
10	pub struct Image {
11	pub url: String,
12	pub title: Option<String>,
13	}
14
15	impl NodeValue for Image {
16	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
17	let mut attrs = node.attrs.clone();
18	attrs.push(("src", self.url.clone()));
19	attrs.push(("alt", node.collect_text()));
20
21	if let Some(title) = &self.title {
22	attrs.push(("title", title.clone()));
23	}
24
25	fmt.self_close("img", &attrs);
26	}
27	}
28
29	pub fn add(md: &mut MarkdownIt) {
30	full_link::add_prefix::<'!', true>(md, \|href, title\| Node::new(Image {
31	url: href.unwrap_or_default(),
32	title,
33	}));
34	}

crates/markdown-it/src/plugins/cmark/inline/link.rs created+35

...	@@ -0,0 +1,35 @@
1	//! Links
2	//!
3	//! `![link](<to> "stuff")`
4	//!
5	//! <https://spec.commonmark.org/0.30/#links>
6	use crate::generics::inline::full_link;
7	use crate::{MarkdownIt, Node, NodeValue, Renderer};
8
9	#[derive(Debug)]
10	pub struct Link {
11	pub url: String,
12	pub title: Option<String>,
13	}
14
15	impl NodeValue for Link {
16	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
17	let mut attrs = node.attrs.clone();
18	attrs.push(("href", self.url.clone()));
19
20	if let Some(title) = &self.title {
21	attrs.push(("title", title.clone()));
22	}
23
24	fmt.open("a", &attrs);
25	fmt.contents(&node.children);
26	fmt.close("a");
27	}
28	}
29
30	pub fn add(md: &mut MarkdownIt) {
31	full_link::add::<false>(md, \|href, title\| Node::new(Link {
32	url: href.unwrap_or_default(),
33	title,
34	}));
35	}

crates/markdown-it/src/plugins/cmark/inline/mod.rs created+9

...	@@ -0,0 +1,9 @@
1	//! Inline-level CommonMark structures.
2	pub mod autolink;
3	pub mod backticks;
4	pub mod emphasis;
5	pub mod entity;
6	pub mod escape;
7	pub mod image;
8	pub mod link;
9	pub mod newline;

crates/markdown-it/src/plugins/cmark/inline/newline.rs created+81

...	@@ -0,0 +1,81 @@
1	//! Line breaks
2	//!
3	//! Processes EOL (`\n`, soft and hard breaks).
4	//!
5	//! - <https://spec.commonmark.org/0.30/#hard-line-breaks>
6	//! - <https://spec.commonmark.org/0.30/#soft-line-breaks>
7	use crate::parser::inline::{InlineRule, InlineState};
8	use crate::{MarkdownIt, Node, NodeValue, Renderer};
9
10	#[derive(Debug)]
11	pub struct Hardbreak;
12
13	impl NodeValue for Hardbreak {
14	fn render(&self, _: &Node, fmt: &mut dyn Renderer) {
15	fmt.self_close("br", &[]);
16	fmt.cr();
17	}
18	}
19
20	#[derive(Debug)]
21	pub struct Softbreak;
22
23	impl NodeValue for Softbreak {
24	fn render(&self, _: &Node, fmt: &mut dyn Renderer) {
25	fmt.cr();
26	}
27	}
28
29	pub fn add(md: &mut MarkdownIt) {
30	md.inline.add_rule::<NewlineScanner>();
31	}
32
33	#[doc(hidden)]
34	pub struct NewlineScanner;
35	impl InlineRule for NewlineScanner {
36	const MARKER: char = '\n';
37
38	fn check(state: &mut InlineState) -> Option<usize> {
39	// check rule is required because run() modifies trailing text
40	let mut chars = state.src[state.pos..state.pos_max].chars();
41	if chars.next().unwrap() != '\n' { return None; }
42	Some(1)
43	}
44
45	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
46	let mut chars = state.src[state.pos..state.pos_max].chars();
47
48	if chars.next().unwrap() != '\n' { return None; }
49
50	let mut pos = state.pos;
51	pos += 1;
52
53	// skip leading whitespaces from next line
54	while let Some(' ' \| '\t') = chars.next() {
55	pos += 1;
56	}
57
58	// ' \n' -> hardbreak
59	let mut tail_size = 0;
60	let trailing_text = state.trailing_text_get();
61
62	for ch in trailing_text.chars().rev() {
63	if ch == ' ' {
64	tail_size += 1;
65	} else {
66	break;
67	}
68	}
69
70	state.trailing_text_pop(tail_size);
71
72	let node = if tail_size >= 2 {
73	Node::new(Hardbreak)
74	} else {
75	Node::new(Softbreak)
76	};
77
78	state.pos -= tail_size; // backtrack to include tail in source maps
79	Some((node, pos - state.pos))
80	}
81	}

crates/markdown-it/src/plugins/cmark/mod.rs created+34

...	@@ -0,0 +1,34 @@
1	//! Basic markdown syntax, you probably want to add this.
2	//!
3	//! This is full implementation of [CommonMark](https://spec.commonmark.org/0.30/)
4	//! standard (with the exception of HTML inlines/blocks which are moved to separate
5	//! [plugin](crate::plugins::html) for security reasons).
6	//!
7	//! [cmark::add](self::add) function adds all features at once. If you only want
8	//! to enable some of it (e.g. disable images), you can add each syntax one by one
9	//! by invoking `add` function of the respective module.
10	pub mod block;
11	pub mod inline;
12
13	use crate::MarkdownIt;
14
15	pub fn add(md: &mut MarkdownIt) {
16	inline::newline::add(md);
17	inline::escape::add(md);
18	inline::backticks::add(md);
19	inline::emphasis::add(md);
20	inline::link::add(md);
21	inline::image::add(md);
22	inline::autolink::add(md);
23	inline::entity::add(md);
24
25	block::code::add(md);
26	block::fence::add(md);
27	block::blockquote::add(md);
28	block::hr::add(md);
29	block::list::add(md);
30	block::reference::add(md);
31	block::heading::add(md);
32	block::lheading::add(md);
33	block::paragraph::add(md);
34	}

crates/markdown-it/src/plugins/extra/beautify_links.rs created+39

...	@@ -0,0 +1,39 @@
1	//! Pretty-print all urls and fit them into N characters
2
3	use crate::parser::linkfmt::{LinkFormatter, MDLinkFormatter};
4	use crate::MarkdownIt;
5
6	#[derive(Debug)]
7	struct LinkBeautifier {
8	max_length: usize,
9	parent: Box<dyn LinkFormatter>,
10	}
11
12	impl LinkFormatter for LinkBeautifier {
13	fn validate_link(&self, url: &str) -> Option<()> {
14	self.parent.as_ref().validate_link(url)
15	}
16
17	fn normalize_link(&self, url: &str) -> String {
18	mdurl::format_url_for_computers(url)
19	}
20
21	fn normalize_link_text(&self, url: &str) -> String {
22	mdurl::format_url_for_humans(url, self.max_length)
23	}
24	}
25
26
27	/// Add beautifier plugin, limiting urls to default 50 characters
28	pub fn add(md: &mut MarkdownIt) {
29	add_with_char_limit(md, 50);
30	}
31
32	/// Add beautifier plugin, limiting urls to `max_length` characters
33	pub fn add_with_char_limit(md: &mut MarkdownIt, max_length: usize) {
34	let parent = std::mem::replace(&mut md.link_formatter, Box::new(MDLinkFormatter::new()));
35	md.link_formatter = Box::new(LinkBeautifier {
36	max_length,
37	parent,
38	});
39	}

crates/markdown-it/src/plugins/extra/heading_anchors.rs created+69

...	@@ -0,0 +1,69 @@
1	//! Add id attribute (slug) to headings.
2	//!
3	//! ```rust
4	//! // it is recommended to use 3rd party slug implementation
5	//! //let slugify_fn = \|s: &str\| slug::slugify(s);
6	//! let slugify_fn = markdown_it::plugins::extra::heading_anchors::simple_slugify_fn;
7	//!
8	//! let md = &mut markdown_it::MarkdownIt::new();
9	//! markdown_it::plugins::cmark::add(md);
10	//! markdown_it::plugins::extra::heading_anchors::add(md, slugify_fn);
11	//!
12	//! assert_eq!(
13	//! md.parse("## An example heading").render(),
14	//! "<h2 id=\"an-example-heading\">An example heading</h2>\n",
15	//! );
16	//! ```
17	use std::fmt::Debug;
18
19	use crate::parser::core::CoreRule;
20	use crate::parser::extset::MarkdownItExt;
21	use crate::plugins::cmark::block::heading::ATXHeading;
22	use crate::plugins::cmark::block::lheading::SetextHeader;
23	use crate::{MarkdownIt, Node};
24
25	pub fn add(md: &mut MarkdownIt, slugify: fn (&str) -> String) {
26	md.ext.insert(SlugifyFunction(slugify));
27	md.add_rule::<AddHeadingAnchors>();
28	}
29
30	/// Simple built-in slugify function. It is added for testing and demonstration
31	/// purposes only, you should be using `slug`/`slugify` crate instead or your own impl.
32	pub fn simple_slugify_fn(s: &str) -> String {
33	s.chars().map(\|x\| {
34	if x.is_alphanumeric() {
35	x.to_ascii_lowercase()
36	} else {
37	'-'
38	}
39	}).collect()
40	}
41
42	#[derive(Clone, Copy)]
43	struct SlugifyFunction(fn (&str) -> String);
44	impl MarkdownItExt for SlugifyFunction {}
45
46	impl Default for SlugifyFunction {
47	fn default() -> Self {
48	Self(simple_slugify_fn)
49	}
50	}
51
52	impl Debug for SlugifyFunction {
53	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54	f.debug_struct("SlugifyFunction").finish()
55	}
56	}
57
58	pub struct AddHeadingAnchors;
59	impl CoreRule for AddHeadingAnchors {
60	fn run(root: &mut Node, md: &MarkdownIt) {
61	let slugify = md.ext.get::<SlugifyFunction>().copied().unwrap_or_default().0;
62
63	root.walk_mut(\|node, _\| {
64	if node.is::<ATXHeading>() \|\| node.is::<SetextHeader>() {
65	node.attrs.push(("id", slugify(&node.collect_text())));
66	}
67	});
68	}
69	}

crates/markdown-it/src/plugins/extra/linkify.rs created+135

...	@@ -0,0 +1,135 @@
1	//! Find urls and emails, and turn them into links
2
3	use linkify::{LinkFinder, LinkKind};
4	use once_cell::sync::Lazy;
5	use regex::Regex;
6	use std::cmp::Ordering;
7
8	use crate::parser::core::{CoreRule, Root};
9	use crate::parser::extset::RootExt;
10	use crate::parser::inline::builtin::InlineParserRule;
11	use crate::parser::inline::{InlineRule, InlineState, TextSpecial};
12	use crate::{MarkdownIt, Node, NodeValue, Renderer};
13
14	static SCHEME_RE : Lazy<Regex> = Lazy::new(\|\| {
15	Regex::new(r"(?i)(?:^\|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$").unwrap()
16	});
17
18	#[derive(Debug)]
19	pub struct Linkified {
20	pub url: String,
21	}
22
23	impl NodeValue for Linkified {
24	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
25	let mut attrs = node.attrs.clone();
26	attrs.push(("href", self.url.clone()));
27
28	fmt.open("a", &attrs);
29	fmt.contents(&node.children);
30	fmt.close("a");
31	}
32	}
33
34	pub fn add(md: &mut MarkdownIt) {
35	md.add_rule::<LinkifyPrescan>()
36	.before::<InlineParserRule>();
37
38	md.inline.add_rule::<LinkifyScanner>();
39	}
40
41	type LinkifyState = Vec<LinkifyPosition>;
42	impl RootExt for LinkifyState {}
43
44	#[derive(Debug, Clone, Copy)]
45	struct LinkifyPosition {
46	start: usize,
47	end: usize,
48	//email: bool,
49	}
50
51	#[doc(hidden)]
52	pub struct LinkifyPrescan;
53	impl CoreRule for LinkifyPrescan {
54	fn run(root: &mut Node, _: &MarkdownIt) {
55	let root_data = root.cast_mut::<Root>().unwrap();
56	let source = root_data.content.as_str();
57	let finder = LinkFinder::new();
58	let positions = finder.links(source).filter_map(\|link\| {
59	if *link.kind() == LinkKind::Url {
60	Some(LinkifyPosition {
61	start: link.start(),
62	end: link.end(),
63	//email: *link.kind() == LinkKind::Email,
64	})
65	} else {
66	None
67	}
68	}).collect::<Vec<_>>();
69	root_data.ext.insert(positions);
70	}
71	}
72
73	#[doc(hidden)]
74	pub struct LinkifyScanner;
75	impl InlineRule for LinkifyScanner {
76	const MARKER: char = ':';
77
78	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
79	let mut chars = state.src[state.pos..state.pos_max].chars();
80	if chars.next().unwrap() != ':' { return None; }
81	if state.link_level > 0 { return None; }
82
83	let trailing = state.trailing_text_get();
84	if !SCHEME_RE.is_match(trailing) { return None; }
85
86	let map = state.get_map(state.pos, state.pos_max)?;
87	let (start, _) = map.get_byte_offsets();
88
89	let positions = state.root_ext.get::<LinkifyState>().unwrap();
90
91	let found_idx = positions.binary_search_by(\|x\| {
92	if x.start >= start {
93	Ordering::Greater
94	} else if x.end <= start {
95	Ordering::Less
96	} else {
97	Ordering::Equal
98	}
99	}).ok()?;
100
101	let found = positions[found_idx];
102	let proto_size = start - found.start;
103	if proto_size > trailing.len() { return None; }
104
105	debug_assert_eq!(
106	&trailing[trailing.len()-proto_size..],
107	&state.src[state.pos-proto_size..state.pos]
108	);
109
110	let url_start = state.pos - proto_size;
111	let url_end = state.pos - proto_size + found.end - found.start;
112	if url_end > state.pos_max { return None; }
113
114	let url = &state.src[url_start..url_end];
115	let full_url = state.md.link_formatter.normalize_link(url);
116
117	state.md.link_formatter.validate_link(&full_url)?;
118
119	let content = state.md.link_formatter.normalize_link_text(url);
120
121	let mut inner_node = Node::new(TextSpecial {
122	content: content.clone(),
123	markup: content,
124	info: "autolink",
125	});
126	inner_node.srcmap = state.get_map(url_start, url_end);
127
128	let mut node = Node::new(Linkified { url: full_url });
129	node.children.push(inner_node);
130
131	state.trailing_text_pop(proto_size);
132	state.pos -= proto_size;
133	Some((node, url_end - url_start))
134	}
135	}

crates/markdown-it/src/plugins/extra/mod.rs created+44

...	@@ -0,0 +1,44 @@
1	//! Frequently used markdown extensions and stuff from GFM.
2	//!
3	//! - strikethrough (~~xxx~~~)
4	//! - tables
5	//! - linkify (convert http://example.com to a link)
6	//! - beautify links (cut "http://" from links and shorten paths)
7	//! - smartquotes and typographer
8	//! - code block highlighting using `syntect`
9	//!
10	//! ```rust
11	//! let md = &mut markdown_it::MarkdownIt::new();
12	//! markdown_it::plugins::cmark::add(md);
13	//! markdown_it::plugins::extra::add(md);
14	//!
15	//! let html = md.parse("hello ~~world~~").render();
16	//! assert_eq!(html.trim(), r#"<p>hello <s>world</s></p>"#);
17	//!
18	//! let html = md.parse(r#"Markdown done "The Right Way(TM)""#).render();
19	//! assert_eq!(html.trim(), r#"<p>Markdown done “The Right Way™”</p>"#);
20	//! ```
21	pub mod beautify_links;
22	pub mod heading_anchors;
23	#[cfg(feature = "linkify")]
24	pub mod linkify;
25	pub mod smartquotes;
26	pub mod strikethrough;
27	#[cfg(feature = "syntect")]
28	pub mod syntect;
29	pub mod tables;
30	pub mod typographer;
31
32	use crate::MarkdownIt;
33
34	pub fn add(md: &mut MarkdownIt) {
35	strikethrough::add(md);
36	beautify_links::add(md);
37	#[cfg(feature = "linkify")]
38	linkify::add(md);
39	tables::add(md);
40	#[cfg(feature = "syntect")]
41	syntect::add(md);
42	typographer::add(md);
43	smartquotes::add(md);
44	}

crates/markdown-it/src/plugins/extra/smartquotes.rs created+567

...	@@ -0,0 +1,567 @@
1	//! Replaces `"` and `'` quotes with "nicer" ones like `‘`, `’`, `“`, `”`, or
2	//! with `’` for words like "isn't".
3	//!
4	//! This currently only supports single character quotes, which is a limitation
5	//! of the Rust implementation due to the use of `const` generics.
6	//!
7	//! ## Implementation notes
8	//!
9	//! The main obstacle to implementing this was the fact that the document is
10	//! necessarily represented as a tree of nodes.
11	//! Each node is thus necessarily referenced by its parents, which means that an
12	//! any given moment we cannot hold a mutable reference to a node if any other
13	//! part of the code holds a reference to the document. At least that's my
14	//! understanding of the problem.
15	//! The smartquotes algorithm from the JS library makes heavy use of iteration
16	//! backwards and forwards through a flat list of tokens. This isn't really
17	//! possible in the Rust implementation. Building a flat representation of all
18	//! `Node` objects is easy, but holding that list precludes us from executing a
19	//! `root.walk_mut` call at the same time.
20	//! On top of that, while the smartquotes algorithm iterates linearly over all
21	//! nodes/tokens, looking at a specific token with index `j` can trigger
22	//! replacements in any of the tokens with `0` to `j - 1`.
23	//!
24	//! The solution proposed here is to first compute all the replacement
25	//! operations on a read-only flat view of the document, and _then_ to perform
26	//! all replacements in a single call to `root.walk_mut`.
27	use std::collections::HashMap;
28
29	use crate::common::utils::is_punct_char;
30	use crate::parser::core::CoreRule;
31	use crate::parser::inline::Text;
32	use crate::plugins::cmark::block::paragraph::Paragraph;
33	use crate::plugins::cmark::inline::newline::{Hardbreak, Softbreak};
34	use crate::plugins::html::html_inline::HtmlInline;
35	use crate::{MarkdownIt, Node};
36
37	const APOSTROPHE: char = '\u{2019}';
38	const SINGLE_QUOTE: char = '\'';
39	const DOUBLE_QUOTE: char = '"';
40	const SPACE: char = ' ';
41
42	/// Add smartquotes with the "classic" quote set of `‘`, `’`, `“`, and `”`.
43	pub fn add(md: &mut MarkdownIt) {
44	add_with::<'‘', '’', '“', '”'>(md);
45	}
46
47	pub fn add_with<
48	const OPEN_SINGLE_QUOTE: char,
49	const CLOSE_SINGLE_QUOTE: char,
50	const OPEN_DOUBLE_QUOTE: char,
51	const CLOSE_DOUBLE_QUOTE: char,
52	>(
53	md: &mut MarkdownIt,
54	) {
55	md.add_rule::<SmartQuotesRule<
56	OPEN_SINGLE_QUOTE,
57	CLOSE_SINGLE_QUOTE,
58	OPEN_DOUBLE_QUOTE,
59	CLOSE_DOUBLE_QUOTE>>();
60	}
61
62	/// Simplified Node type that only holds the info we need
63	///
64	/// To replace quotes, we'll be iterating forward and backward over the nodes in
65	/// our document tree. The `Node` class doesn't provide a mechanism to do this
66	/// efficiently, and in any case we only care about certain parts of the
67	/// information. This struct will be used to build a flat view of the document;
68	/// the `Irrelevant` variant serves as a "filler" so that the indexes of the
69	/// entries line up correctly with the order we see during tree traversal.
70	enum FlatToken<'a> {
71	LineBreak,
72	Text {
73	content: &'a str,
74	nesting_level: u32,
75	},
76	HtmlInline {
77	content: &'a str,
78	},
79	Irrelevant,
80	}
81
82	/// A simple enum to distinguish single and double quotes
83	#[derive(PartialEq, Eq, Debug, Clone, Copy)]
84	enum QuoteType {
85	Single,
86	Double,
87	}
88
89	/// Holds information about quotes we have encountered thus far.
90	///
91	/// These quotes may or may not be used to close a pair further down the line.
92	/// The different fields thus hold all the information we need to a) decide
93	/// whether or not to match them up with another quote we encounter, and b) to
94	/// perform the correct replacement, should be indeed use this quote to close a
95	/// pair.
96	struct QuoteMarker {
97	/// The iteration index of the node in which this quote was found.
98	///
99	/// This is the index at which this quote's `Node` appears in a pre-order
100	/// depth-first walk of the document tree. Since we can only _modify_ nodes
101	/// during a walk, we rely on this index to tell us which nodes to modify.
102	walk_index: usize,
103	/// The position of the quote within node's `content`
104	quote_position: usize,
105	/// Whether this is a single or a double quote
106	quote_type: QuoteType,
107	/// Nesting level of the containing token
108	///
109	/// This is the nesting of the containing `Node` within the document tree.
110	/// It is used to decide which quotes can be matched up.
111	level: u32,
112	}
113
114	/// Description of a single quote replacement to be executed
115	///
116	/// As described above, we have to compute the replacements in a first step that
117	/// treats the entire document tree read-only. Only then can we perform the
118	/// actual replacements. This `struct` holds the information we need to perform
119	/// the replacement of a single quote character during a `walk_mut`.
120	struct ReplacementOp {
121	walk_index: usize,
122	quote_position: usize,
123	quote: char,
124	}
125
126	pub struct SmartQuotesRule<
127	const OPEN_SINGLE_QUOTE: char,
128	const CLOSE_SINGLE_QUOTE: char,
129	const OPEN_DOUBLE_QUOTE: char,
130	const CLOSE_DOUBLE_QUOTE: char,
131	>;
132
133	impl<
134	const OPEN_SINGLE_QUOTE: char,
135	const CLOSE_SINGLE_QUOTE: char,
136	const OPEN_DOUBLE_QUOTE: char,
137	const CLOSE_DOUBLE_QUOTE: char,
138	> CoreRule
139	for SmartQuotesRule<
140	OPEN_SINGLE_QUOTE,
141	CLOSE_SINGLE_QUOTE,
142	OPEN_DOUBLE_QUOTE,
143	CLOSE_DOUBLE_QUOTE,
144	>
145	{
146	fn run(root: &mut Node, _: &MarkdownIt) {
147	let text_tokens = all_text_tokens(root);
148
149	let replacement_ops = Self::compute_replacements(text_tokens);
150
151	// now that we know what we want to replace where, we go over the nodes a _third_ time to do all the actual replacements.
152	let mut current_index: usize = 0;
153
154	root.walk_mut(\|node, _\| {
155	if let Some(current_replacements) = replacement_ops.get(&current_index) {
156	let text_node = node.cast_mut::<Text>()
157	.expect("Expected to find a text node at this index because we constructed our replacements HashMap accordingly.");
158	text_node.content = execute_replacements(current_replacements, &text_node.content);
159	};
160	current_index += 1;
161	});
162	}
163	}
164
165	impl<
166	const OPEN_SINGLE_QUOTE: char,
167	const CLOSE_SINGLE_QUOTE: char,
168	const OPEN_DOUBLE_QUOTE: char,
169	const CLOSE_DOUBLE_QUOTE: char,
170	>
171	SmartQuotesRule<OPEN_SINGLE_QUOTE, CLOSE_SINGLE_QUOTE, OPEN_DOUBLE_QUOTE, CLOSE_DOUBLE_QUOTE>
172	{
173	/// Walk the list of tokens to figure out what needs replacing where. to do
174	/// this, we need to search back and forth over the nodes to find matching
175	/// quotes across nodes. The borrow checker won't let us handle the entire
176	/// set of nodes as mutable at the same time however, so all we do here is
177	/// figure out what we _want_ to replace in which node.
178	fn compute_replacements(text_tokens: Vec<FlatToken>) -> HashMap<usize, HashMap<usize, char>> {
179	let mut quote_stack: Vec<QuoteMarker> = Vec::new();
180	let mut replacement_ops: HashMap<usize, HashMap<usize, char>> = HashMap::new();
181	for (walk_index, token) in text_tokens.iter().enumerate() {
182	if let FlatToken::Text {
183	content,
184	nesting_level,
185	} = token
186	{
187	for op in Self::replace_smartquotes(
188	content,
189	walk_index,
190	*nesting_level,
191	&text_tokens,
192	&mut quote_stack,
193	) {
194	replacement_ops
195	.entry(op.walk_index)
196	.or_default()
197	.insert(op.quote_position, op.quote);
198	}
199	}
200	}
201	replacement_ops
202	}
203
204	/// Compute quote replacements found by looking at a single text block
205	fn replace_smartquotes(
206	content: &str,
207	walk_index: usize,
208	level: u32,
209	text_tokens: &[FlatToken],
210	quote_stack: &mut Vec<QuoteMarker>,
211	) -> Vec<ReplacementOp> {
212	truncate_stack(quote_stack, level);
213
214	let mut result: Vec<_> = Vec::new();
215	for (quote_position, quote_type) in find_quotes(content) {
216	let last_char = find_last_char_before(text_tokens, walk_index, quote_position);
217	let next_char = find_first_char_after(text_tokens, walk_index, quote_position);
218
219	let (can_open, can_close): (bool, bool) =
220	can_open_or_close(&quote_type, last_char, next_char);
221
222	if !can_open && !can_close {
223	// if this is a single quote then we're in the middle of a word and
224	// assume it to be an apostrophe
225	if quote_type == QuoteType::Single {
226	result.push(ReplacementOp {
227	walk_index,
228	quote_position,
229	quote: APOSTROPHE,
230	});
231	}
232	// in any case, we're done with this quote and continue searching
233	// for more quotes in this text block
234	continue;
235	}
236
237	if can_close {
238	if let Some((opening_op, closing_op, new_stack_len)) =
239	Self::try_close(quote_stack, walk_index, level, quote_type, quote_position)
240	{
241	quote_stack.truncate(new_stack_len);
242	result.push(opening_op);
243	result.push(closing_op);
244	continue;
245	}
246	}
247
248	if can_open {
249	quote_stack.push(QuoteMarker {
250	walk_index,
251	quote_position,
252	quote_type,
253	level,
254	});
255	} else if can_close && quote_type == QuoteType::Single {
256	result.push(ReplacementOp {
257	walk_index,
258	quote_position,
259	quote: APOSTROPHE,
260	});
261	}
262	}
263	result
264	}
265
266	/// Try to find a matching opening quote to the given one.
267	///
268	/// If a match is found, returns `Some` with two `ReplacementOp`s to be
269	/// added to the result, and with the resulting length of the `quote_stack`.
270	fn try_close(
271	quote_stack: &[QuoteMarker],
272	walk_index: usize,
273	level: u32,
274	quote_type: QuoteType,
275	quote_position: usize,
276	) -> Option<(ReplacementOp, ReplacementOp, usize)> {
277	for (j, other_item) in quote_stack.iter().enumerate().rev() {
278	if other_item.level < level {
279	return None;
280	}
281	if other_item.quote_type == quote_type && other_item.level == level {
282	return Some((
283	ReplacementOp {
284	walk_index: other_item.walk_index,
285	quote_position: other_item.quote_position,
286	quote: if quote_type == QuoteType::Single {
287	OPEN_SINGLE_QUOTE
288	} else {
289	OPEN_DOUBLE_QUOTE
290	},
291	},
292	ReplacementOp {
293	walk_index,
294	quote_position,
295	quote: if quote_type == QuoteType::Single {
296	CLOSE_SINGLE_QUOTE
297	} else {
298	CLOSE_DOUBLE_QUOTE
299	},
300	},
301	j,
302	));
303	}
304	}
305	None
306	}
307	}
308
309	/// Produces a simplified flat list of all tokens, with the necessary
310	/// information to do smart quote replacement.
311	///
312	/// This handles inline html and inline code like JS version seems to do.
313	/// This list is a work-around for the fact that we can't build a flat list of
314	/// all nodes for iteration back and forth, and at the same time do a mutable
315	/// walk on the document tree.
316	///
317	/// Returns a `Vec<FlatToken<'a>>` where `<'a>` is the same lifetime as `root`.
318	/// This simply reflects the fact that the `content: &str` entries of the
319	/// `FlatToken` structs reference the same memory as `root`'s children.
320	/// Every entry in the `Vec` will produce an entry in the result, meaning that
321	/// the index of a token in the resulting `Vec` will be the same as the index it
322	/// would get during a `root.walk` call.
323	fn all_text_tokens(root: &Node) -> Vec<FlatToken> {
324	let mut result = Vec::new();
325	let mut walk_index = 0;
326	root.walk(\|node, nesting_level\| {
327	if let Some(text_node) = node.cast::<Text>() {
328	result.push(FlatToken::Text {
329	content: &text_node.content,
330	nesting_level,
331	});
332	} else if let Some(html_node) = node.cast::<HtmlInline>() {
333	result.push(FlatToken::HtmlInline {
334	content: &html_node.content,
335	});
336	} else if node.is::<Paragraph>() \|\| node.is::<Hardbreak>() \|\| node.is::<Softbreak>() {
337	result.push(FlatToken::LineBreak);
338	} else {
339	result.push(FlatToken::Irrelevant);
340	}
341	walk_index += 1;
342	});
343	result
344	}
345
346	/// Checks whether we can open or close a pair of quotes, given the quote type
347	/// and the type of characters before and after the quote
348	fn can_open_or_close(quote_type: &QuoteType, last_char: char, next_char: char) -> (bool, bool) {
349	// special case: 1"" -> count first quote as an inch
350	// We handle this before doing anything else to simplify the conditions
351	// below.
352	let is_double = *quote_type == QuoteType::Double;
353	let next_is_double = next_char == DOUBLE_QUOTE;
354	let last_is_digit = last_char.is_ascii_digit();
355	if next_is_double && is_double && last_is_digit {
356	return (false, false);
357	}
358
359	// using `is_ascii_punctuation` here matches the JS version exactly, but
360	// that also means we might inherit that implementation's shortcomings
361	// by ignoring unicode punctuation. `is_punct_char` however should
362	// compensate for this.
363	let is_last_punctuation = last_char.is_ascii_punctuation() \|\| is_punct_char(last_char);
364	let is_next_punctuation = next_char.is_ascii_punctuation() \|\| is_punct_char(next_char);
365
366	// Yet again we rely on rust's built-in character handling. The definition
367	// of `is_whitespace` according to the unicode proplist.txt shows that the
368	// difference to the JS version.
369	// https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
370	//
371	// Recognized as whitespace by Rust, but not by JS:
372	// 0x85, 0x28, 0x29
373	let is_last_whitespace = last_char.is_whitespace();
374	let is_next_whitespace = next_char.is_whitespace();
375
376	let can_open =
377	!is_next_whitespace && (!is_next_punctuation \|\| is_last_whitespace \|\| is_last_punctuation);
378	let can_close =
379	!is_last_whitespace && (!is_last_punctuation \|\| is_next_whitespace \|\| is_next_punctuation);
380
381	if can_open && can_close {
382	// Replace quotes in the middle of punctuation sequence, but not
383	// in the middle of the words, i.e.:
384	//
385	// 1. foo " bar " baz - not replaced
386	// 2. foo-"-bar-"-baz - replaced
387	// 3. foo"bar"baz - not replaced
388	return (is_last_punctuation, is_next_punctuation);
389	}
390
391	(can_open, can_close)
392	}
393
394	/// Executes a set of character replacements on a string
395	fn execute_replacements(replacement_ops: &HashMap<usize, char>, content: &str) -> String {
396	content
397	.chars()
398	.enumerate()
399	.map(\|(i, c)\| *replacement_ops.get(&i).unwrap_or(&c))
400	.collect()
401	}
402
403	/// Truncates the stack of quotes following the JS implementation.
404	///
405	/// This _might_ be simplified by removing the `rev` call and using
406	/// `Vec::take_while` instead, but I'm not 100% sure yet that the levels on the
407	/// stack are really monotonously increasing, so I'm leaving it as is for now.
408	fn truncate_stack(quote_stack: &mut Vec<QuoteMarker>, level: u32) {
409	let stack_len = quote_stack
410	.iter()
411	.rev()
412	.skip_while(\|qm\| qm.level > level)
413	.count();
414	quote_stack.truncate(stack_len);
415	}
416
417	/// Finds all single or double quotes in a string, together with their positions
418	///
419	/// This might be replaced with a regex search, but not sure that's really worth
420	/// it, given that we only check for two fixed characters.
421	fn find_quotes(content: &str) -> impl Iterator<Item = (usize, QuoteType)> + '_ {
422	content.chars().enumerate().filter_map(\|(p, c)\| {
423	if c == SINGLE_QUOTE \|\| c == DOUBLE_QUOTE {
424	Some((
425	p,
426	if c == SINGLE_QUOTE {
427	QuoteType::Single
428	} else {
429	QuoteType::Double
430	},
431	))
432	} else {
433	None
434	}
435	})
436	}
437
438	/// Finds the next relevant character after a given position
439	///
440	/// This is the mirror image of `find_last_char_before`.
441	///
442	/// The position given is that of a quote we found. It is identified by its
443	/// token/node index and the position of the quote inside that token. The full
444	/// sequence of the text tokens is searched forwards from that point and the
445	/// first character is returned.
446	///
447	/// If a line break or the end of the document is encountered during search,
448	/// space (0x20) is returned.
449	///
450	/// This function is a bit simpler than `find_last_char_before` because Vec
451	/// conveniently returns None for out-of-range indexes at the top end, while not
452	/// allowing to index with negative index.
453	fn find_first_char_after(
454	text_tokens: &[FlatToken],
455	token_index: usize,
456	quote_position: usize,
457	) -> char {
458	for (idx_t, text_token) in text_tokens.iter().enumerate().skip(token_index) {
459	let token = match text_token {
460	FlatToken::LineBreak => return SPACE,
461	FlatToken::Text {
462	content,
463	nesting_level: _,
464	} => content,
465	FlatToken::HtmlInline {
466	content,
467	} => content,
468	FlatToken::Irrelevant => continue,
469	};
470	let start_index = if idx_t == token_index {
471	quote_position + 1
472	} else {
473	0
474	};
475	if let Some(c) = token.chars().nth(start_index) {
476	return c;
477	}
478	}
479	// this will be hit if we start searching at the last position of the last
480	// text token
481	SPACE
482	}
483
484	/// Finds the last relevant character before a given position
485	///
486	/// The position given is that of a quote we found. It is identified by its
487	/// token/node index and the position of the quote inside that token. The full
488	/// sequence of the text tokens is searched backwards from that point and the
489	/// first character is returned.
490	///
491	/// If a line break or the beginning of the document is encountered during
492	/// search, space (0x20) is returned.
493	fn find_last_char_before(
494	text_tokens: &[FlatToken],
495	token_index: usize,
496	quote_position: usize,
497	) -> char {
498	for idx_t in (0..=token_index).rev() {
499	let token = match &text_tokens[idx_t] {
500	FlatToken::LineBreak => return SPACE,
501	FlatToken::Text {
502	content,
503	nesting_level: _,
504	} => content,
505	FlatToken::HtmlInline {
506	content,
507	} => content,
508	FlatToken::Irrelevant => continue,
509	};
510
511	// this is _not_ the first index we want to look at, but rather the
512	// index just _after_ that. The reason is simply that this is `usize`
513	// and we want to first check if it's possible to still subtract 1 from
514	// it without panicking.
515	let start_index: usize = if idx_t == token_index {
516	quote_position
517	} else {
518	token.chars().count()
519	};
520	// means we can't go any further left -> try the next token (i.e. the
521	// one preceding this one)
522	if start_index == 0 {
523	continue;
524	}
525	// unwrapping is safe here, we built our index to match the length of
526	// the string, or (in the case of the token containing the quote itself)
527	// it should be indexing a _prefix_ of the string.
528	return token.chars().nth(start_index - 1).unwrap();
529	}
530	// this will be hit if we find a quote in the first position of the first token
531	SPACE
532	}
533
534
535	#[cfg(test)]
536	mod tests {
537	#[test]
538	fn smartquotes_basics() {
539	let md = &mut crate::MarkdownIt::new();
540	crate::plugins::cmark::add(md);
541	crate::plugins::extra::smartquotes::add(md);
542	let html = md.parse(r#"'hello' "world""#).render();
543	assert_eq!(html.trim(), r#"<p>‘hello’ “world”</p>"#);
544	}
545
546	#[test]
547	fn smartquotes_shouldnt_affect_html() {
548	let md = &mut crate::MarkdownIt::new();
549	crate::plugins::cmark::add(md);
550	crate::plugins::html::html_inline::add(md);
551	crate::plugins::extra::smartquotes::add(md);
552	let html = md.parse(r#"<a href="hello"></a>"#).render();
553	assert_eq!(html.trim(), r#"<p><a href="hello"></a></p>"#);
554	}
555
556	#[test]
557	fn smartquotes_should_work_with_typographer() {
558	// regression test for https://github.com/rlidwka/markdown-it.rs/issues/26
559	let md = &mut crate::MarkdownIt::new();
560	crate::plugins::cmark::add(md);
561	crate::plugins::html::html_inline::add(md);
562	crate::plugins::extra::typographer::add(md);
563	crate::plugins::extra::smartquotes::add(md);
564	let html = md.parse("\"...\"").render();
565	assert_eq!(html.trim(), "<p>“<strong>…</strong>”</p>");
566	}
567	}

crates/markdown-it/src/plugins/extra/strikethrough.rs created+20

...	@@ -0,0 +1,20 @@
1	//! Strikethrough syntax (like `~~this~~`)
2	use crate::generics::inline::emph_pair;
3	use crate::{MarkdownIt, Node, NodeValue, Renderer};
4
5	#[derive(Debug)]
6	pub struct Strikethrough {
7	pub marker: char
8	}
9
10	impl NodeValue for Strikethrough {
11	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
12	fmt.open("s", &node.attrs);
13	fmt.contents(&node.children);
14	fmt.close("s");
15	}
16	}
17
18	pub fn add(md: &mut MarkdownIt) {
19	emph_pair::add_with::<'~', 2, true>(md, \|\| Node::new(Strikethrough { marker: '~' }));
20	}

crates/markdown-it/src/plugins/extra/syntect.rs created+74

...	@@ -0,0 +1,74 @@
1	//! Syntax highlighting for code blocks
2	use syntect::highlighting::ThemeSet;
3	use syntect::html::highlighted_html_for_string;
4	use syntect::parsing::SyntaxSet;
5
6	use crate::parser::core::CoreRule;
7	use crate::parser::extset::MarkdownItExt;
8	use crate::plugins::cmark::block::code::CodeBlock;
9	use crate::plugins::cmark::block::fence::CodeFence;
10	use crate::{MarkdownIt, Node, NodeValue, Renderer};
11
12	#[derive(Debug)]
13	pub struct SyntectSnippet {
14	pub html: String,
15	}
16
17	impl NodeValue for SyntectSnippet {
18	fn render(&self, _: &Node, fmt: &mut dyn Renderer) {
19	fmt.text_raw(&self.html);
20	}
21	}
22
23	#[derive(Debug, Clone, Copy)]
24	struct SyntectSettings(&'static str);
25	impl MarkdownItExt for SyntectSettings {}
26
27	impl Default for SyntectSettings {
28	fn default() -> Self {
29	Self("InspiredGitHub")
30	}
31	}
32
33	pub fn add(md: &mut MarkdownIt) {
34	md.add_rule::<SyntectRule>();
35	}
36
37	pub fn set_theme(md: &mut MarkdownIt, theme: &'static str) {
38	md.ext.insert(SyntectSettings(theme));
39	}
40
41	pub struct SyntectRule;
42	impl CoreRule for SyntectRule {
43	fn run(root: &mut Node, md: &MarkdownIt) {
44	let ss = SyntaxSet::load_defaults_newlines();
45	let ts = ThemeSet::load_defaults();
46	let theme = &ts.themes[md.ext.get::<SyntectSettings>().copied().unwrap_or_default().0];
47
48	root.walk_mut(\|node, _\| {
49	let mut content = None;
50	let mut language = None;
51
52	if let Some(data) = node.cast::<CodeBlock>() {
53	content = Some(&data.content);
54	} else if let Some(data) = node.cast::<CodeFence>() {
55	language = Some(data.info.clone());
56	content = Some(&data.content);
57	}
58
59	if let Some(content) = content {
60	let mut syntax = None;
61	if let Some(language) = language {
62	syntax = ss.find_syntax_by_token(&language);
63	}
64	let syntax = syntax.unwrap_or_else(\|\| ss.find_syntax_plain_text());
65
66	let html = highlighted_html_for_string(content, &ss, syntax, theme);
67
68	if let Ok(html) = html {
69	node.replace(SyntectSnippet { html });
70	}
71	}
72	});
73	}
74	}

crates/markdown-it/src/plugins/extra/tables.rs created+456

...	@@ -0,0 +1,456 @@
1	//! GFM tables
2	//!
3	//! <https://github.github.com/gfm/#tables-extension->
4	use crate::common::sourcemap::SourcePos;
5	use crate::parser::block::{BlockRule, BlockState};
6	use crate::parser::extset::RenderExt;
7	use crate::parser::inline::InlineRoot;
8	use crate::plugins::cmark::block::heading::HeadingScanner;
9	use crate::plugins::cmark::block::list::ListScanner;
10	use crate::{MarkdownIt, Node, NodeValue, Renderer};
11
12	#[derive(Debug)]
13	pub struct Table {
14	pub alignments: Vec<ColumnAlignment>,
15	}
16
17	impl NodeValue for Table {
18	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
19	let old_context = fmt.ext().remove::<TableRenderContext>();
20	fmt.ext().insert(TableRenderContext { head: false, alignments: self.alignments.clone(), index: 0 });
21
22	fmt.cr();
23	fmt.open("table", &node.attrs);
24	fmt.cr();
25	fmt.contents(&node.children);
26	fmt.cr();
27	fmt.close("table");
28	fmt.cr();
29
30	old_context.map(\|ctx\| fmt.ext().insert(ctx));
31	}
32	}
33
34	#[derive(Debug, Default)]
35	pub struct TableRenderContext {
36	pub head: bool,
37	pub index: usize,
38	pub alignments: Vec<ColumnAlignment>,
39	}
40
41	impl RenderExt for TableRenderContext {}
42
43	#[derive(Debug)]
44	pub struct TableHead;
45
46	impl NodeValue for TableHead {
47	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
48	let ctx = fmt.ext().get_or_insert_default::<TableRenderContext>();
49	ctx.head = true;
50
51	fmt.cr();
52	fmt.open("thead", &node.attrs);
53	fmt.cr();
54	fmt.contents(&node.children);
55	fmt.cr();
56	fmt.close("thead");
57	fmt.cr();
58
59	let ctx = fmt.ext().get_or_insert_default::<TableRenderContext>();
60	ctx.head = false;
61	}
62	}
63
64	#[derive(Debug)]
65	pub struct TableBody;
66
67	impl NodeValue for TableBody {
68	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
69	fmt.cr();
70	fmt.open("tbody", &node.attrs);
71	fmt.cr();
72	fmt.contents(&node.children);
73	fmt.cr();
74	fmt.close("tbody");
75	fmt.cr();
76	}
77	}
78
79	#[derive(Debug)]
80	pub struct TableRow;
81
82	impl NodeValue for TableRow {
83	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
84	let ctx = fmt.ext().get_or_insert_default::<TableRenderContext>();
85	ctx.index = 0;
86
87	fmt.cr();
88	fmt.open("tr", &node.attrs);
89	fmt.cr();
90	fmt.contents(&node.children);
91	fmt.cr();
92	fmt.close("tr");
93	fmt.cr();
94	}
95	}
96
97	#[derive(Debug)]
98	pub struct TableCell;
99
100	impl NodeValue for TableCell {
101	fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
102	let ctx = fmt.ext().get_or_insert_default::<TableRenderContext>();
103	let tag = if ctx.head { "th" } else { "td" };
104
105	let mut attrs = node.attrs.clone();
106
107	match ctx.alignments.get(ctx.index).copied().unwrap_or_default() {
108	ColumnAlignment::None => (),
109	ColumnAlignment::Left => attrs.push(("style", "text-align:left".to_owned())),
110	ColumnAlignment::Right => attrs.push(("style", "text-align:right".to_owned())),
111	ColumnAlignment::Center => attrs.push(("style", "text-align:center".to_owned())),
112	}
113
114	ctx.index += 1;
115
116	fmt.open(tag, &attrs);
117	fmt.contents(&node.children);
118	fmt.close(tag);
119	fmt.cr();
120	}
121	}
122
123	pub fn add(md: &mut MarkdownIt) {
124	md.block.add_rule::<TableScanner>()
125	.before::<ListScanner>()
126	.before::<HeadingScanner>();
127	}
128
129	#[doc(hidden)]
130	pub struct TableScanner;
131
132	#[derive(Debug)]
133	struct RowContent {
134	str: String,
135	srcmap: Vec<(usize, usize)>,
136	}
137
138	#[derive(Debug, Clone, Copy)]
139	pub enum ColumnAlignment {
140	None,
141	Left,
142	Right,
143	Center,
144	}
145
146	impl Default for ColumnAlignment {
147	fn default() -> Self { Self::None }
148	}
149
150	impl TableScanner {
151	fn scan_row(line: &str) -> Vec<RowContent> {
152	let mut result = Vec::new();
153	let mut str = String::new();
154	let mut srcmap = vec![(0, 0)];
155	let mut is_escaped = false;
156	let mut is_leading = true;
157
158	for (pos, ch) in line.char_indices() {
159	match ch {
160	' ' \| '\t' if is_leading => {
161	srcmap[0].1 += 1;
162	}
163	'\|' => {
164	is_leading = false;
165	if is_escaped {
166	str.push_str(&line[srcmap.last().unwrap().1..pos-1]);
167	srcmap.push((str.len(), pos));
168	} else {
169	str.push_str(&line[srcmap.last().unwrap().1..pos]);
170	result.push(RowContent {
171	str: std::mem::take(&mut str),
172	srcmap: std::mem::take(&mut srcmap),
173	});
174	srcmap = vec![(0, pos + 1)];
175	is_escaped = false;
176	is_leading = true;
177	}
178	}
179	'\\' => {
180	is_leading = false;
181	is_escaped = true;
182	}
183	_ => {
184	is_leading = false;
185	is_escaped = false;
186	}
187	}
188	}
189
190	str.push_str(&line[srcmap.last().unwrap().1..]);
191	result.push(RowContent {
192	str,
193	srcmap,
194	});
195
196	// trim trailing spaces
197	for content in result.iter_mut() {
198	while content.str.ends_with([ ' ', '\t' ]) {
199	content.str.pop();
200	}
201	}
202
203	// remove last cell if empty
204	if let Some(RowContent { str, srcmap: _ }) = result.last() {
205	if str.is_empty() { result.pop(); }
206	}
207
208	// remove first cell if empty
209	if let Some(RowContent { str, srcmap: _ }) = result.first() {
210	if str.is_empty() { result.remove(0); }
211	}
212
213	result
214	}
215
216	fn scan_alignment_row(line: &str) -> Option<Vec<ColumnAlignment>> {
217	// quick check second line, only allow :-\| and spaces
218	// (this is for performance only)
219	let mut has_delimiter = false;
220	for ch in line.chars() {
221	match ch {
222	'\|'\| ':' => { has_delimiter = true },
223	'-' \| ' ' \| '\t' => (),
224	_ => return None,
225	}
226	}
227	if !has_delimiter { return None; }
228
229	// if first character is '-', then second character must not be a space
230	// (due to parsing ambiguity with list)
231	if line.starts_with("- ") { return None; }
232
233	let mut result = Vec::new();
234
235	for RowContent { str, srcmap: _ } in Self::scan_row(line) {
236	let mut alignment : u8 = 0;
237	let mut cell = str.as_str();
238
239	if cell.starts_with(':') {
240	alignment \|= 1;
241	cell = &cell[1..];
242	}
243
244	if cell.ends_with(':') {
245	alignment \|= 2;
246	cell = &cell[..cell.len()-1];
247	}
248
249	// only allow '-----' in the remainder
250	if cell.is_empty() \|\| cell.contains(\|c\| c != '-') {
251	return None;
252	}
253
254	result.push(match alignment {
255	0 => ColumnAlignment::None,
256	1 => ColumnAlignment::Left,
257	2 => ColumnAlignment::Right,
258	3 => ColumnAlignment::Center,
259	_ => unreachable!(),
260	});
261	}
262
263	Some(result)
264	}
265
266	fn scan_header(state: &BlockState) -> Option<(Vec<RowContent>, Vec<ColumnAlignment>)> {
267	// should have at least two lines
268	if state.line + 2 > state.line_max { return None; }
269
270	if state.line_indent(state.line) >= state.md.max_indent { return None; }
271
272	let next_line = state.line + 1;
273	if state.line_indent(next_line) < 0 { return None; }
274
275	if state.line_indent(next_line) >= state.md.max_indent { return None; }
276
277	let alignments = Self::scan_alignment_row(state.get_line(next_line))?;
278	let header_row = Self::scan_row(state.get_line(state.line));
279
280	// header row must match the delimiter row in the number of cells
281	if header_row.len() != alignments.len() {
282	return None;
283	}
284
285	// table without any columns is not a table, see markdown-it#724
286	if header_row.is_empty() {
287	return None;
288	}
289
290	Some(( header_row, alignments ))
291	}
292	}
293
294	impl BlockRule for TableScanner {
295	fn check(state: &mut BlockState) -> Option<()> {
296	if state.node.is::<TableBody>() { return None; }
297
298	Self::scan_header(state).map(\|_\| ())
299	}
300
301	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
302	let ( header_row, alignments ) = Self::scan_header(state)?;
303	let table_cell_count = header_row.len();
304	let mut table_node = Node::new(Table { alignments });
305
306	let mut thead_node = Node::new(TableHead);
307	thead_node.srcmap = state.get_map(state.line, state.line + 1);
308
309	let mut row_node = Node::new(TableRow);
310	row_node.srcmap = state.get_map(state.line, state.line);
311
312	fn add_cell(row_node: &mut Node, cell: String, srcmap: Vec<(usize, usize)>) {
313	let mut cell_node = Node::new(TableCell);
314	let (start, _) = row_node.srcmap.unwrap().get_byte_offsets();
315	cell_node.srcmap = Some(SourcePos::new(
316	start + srcmap.first().unwrap().1,
317	start + srcmap.last().unwrap().1 + cell.len() - srcmap.last().unwrap().0,
318	));
319	if !cell.is_empty() {
320	let mapping = srcmap.into_iter().map(\|(dstpos, srcpos)\| (dstpos, srcpos + start)).collect();
321	cell_node.children.push(Node::new(InlineRoot::new(cell, mapping)));
322	}
323	row_node.children.push(cell_node);
324	}
325
326	for RowContent { str: cell, srcmap } in header_row {
327	add_cell(&mut row_node, cell, srcmap);
328	}
329
330	thead_node.children.push(row_node);
331	table_node.children.push(thead_node);
332
333	let tbody_node = Node::new(TableBody);
334	let old_node = std::mem::replace(&mut state.node, tbody_node);
335
336	//
337	// Iterate table rows
338	//
339
340	let start_line = state.line;
341	state.line += 2;
342
343	while state.line < state.line_max {
344	//
345	// Try to check if table is terminated or continued.
346	//
347	if state.line_indent(state.line) < 0 { break; }
348
349	if state.line_indent(state.line) >= state.md.max_indent { break; }
350
351	// stop if the line is empty
352	if state.is_empty(state.line) { break; }
353
354	// fail if terminating block found
355	if state.test_rules_at_line() { break; }
356
357	let mut row_node = Node::new(TableRow);
358	row_node.srcmap = state.get_map(state.line, state.line);
359	let line = state.get_line(state.line);
360
361	let mut body_row = Self::scan_row(line);
362	let mut end_of_line = RowContent { str: String::new(), srcmap: vec![(0, line.len())] };
363
364	for index in 0..table_cell_count {
365	let RowContent { str: cell, srcmap } = body_row.get_mut(index).unwrap_or(&mut end_of_line);
366	add_cell(&mut row_node, cell.clone(), srcmap.clone());
367	}
368
369	state.node.children.push(row_node);
370	state.line += 1;
371	}
372
373	let mut tbody_node = std::mem::replace(&mut state.node, old_node);
374
375	if !tbody_node.children.is_empty() {
376	tbody_node.srcmap = state.get_map(start_line + 2, state.line - 1);
377	table_node.children.push(tbody_node);
378	}
379
380	let line_count = state.line - start_line;
381	state.line = start_line;
382	Some((table_node, line_count))
383	}
384	}
385
386
387	#[cfg(test)]
388	mod tests {
389	use super::TableScanner;
390
391	#[test]
392	fn should_split_cells() {
393	assert_eq!(TableScanner::scan_row("").len(), 0);
394	assert_eq!(TableScanner::scan_row("a").len(), 1);
395	assert_eq!(TableScanner::scan_row("a \| b").len(), 2);
396	assert_eq!(TableScanner::scan_row("a \| b \| c").len(), 3);
397	}
398
399	#[test]
400	fn should_ignore_leading_trailing_empty_cells() {
401	assert_eq!(TableScanner::scan_row("foo \| bar").len(), 2);
402	assert_eq!(TableScanner::scan_row("foo \| bar \|").len(), 2);
403	assert_eq!(TableScanner::scan_row("\| foo \| bar").len(), 2);
404	assert_eq!(TableScanner::scan_row("\| foo \| bar \|").len(), 2);
405	assert_eq!(TableScanner::scan_row("\| \| foo \| bar \| \|").len(), 4);
406	assert_eq!(TableScanner::scan_row("\|").len(), 0);
407	assert_eq!(TableScanner::scan_row("\|\|").len(), 1);
408	}
409
410	#[test]
411	fn should_trim_cell_content() {
412	assert_eq!(TableScanner::scan_row("\|foo\|")[0].str, "foo");
413	assert_eq!(TableScanner::scan_row("\| foo \|")[0].str, "foo");
414	assert_eq!(TableScanner::scan_row("\|\tfoo\t\|")[0].str, "foo");
415	assert_eq!(TableScanner::scan_row("\| \t foo \t \|")[0].str, "foo");
416	}
417
418	#[test]
419	fn should_process_backslash_escapes() {
420	assert_eq!(TableScanner::scan_row(r#"\| foo\bar \|"#)[0].str, r#"foo\bar"#);
421	assert_eq!(TableScanner::scan_row(r#"\| foo\\|bar \|"#)[0].str, r#"foo\|bar"#);
422	assert_eq!(TableScanner::scan_row(r#"\| foo\\\|bar \|"#)[0].str, r#"foo\\|bar"#);
423	assert_eq!(TableScanner::scan_row(r#"\| foo\\\\|bar \|"#)[0].str, r#"foo\\\|bar"#);
424	assert_eq!(TableScanner::scan_row(r#"\| foo\\\\\|bar \|"#)[0].str, r#"foo\\\\|bar"#);
425	}
426
427	#[test]
428	fn should_trim_cell_content_srcmaps() {
429	let row = TableScanner::scan_row("\| foo \| \tbar\t \|");
430	assert_eq!(row[0].str, "foo");
431	assert_eq!(row[0].srcmap, vec![(0, 2)]);
432	assert_eq!(row[1].str, "bar");
433	assert_eq!(row[1].srcmap, vec![(0, 9)]);
434	}
435
436	#[test]
437	fn should_process_backslash_escapes_srcmaps() {
438	let row = TableScanner::scan_row(r#"\| foo\\\|bar\\\\|baz\ \|"#);
439	assert_eq!(row[0].str, r#"foo\\|bar\\\|baz\"#);
440	assert_eq!(row[0].srcmap, vec![(0, 3), (4, 8), (10, 15)]);
441	}
442
443	#[test]
444	fn require_pipe_or_colon_in_align_row() {
445	let md = &mut crate::MarkdownIt::new();
446	crate::plugins::extra::tables::add(md);
447	let html = md.parse("foo\n---\nbar").render();
448	assert_eq!(html.trim(), "foo\n---\nbar");
449	let html = md.parse("\|foo\n---\nbar").render();
450	assert_eq!(html.trim(), "\|foo\n---\nbar");
451	let html = md.parse("foo\n\|---\nbar").render();
452	assert!(html.trim().starts_with("<table"));
453	let html = md.parse("foo\n:---\nbar").render();
454	assert!(html.trim().starts_with("<table"));
455	}
456	}

crates/markdown-it/src/plugins/extra/typographer.rs created+124

...	@@ -0,0 +1,124 @@
1	//! Common textual replacements for dashes, ©, ™, …
2	//!
3	//! Note: Since this plugin is most useful with smart-quotes, which is not
4	//! currently implemented, this plugin is _not_ enabled by default when using
5	//! `plugins::extra::add`. You will have to enable it separately:
6	//!
7	//! ```rust
8	//! let md = &mut markdown_it::MarkdownIt::new();
9	//! markdown_it::plugins::cmark::add(md);
10	//! markdown_it::plugins::extra::add(md);
11	//! markdown_it::plugins::extra::typographer::add(md);
12	//!
13	//! let html = md.parse("Hello world!.... This is the Right Way(TM) to markdown!!!!!").render();
14	//! assert_eq!(html.trim(), r#"<p>Hello world!.. This is the Right Way™ to markdown!!!</p>"#);
15	//! ```
16	//! In summary, these are the replacements that will be made when using this:
17	//!
18	//! ## Typography
19	//!
20	//! - Repeated dots (`...`) to ellipsis (`…`)
21	//! except `?...` and `!...` which become `?..` and `!..` respectively
22	//! - `+-` to `±`
23	//! - Don't repeat `?` and `!` more than 3 times: `???`
24	//! - De-duplicate commas
25	//! - em and en dashes: `--` to `–` and `---` to `—`
26	//!
27	//! ## Common symbols (case insensitive)
28	//!
29	//! - Copyright: `(c)` to `©`
30	//! - Reserved: `(r)` to `®`
31	//! - Trademark: `(tm)` to `™`
32
33	use once_cell::sync::Lazy;
34	use regex::Regex;
35	use std::borrow::Cow;
36
37	use crate::parser::core::CoreRule;
38	use crate::parser::inline::Text;
39	use crate::{MarkdownIt, Node};
40
41	static REPLACEMENTS: Lazy<Box<[(Regex, &'static str)]>> = Lazy::new(\|\| {
42	Box::new([
43	(Regex::new(r"\+-").unwrap(), "±"),
44	(Regex::new(r"\.{2,}").unwrap(), "…"),
45	(Regex::new(r"([?!])…").unwrap(), "$1.."),
46	(Regex::new(r"([?!]){4,}").unwrap(), "$1$1$1"),
47	(Regex::new(r",{2,}").unwrap(), ","),
48	// These look a little different from the JS implementation because the
49	// regex crate doesn't support look-behind and look-ahead patterns
50	(
51	Regex::new(r"(?m)(?P<pre>^\|[^-])(?P<dash>---)(?P<post>[^-]\|$)").unwrap(),
52	"$pre\u{2014}$post",
53	),
54	(
55	Regex::new(r"(?m)(?P<pre>^\|\s)(?P<dash>--)(?P<post>\s\|$)").unwrap(),
56	"$pre\u{2013}$post",
57	),
58	(
59	Regex::new(r"(?m)(?P<pre>^\|[^-\s])(?P<dash>--)(?P<post>[^-\s]\|$)").unwrap(),
60	"$pre\u{2013}$post",
61	),
62	])
63	});
64	static SCOPED_RE: Lazy<Regex> = Lazy::new(\|\| Regex::new(r"(?i)$(c\|tm\|r)$").unwrap());
65	static RARE_RE: Lazy<Regex> = Lazy::new(\|\| Regex::new(r"\+-\|\.\.\|\?\?\?\?\|!!!!\|,,\|--").unwrap());
66
67	fn replace_abbreviation(input: &str) -> &'static str {
68	match input.to_lowercase().as_str() {
69	"(c)" => "©",
70	"(r)" => "®",
71	"(tm)" => "™",
72	_ => unreachable!("Got invalid abbreviation '{}'", input),
73	}
74	}
75
76	pub fn add(md: &mut MarkdownIt) {
77	md.add_rule::<TypographerRule>();
78	}
79
80	pub struct TypographerRule;
81
82	impl CoreRule for TypographerRule {
83	fn run(root: &mut Node, _: &MarkdownIt) {
84	root.walk_mut(\|node, _\| {
85	let Some(text_node) = node.cast_mut::<Text>() else { return; };
86
87	if SCOPED_RE.is_match(&text_node.content) {
88	text_node.content = SCOPED_RE
89	.replace_all(&text_node.content, \|caps: &regex::Captures\| {
90	replace_abbreviation(caps.get(0).unwrap().as_str())
91	})
92	.to_string();
93	}
94	if RARE_RE.is_match(&text_node.content) {
95	let mut result = Cow::Borrowed(text_node.content.as_str());
96
97	for (pattern, replacement) in REPLACEMENTS.iter() {
98	if let Cow::Owned(s) = pattern.replace_all(&result, *replacement) {
99	result = Cow::Owned(s);
100
101	// This is a bit unfortunate but since we can't use
102	// look-ahead and look-behind patterns in the dash
103	// replacements, the preceding and following
104	// characters (pre and post in the patterns) become
105	// part of the match. So a string like "bla-- --foo"
106	// would create two overlapping matches, "a-- "
107	// and " --f". But replace_all only replaces
108	// non-overlapping matches. So we can't do this in
109	// one single replacement. My only consolation here
110	// is that this won't happen very often in practice,
111	// and that it cost us "only" one extra call.
112	if let Cow::Owned(s) = pattern.replace_all(&result, *replacement) {
113	result = Cow::Owned(s);
114	}
115	}
116	}
117
118	if let Cow::Owned(s) = result {
119	text_node.content = s;
120	}
121	}
122	});
123	}
124	}

crates/markdown-it/src/plugins/html/html_block.rs created+151

...	@@ -0,0 +1,151 @@
1	//! HTML block syntax from CommonMark
2	//!
3	//! <https://spec.commonmark.org/0.30/#html-blocks>
4	use once_cell::sync::Lazy;
5	use regex::Regex;
6
7	use super::utils::blocks::*;
8	use super::utils::regexps::*;
9	use crate::parser::block::{BlockRule, BlockState};
10	use crate::{MarkdownIt, Node, NodeValue, Renderer};
11
12	#[derive(Debug)]
13	pub struct HtmlBlock {
14	pub content: String,
15	}
16
17	impl NodeValue for HtmlBlock {
18	fn render(&self, _: &Node, fmt: &mut dyn Renderer) {
19	fmt.cr();
20	fmt.text_raw(&self.content);
21	fmt.cr();
22	}
23	}
24
25	pub fn add(md: &mut MarkdownIt) {
26	md.block.add_rule::<HtmlBlockScanner>();
27	}
28
29	struct HTMLSequence {
30	open: Regex,
31	close: Regex,
32	can_terminate_paragraph: bool,
33	}
34
35	impl HTMLSequence {
36	pub fn new(open: Regex, close: Regex, can_terminate_paragraph: bool) -> Self {
37	Self { open, close, can_terminate_paragraph }
38	}
39	}
40
41	// An array of opening and corresponding closing sequences for html tags,
42	// last argument defines whether it can terminate a paragraph or not
43	//
44	static HTML_SEQUENCES : Lazy<[HTMLSequence; 7]> = Lazy::new(\|\| {
45	let block_names = HTML_BLOCKS.join("\|");
46	let open_close_tag_re = HTML_OPEN_CLOSE_TAG_RE.as_str();
47
48	[
49	HTMLSequence::new(
50	Regex::new(r#"(?i)^<(script\|pre\|style\|textarea)(\s\|>\|$)"#).unwrap(),
51	Regex::new(r#"(?i)</(script\|pre\|style\|textarea)>"#).unwrap(),
52	true
53	),
54
55	HTMLSequence::new(
56	Regex::new(r#"^<!--"#).unwrap(),
57	Regex::new(r#"-->"#).unwrap(),
58	true
59	),
60
61	HTMLSequence::new(
62	Regex::new(r#"^<\?"#).unwrap(),
63	Regex::new(r#"\?>"#).unwrap(),
64	true
65	),
66
67	HTMLSequence::new(
68	Regex::new(r#"^<![A-Z]"#).unwrap(),
69	Regex::new(r#">"#).unwrap(),
70	true
71	),
72
73	HTMLSequence::new(
74	Regex::new(r#"^<!\[CDATA\["#).unwrap(),
75	Regex::new(r#"\]\]>"#).unwrap(),
76	true
77	),
78
79	HTMLSequence::new(
80	Regex::new(&format!("(?i)^</?({block_names})(\\s\|/?>\|$)")).unwrap(),
81	Regex::new(r#"^$"#).unwrap(),
82	true
83	),
84
85	HTMLSequence::new(
86	Regex::new(&format!("{open_close_tag_re}\\s*$")).unwrap(),
87	Regex::new(r#"^$"#).unwrap(),
88	false
89	),
90	]
91	});
92
93	#[doc(hidden)]
94	pub struct HtmlBlockScanner;
95
96	impl HtmlBlockScanner {
97	fn get_sequence(state: &mut BlockState) -> Option<&'static HTMLSequence> {
98
99	if state.line_indent(state.line) >= state.md.max_indent { return None; }
100
101	let line_text = state.get_line(state.line);
102	let Some('<') = line_text.chars().next() else { return None; };
103
104	let mut sequence = None;
105	for seq in HTML_SEQUENCES.iter() {
106	if seq.open.is_match(line_text) {
107	sequence = Some(seq);
108	break;
109	}
110	}
111
112	sequence
113	}
114	}
115
116	impl BlockRule for HtmlBlockScanner {
117	fn check(state: &mut BlockState) -> Option<()> {
118	let sequence = Self::get_sequence(state)?;
119	if !sequence.can_terminate_paragraph { return None; }
120	Some(())
121	}
122
123	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
124	let sequence = Self::get_sequence(state)?;
125
126	let line_text = state.get_line(state.line);
127	let start_line = state.line;
128	let mut next_line = state.line + 1;
129
130	// If we are here - we detected HTML block.
131	// Let's roll down till block end.
132	if !sequence.close.is_match(line_text) {
133	while next_line < state.line_max {
134	if state.line_indent(next_line) < 0 { break; }
135
136	let line_text = state.get_line(next_line);
137
138	if sequence.close.is_match(line_text) {
139	if !line_text.is_empty() { next_line += 1; }
140	break;
141	}
142
143	next_line += 1;
144	}
145	}
146
147	let (content, _) = state.get_lines(start_line, next_line, state.blk_indent, true);
148	let node = Node::new(HtmlBlock { content });
149	Some((node, next_line - state.line))
150	}
151	}

crates/markdown-it/src/plugins/html/html_inline.rs created+50

...	@@ -0,0 +1,50 @@
1	//! HTML inline syntax from CommonMark
2	//!
3	//! <https://spec.commonmark.org/0.30/#raw-html>
4	use super::utils::regexps::*;
5	use crate::parser::inline::{InlineRule, InlineState};
6	use crate::{MarkdownIt, Node, NodeValue, Renderer};
7
8	#[derive(Debug)]
9	pub struct HtmlInline {
10	pub content: String,
11	}
12
13	impl NodeValue for HtmlInline {
14	fn render(&self, _: &Node, fmt: &mut dyn Renderer) {
15	fmt.text_raw(&self.content);
16	}
17	}
18
19	pub fn add(md: &mut MarkdownIt) {
20	md.inline.add_rule::<HtmlInlineScanner>();
21	}
22
23	#[doc(hidden)]
24	pub struct HtmlInlineScanner;
25	impl InlineRule for HtmlInlineScanner {
26	const MARKER: char = '<';
27
28	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
29	// Check start
30	let mut chars = state.src[state.pos..state.pos_max].chars();
31	if chars.next().unwrap() != '<' { return None; }
32
33	// Quick fail on second char
34	let Some('!' \| '?' \| '/' \| 'A'..='Z' \| 'a'..='z') = chars.next() else { return None; };
35
36	let capture = HTML_TAG_RE.captures(&state.src[state.pos..state.pos_max])?.get(0).unwrap().as_str();
37	let capture_len = capture.len();
38
39	let content = capture.to_owned();
40
41	if HTML_LINK_OPEN.is_match(&content) {
42	state.link_level += 1;
43	} else if HTML_LINK_CLOSE.is_match(&content) {
44	state.link_level -= 1;
45	}
46
47	let node = Node::new(HtmlInline { content });
48	Some((node, capture_len))
49	}
50	}

crates/markdown-it/src/plugins/html/mod.rs created+29

...	@@ -0,0 +1,29 @@
1	//! Raw html syntax (block and inline), part of CommonMark standard.
2	//!
3	//! This feature is separated from cmark because it is unsafe to enable by
4	//! default (due to lack of any kind of html sanitization).
5	//!
6	//! You can enable it if you're:
7	//! - looking for strict CommonMark compatibility
8	//! - only have trusted input (i.e. writing markdown yourself)
9	//! - or took some care to sanitize html yourself
10	//!
11	//! ```rust
12	//! let md = &mut markdown_it::MarkdownIt::new();
13	//! markdown_it::plugins::cmark::add(md);
14	//! markdown_it::plugins::html::add(md);
15	//!
16	//! let html = md.parse("hello<br>world").render();
17	//! assert_eq!(html.trim(), r#"<p>hello<br>world</p>"#);
18	//! ```
19
20	pub mod html_block;
21	pub mod html_inline;
22	mod utils;
23
24	use crate::MarkdownIt;
25
26	pub fn add(md: &mut MarkdownIt) {
27	html_inline::add(md);
28	html_block::add(md);
29	}

crates/markdown-it/src/plugins/html/utils/blocks.rs created+68

...	@@ -0,0 +1,68 @@
1	//! List of valid html blocks names, according to commonmark spec
2	//! http://jgm.github.io/CommonMark/spec.html#html-blocks
3	//!
4
5	pub const HTML_BLOCKS: [&str; 62] = [
6	"address",
7	"article",
8	"aside",
9	"base",
10	"basefont",
11	"blockquote",
12	"body",
13	"caption",
14	"center",
15	"col",
16	"colgroup",
17	"dd",
18	"details",
19	"dialog",
20	"dir",
21	"div",
22	"dl",
23	"dt",
24	"fieldset",
25	"figcaption",
26	"figure",
27	"footer",
28	"form",
29	"frame",
30	"frameset",
31	"h1",
32	"h2",
33	"h3",
34	"h4",
35	"h5",
36	"h6",
37	"head",
38	"header",
39	"hr",
40	"html",
41	"iframe",
42	"legend",
43	"li",
44	"link",
45	"main",
46	"menu",
47	"menuitem",
48	"nav",
49	"noframes",
50	"ol",
51	"optgroup",
52	"option",
53	"p",
54	"param",
55	"section",
56	"source",
57	"summary",
58	"table",
59	"tbody",
60	"td",
61	"tfoot",
62	"th",
63	"thead",
64	"title",
65	"tr",
66	"track",
67	"ul",
68	];

crates/markdown-it/src/plugins/html/utils/mod.rs created+2

...	@@ -0,0 +1,2 @@
1	pub mod blocks;
2	pub mod regexps;

crates/markdown-it/src/plugins/html/utils/regexps.rs created+46

...	@@ -0,0 +1,46 @@
1	//! Regexps to match html elements
2	//!
3	#![allow(non_upper_case_globals)]
4	use const_format::formatcp;
5	use once_cell::sync::Lazy;
6	use regex::Regex;
7
8	const attr_name : &str = r#"[a-zA-Z_:][a-zA-Z0-9:._-]*"#;
9
10	const unquoted : &str = r#"[^"'=<>`\x00-\x20]+"#;
11	const single_quoted : &str = r#"'[^']*'"#;
12	const double_quoted : &str = r#""[^"]*""#;
13
14	const attr_value : &str = formatcp!("(?:{unquoted}\|{single_quoted}\|{double_quoted})");
15
16	const attribute : &str = formatcp!("(?:\\s+{attr_name}(?:\\s=\\s{attr_value})?)");
17
18	const open_tag : &str = formatcp!("<[A-Za-z][A-Za-z0-9\\-]{attribute}\\s*/?>");
19
20	const close_tag : &str = r#"</[A-Za-z][A-Za-z0-9\-]\s>"#;
21	const comment : &str = r#"<!---->\|<!--(?:-?[^>-])(?:-?[^-])*-->"#;
22	const processing : &str = r#"<[?][\s\S]*?[?]>"#;
23	const declaration : &str = r#"<![A-Z]+\s+[^>]*>"#;
24	const cdata : &str = r#"<!\[CDATA\[[\s\S]*?\]\]>"#;
25
26	#[allow(clippy::double_parens)]
27	pub static HTML_TAG_RE : Lazy<Regex> = Lazy::new(\|\| {
28	Regex::new(
29	formatcp!("^(?:{open_tag}\|{close_tag}\|{comment}\|{processing}\|{declaration}\|{cdata})")
30	).unwrap()
31	});
32
33	#[allow(clippy::double_parens)]
34	pub static HTML_OPEN_CLOSE_TAG_RE : Lazy<Regex> = Lazy::new(\|\| {
35	Regex::new(
36	formatcp!("^(?:{open_tag}\|{close_tag})")
37	).unwrap()
38	});
39
40	pub static HTML_LINK_OPEN : Lazy<Regex> = Lazy::new(\|\| {
41	Regex::new(r#"^<a[>\s]"#).unwrap()
42	});
43
44	pub static HTML_LINK_CLOSE : Lazy<Regex> = Lazy::new(\|\| {
45	Regex::new(r#"^</a\s*>"#).unwrap()
46	});

crates/markdown-it/src/plugins/mod.rs created+20

...	@@ -0,0 +1,20 @@
1	//! Ready-to-use plugins. Everything, including basic markdown syntax, is a plugin.
2	//!
3	//! This library is made to be as extensible as possible. In order to ensure that
4	//! you can write your own markdown syntax of any arbitrary complexity,
5	//! CommonMark syntax itself is made into a plugin (`cmark`), which you can use
6	//! as an example of how to write your own.
7	//!
8	//! Add each plugin you need by invoking `add` function like this:
9	//! ```rust
10	//! let md = &mut markdown_it::MarkdownIt::new();
11	//! markdown_it::plugins::cmark::add(md);
12	//! markdown_it::plugins::extra::add(md);
13	//! markdown_it::plugins::html::add(md);
14	//! markdown_it::plugins::sourcepos::add(md);
15	//! // ...
16	//! ```
17	pub mod cmark;
18	pub mod extra;
19	pub mod html;
20	pub mod sourcepos;

crates/markdown-it/src/plugins/sourcepos.rs created+52

...	@@ -0,0 +1,52 @@
1	//! Add source mapping to resulting HTML, looks like this: `<stuff data-sourcepos="1:1-2:3">`.
2	//! ```rust
3	//! let md = &mut markdown_it::MarkdownIt::new();
4	//! markdown_it::plugins::cmark::add(md);
5	//! markdown_it::plugins::sourcepos::add(md);
6	//!
7	//! let html = md.parse("# hello").render();
8	//! assert_eq!(html.trim(), r#"<h1 data-sourcepos="1:1-1:7">hello</h1>"#);
9	//! ```
10	use crate::common::sourcemap::SourceWithLineStarts;
11	use crate::parser::block::builtin::BlockParserRule;
12	use crate::parser::core::{CoreRule, Root};
13	use crate::parser::inline::builtin::InlineParserRule;
14	use crate::{MarkdownIt, Node};
15
16	pub fn add(md: &mut MarkdownIt) {
17	md.add_rule::<SyntaxPosRule>()
18	.after::<BlockParserRule>()
19	.after::<InlineParserRule>();
20	}
21
22	#[doc(hidden)]
23	pub struct SyntaxPosRule;
24	impl CoreRule for SyntaxPosRule {
25	fn run(root: &mut Node, _: &MarkdownIt) {
26	let source = root.cast::<Root>().unwrap().content.as_str();
27	let mapping = SourceWithLineStarts::new(source);
28
29	root.walk_mut(\|node, _\| {
30	if let Some(map) = node.srcmap {
31	let ((startline, startcol), (endline, endcol)) = map.get_positions(&mapping);
32	node.attrs.push(("data-sourcepos", format!("{}:{}-{}:{}", startline, startcol, endline, endcol)));
33	}
34	});
35	}
36	}
37
38
39	#[cfg(test)]
40	mod tests {
41	#[test]
42	fn header_test() {
43	// same as doctest, keep in sync!
44	// used for code coverage and quicker rust-analyzer hints
45	let md = &mut crate::MarkdownIt::new();
46	crate::plugins::cmark::add(md);
47	crate::plugins::sourcepos::add(md);
48
49	let html = md.parse("# hello").render();
50	assert_eq!(html.trim(), r#"<h1 data-sourcepos="1:1-1:7">hello</h1>"#);
51	}
52	}

crates/markdown-it/tests/commonmark.rs created+6557

...	@@ -0,0 +1,6557 @@
1
2	fn run(input: &str, output: &str) {
3	let output = if output.is_empty() { "".to_owned() } else { output.to_owned() + "\n" };
4	let md = &mut markdown_it::MarkdownIt::new();
5	markdown_it::plugins::cmark::add(md);
6	markdown_it::plugins::html::add(md);
7	let node = md.parse(&(input.to_owned() + "\n"));
8
9	// make sure we have sourcemaps for everything
10	node.walk(\|node, _\| assert!(node.srcmap.is_some()));
11
12	let result = node.xrender();
13	assert_eq!(result, output);
14
15	// make sure it doesn't crash without trailing \n
16	let _ = md.parse(input.trim_end());
17	}
18
19	///////////////////////////////////////////////////////////////////////////
20	// TESTGEN: fixtures/commonmark/good.txt
21	#[rustfmt::skip]
22	mod fixtures_commonmark_good_txt {
23	use super::run;
24	// this part of the file is auto-generated
25	// don't edit it, otherwise your changes might be lost
26	#[test]
27	fn src_line_355() {
28	let input = "\tfoo\tbaz\t\tbim";
29	let output = "<pre><code>foo\tbaz\t\tbim
30	</code></pre>";
31	run(input, output);
32	}
33
34	#[test]
35	fn src_line_362() {
36	let input = " \tfoo\tbaz\t\tbim";
37	let output = "<pre><code>foo\tbaz\t\tbim
38	</code></pre>";
39	run(input, output);
40	}
41
42	#[test]
43	fn src_line_369() {
44	let input = " a\ta
45	ὐ\ta";
46	let output = "<pre><code>a\ta
47	ὐ\ta
48	</code></pre>";
49	run(input, output);
50	}
51
52	#[test]
53	fn src_line_382() {
54	let input = " - foo
55
56	\tbar";
57	let output = r#"<ul>
58	<li>
59	<p>foo</p>
60	<p>bar</p>
61	</li>
62	</ul>"#;
63	run(input, output);
64	}
65
66	#[test]
67	fn src_line_395() {
68	let input = "- foo
69
70	\t\tbar";
71	let output = r#"<ul>
72	<li>
73	<p>foo</p>
74	<pre><code> bar
75	</code></pre>
76	</li>
77	</ul>"#;
78	run(input, output);
79	}
80
81	#[test]
82	fn src_line_418() {
83	let input = ">\t\tfoo";
84	let output = r#"<blockquote>
85	<pre><code> foo
86	</code></pre>
87	</blockquote>"#;
88	run(input, output);
89	}
90
91	#[test]
92	fn src_line_427() {
93	let input = "-\t\tfoo";
94	let output = r#"<ul>
95	<li>
96	<pre><code> foo
97	</code></pre>
98	</li>
99	</ul>"#;
100	run(input, output);
101	}
102
103	#[test]
104	fn src_line_439() {
105	let input = " foo
106	\tbar";
107	let output = r#"<pre><code>foo
108	bar
109	</code></pre>"#;
110	run(input, output);
111	}
112
113	#[test]
114	fn src_line_448() {
115	let input = " - foo
116	- bar
117	\t - baz";
118	let output = r#"<ul>
119	<li>foo
120	<ul>
121	<li>bar
122	<ul>
123	<li>baz</li>
124	</ul>
125	</li>
126	</ul>
127	</li>
128	</ul>"#;
129	run(input, output);
130	}
131
132	#[test]
133	fn src_line_466() {
134	let input = "#\tFoo";
135	let output = r#"<h1>Foo</h1>"#;
136	run(input, output);
137	}
138
139	#[test]
140	fn src_line_472() {
141	let input = "\t\t*\t";
142	let output = r#"<hr />"#;
143	run(input, output);
144	}
145
146	#[test]
147	fn src_line_489() {
148	let input = r#"\!\"\#\$\%\&\'\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\\|\}\~"#;
149	let output = r#"<p>!"#$%&'()*+,-./:;<=>?@[\]^_`{\|}~</p>"#;
150	run(input, output);
151	}
152
153	#[test]
154	fn src_line_499() {
155	let input = "\\\t\\A\\a\\ \\3\\φ\\«";
156	let output = "<p>\\\t\\A\\a\\ \\3\\φ\\«</p>";
157	run(input, output);
158	}
159
160	#[test]
161	fn src_line_509() {
162	let input = r#"\not emphasized
163	\<br/> not a tag
164	\[not a link](/foo)
165	\`not code`
166	1\. not a list
167	\* not a list
168	\# not a heading
169	\[foo]: /url "not a reference"
170	\ö not a character entity"#;
171	let output = r#"<p>not emphasized
172	<br/> not a tag
173	[not a link](/foo)
174	`not code`
175	1. not a list
176	* not a list
177	# not a heading
178	[foo]: /url "not a reference"
179	&ouml; not a character entity</p>"#;
180	run(input, output);
181	}
182
183	#[test]
184	fn src_line_534() {
185	let input = r#"\\emphasis"#;
186	let output = r#"<p>\<em>emphasis</em></p>"#;
187	run(input, output);
188	}
189
190	#[test]
191	fn src_line_543() {
192	let input = r#"foo\
193	bar"#;
194	let output = r#"<p>foo<br />
195	bar</p>"#;
196	run(input, output);
197	}
198
199	#[test]
200	fn src_line_555() {
201	let input = r#"`` \[\` ``"#;
202	let output = r#"<p><code>\[\`</code></p>"#;
203	run(input, output);
204	}
205
206	#[test]
207	fn src_line_562() {
208	let input = r#" \[\]"#;
209	let output = r#"<pre><code>\[\]
210	</code></pre>"#;
211	run(input, output);
212	}
213
214	#[test]
215	fn src_line_570() {
216	let input = r#"~~~
217	\[\]
218	~~~"#;
219	let output = r#"<pre><code>\[\]
220	</code></pre>"#;
221	run(input, output);
222	}
223
224	#[test]
225	fn src_line_580() {
226	let input = r#"<http://example.com?find=\*>"#;
227	let output = r#"<p><a href="http://example.com?find=%5C">http://example.com?find=\</a></p>"#;
228	run(input, output);
229	}
230
231	#[test]
232	fn src_line_587() {
233	let input = r#"<a href="/bar\/)">"#;
234	let output = r#"<a href="/bar\/)">"#;
235	run(input, output);
236	}
237
238	#[test]
239	fn src_line_597() {
240	let input = r#"[foo](/bar\* "ti\*tle")"#;
241	let output = r#"<p><a href="/bar" title="title">foo</a></p>"#;
242	run(input, output);
243	}
244
245	#[test]
246	fn src_line_604() {
247	let input = r#"[foo]
248
249	[foo]: /bar\* "ti\*tle""#;
250	let output = r#"<p><a href="/bar" title="title">foo</a></p>"#;
251	run(input, output);
252	}
253
254	#[test]
255	fn src_line_613() {
256	let input = r#"``` foo\+bar
257	foo
258	```"#;
259	let output = r#"<pre><code class="language-foo+bar">foo
260	</code></pre>"#;
261	run(input, output);
262	}
263
264	#[test]
265	fn src_line_649() {
266	let input = r#"  & © Æ &Dcaron;
267	¾ &HilbertSpace; &DifferentialD;
268	&ClockwiseContourIntegral; &ngE;"#;
269	let output = r#"<p> & © Æ Ď
270	¾ ℋ ⅆ
271	∲ ≧̸</p>"#;
272	run(input, output);
273	}
274
275	#[test]
276	fn src_line_668() {
277	let input = r#"# Ӓ Ϡ "#;
278	let output = r#"<p># Ӓ Ϡ �</p>"#;
279	run(input, output);
280	}
281
282	#[test]
283	fn src_line_681() {
284	let input = r#"&#X22; &#XD06; ಫ"#;
285	let output = r#"<p>" ആ ಫ</p>"#;
286	run(input, output);
287	}
288
289	#[test]
290	fn src_line_690() {
291	let input = r#"&nbsp &x; &#; &#x;
292	&#87654321;
293	&#abcdef0;
294	&ThisIsNotDefined; &hi?;"#;
295	let output = r#"<p>&nbsp &x; &#; &#x;
296	&#87654321;
297	&#abcdef0;
298	&ThisIsNotDefined; &hi?;</p>"#;
299	run(input, output);
300	}
301
302	#[test]
303	fn src_line_707() {
304	let input = r#"&copy"#;
305	let output = r#"<p>&copy</p>"#;
306	run(input, output);
307	}
308
309	#[test]
310	fn src_line_717() {
311	let input = r#"&MadeUpEntity;"#;
312	let output = r#"<p>&MadeUpEntity;</p>"#;
313	run(input, output);
314	}
315
316	#[test]
317	fn src_line_728() {
318	let input = r#"<a href="öö.html">"#;
319	let output = r#"<a href="öö.html">"#;
320	run(input, output);
321	}
322
323	#[test]
324	fn src_line_735() {
325	let input = r#"[foo](/föö "föö")"#;
326	let output = r#"<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>"#;
327	run(input, output);
328	}
329
330	#[test]
331	fn src_line_742() {
332	let input = r#"[foo]
333
334	[foo]: /föö "föö""#;
335	let output = r#"<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>"#;
336	run(input, output);
337	}
338
339	#[test]
340	fn src_line_751() {
341	let input = r#"``` föö
342	foo
343	```"#;
344	let output = r#"<pre><code class="language-föö">foo
345	</code></pre>"#;
346	run(input, output);
347	}
348
349	#[test]
350	fn src_line_764() {
351	let input = r#"`föö`"#;
352	let output = r#"<p><code>f&ouml;&ouml;</code></p>"#;
353	run(input, output);
354	}
355
356	#[test]
357	fn src_line_771() {
358	let input = r#" föfö"#;
359	let output = r#"<pre><code>f&ouml;f&ouml;
360	</code></pre>"#;
361	run(input, output);
362	}
363
364	#[test]
365	fn src_line_783() {
366	let input = r#"foo
367	foo"#;
368	let output = r#"<p>foo
369	<em>foo</em></p>"#;
370	run(input, output);
371	}
372
373	#[test]
374	fn src_line_791() {
375	let input = r#"* foo
376
377	* foo"#;
378	let output = r#"<p>* foo</p>
379	<ul>
380	<li>foo</li>
381	</ul>"#;
382	run(input, output);
383	}
384
385	#[test]
386	fn src_line_802() {
387	let input = r#"foo bar"#;
388	let output = r#"<p>foo
389
390	bar</p>"#;
391	run(input, output);
392	}
393
394	#[test]
395	fn src_line_810() {
396	let input = r#" foo"#;
397	let output = "<p>\tfoo</p>";
398	run(input, output);
399	}
400
401	#[test]
402	fn src_line_817() {
403	let input = r#"[a](url "tit")"#;
404	let output = r#"<p>[a](url "tit")</p>"#;
405	run(input, output);
406	}
407
408	#[test]
409	fn src_line_840() {
410	let input = r#"- `one
411	- two`"#;
412	let output = r#"<ul>
413	<li>`one</li>
414	<li>two`</li>
415	</ul>"#;
416	run(input, output);
417	}
418
419	#[test]
420	fn src_line_879() {
421	let input = r#"***
422	---
423	___"#;
424	let output = r#"<hr />
425	<hr />
426	<hr />"#;
427	run(input, output);
428	}
429
430	#[test]
431	fn src_line_892() {
432	let input = r#"+++"#;
433	let output = r#"<p>+++</p>"#;
434	run(input, output);
435	}
436
437	#[test]
438	fn src_line_899() {
439	let input = r#"==="#;
440	let output = r#"<p>===</p>"#;
441	run(input, output);
442	}
443
444	#[test]
445	fn src_line_908() {
446	let input = r#"--
447	**
448	__"#;
449	let output = r#"<p>--
450	**
451	__</p>"#;
452	run(input, output);
453	}
454
455	#[test]
456	fn src_line_921() {
457	let input = r#" ***
458	***
459	***"#;
460	let output = r#"<hr />
461	<hr />
462	<hr />"#;
463	run(input, output);
464	}
465
466	#[test]
467	fn src_line_934() {
468	let input = r#" ***"#;
469	let output = r#"<pre><code>***
470	</code></pre>"#;
471	run(input, output);
472	}
473
474	#[test]
475	fn src_line_942() {
476	let input = r#"Foo
477	***"#;
478	let output = r#"<p>Foo
479	***</p>"#;
480	run(input, output);
481	}
482
483	#[test]
484	fn src_line_953() {
485	let input = r#"_____________________________________"#;
486	let output = r#"<hr />"#;
487	run(input, output);
488	}
489
490	#[test]
491	fn src_line_962() {
492	let input = r#" - - -"#;
493	let output = r#"<hr />"#;
494	run(input, output);
495	}
496
497	#[test]
498	fn src_line_969() {
499	let input = r#" ** * ** * ** * **"#;
500	let output = r#"<hr />"#;
501	run(input, output);
502	}
503
504	#[test]
505	fn src_line_976() {
506	let input = r#"- - - -"#;
507	let output = r#"<hr />"#;
508	run(input, output);
509	}
510
511	#[test]
512	fn src_line_985() {
513	let input = "- - - - \x20";
514	let output = r#"<hr />"#;
515	run(input, output);
516	}
517
518	#[test]
519	fn src_line_994() {
520	let input = r#"_ _ _ _ a
521
522	a------
523
524	---a---"#;
525	let output = r#"<p>_ _ _ _ a</p>
526	<p>a------</p>
527	<p>---a---</p>"#;
528	run(input, output);
529	}
530
531	#[test]
532	fn src_line_1010() {
533	let input = r#" -"#;
534	let output = r#"<p><em>-</em></p>"#;
535	run(input, output);
536	}
537
538	#[test]
539	fn src_line_1019() {
540	let input = r#"- foo
541	***
542	- bar"#;
543	let output = r#"<ul>
544	<li>foo</li>
545	</ul>
546	<hr />
547	<ul>
548	<li>bar</li>
549	</ul>"#;
550	run(input, output);
551	}
552
553	#[test]
554	fn src_line_1036() {
555	let input = r#"Foo
556	***
557	bar"#;
558	let output = r#"<p>Foo</p>
559	<hr />
560	<p>bar</p>"#;
561	run(input, output);
562	}
563
564	#[test]
565	fn src_line_1053() {
566	let input = r#"Foo
567	---
568	bar"#;
569	let output = r#"<h2>Foo</h2>
570	<p>bar</p>"#;
571	run(input, output);
572	}
573
574	#[test]
575	fn src_line_1066() {
576	let input = r#"* Foo
577	* * *
578	* Bar"#;
579	let output = r#"<ul>
580	<li>Foo</li>
581	</ul>
582	<hr />
583	<ul>
584	<li>Bar</li>
585	</ul>"#;
586	run(input, output);
587	}
588
589	#[test]
590	fn src_line_1083() {
591	let input = r#"- Foo
592	- * * *"#;
593	let output = r#"<ul>
594	<li>Foo</li>
595	<li>
596	<hr />
597	</li>
598	</ul>"#;
599	run(input, output);
600	}
601
602	#[test]
603	fn src_line_1112() {
604	let input = r#"# foo
605	## foo
606	### foo
607	#### foo
608	##### foo
609	###### foo"#;
610	let output = r#"<h1>foo</h1>
611	<h2>foo</h2>
612	<h3>foo</h3>
613	<h4>foo</h4>
614	<h5>foo</h5>
615	<h6>foo</h6>"#;
616	run(input, output);
617	}
618
619	#[test]
620	fn src_line_1131() {
621	let input = r#"####### foo"#;
622	let output = r#"<p>####### foo</p>"#;
623	run(input, output);
624	}
625
626	#[test]
627	fn src_line_1146() {
628	let input = r#"#5 bolt
629
630	#hashtag"#;
631	let output = r#"<p>#5 bolt</p>
632	<p>#hashtag</p>"#;
633	run(input, output);
634	}
635
636	#[test]
637	fn src_line_1158() {
638	let input = r#"\## foo"#;
639	let output = r#"<p>## foo</p>"#;
640	run(input, output);
641	}
642
643	#[test]
644	fn src_line_1167() {
645	let input = r#"# foo bar \baz\"#;
646	let output = r#"<h1>foo <em>bar</em> baz</h1>"#;
647	run(input, output);
648	}
649
650	#[test]
651	fn src_line_1176() {
652	let input = "# foo \x20";
653	let output = r#"<h1>foo</h1>"#;
654	run(input, output);
655	}
656
657	#[test]
658	fn src_line_1185() {
659	let input = r#" ### foo
660	## foo
661	# foo"#;
662	let output = r#"<h3>foo</h3>
663	<h2>foo</h2>
664	<h1>foo</h1>"#;
665	run(input, output);
666	}
667
668	#[test]
669	fn src_line_1198() {
670	let input = r#" # foo"#;
671	let output = r#"<pre><code># foo
672	</code></pre>"#;
673	run(input, output);
674	}
675
676	#[test]
677	fn src_line_1206() {
678	let input = r#"foo
679	# bar"#;
680	let output = r#"<p>foo
681	# bar</p>"#;
682	run(input, output);
683	}
684
685	#[test]
686	fn src_line_1217() {
687	let input = r#"## foo ##
688	### bar ###"#;
689	let output = r#"<h2>foo</h2>
690	<h3>bar</h3>"#;
691	run(input, output);
692	}
693
694	#[test]
695	fn src_line_1228() {
696	let input = r#"# foo ##################################
697	##### foo ##"#;
698	let output = r#"<h1>foo</h1>
699	<h5>foo</h5>"#;
700	run(input, output);
701	}
702
703	#[test]
704	fn src_line_1239() {
705	let input = "### foo ### \x20";
706	let output = r#"<h3>foo</h3>"#;
707	run(input, output);
708	}
709
710	#[test]
711	fn src_line_1250() {
712	let input = r#"### foo ### b"#;
713	let output = r#"<h3>foo ### b</h3>"#;
714	run(input, output);
715	}
716
717	#[test]
718	fn src_line_1259() {
719	let input = r#"# foo#"#;
720	let output = r#"<h1>foo#</h1>"#;
721	run(input, output);
722	}
723
724	#[test]
725	fn src_line_1269() {
726	let input = r#"### foo \###
727	## foo #\##
728	# foo \#"#;
729	let output = r#"<h3>foo ###</h3>
730	<h2>foo ###</h2>
731	<h1>foo #</h1>"#;
732	run(input, output);
733	}
734
735	#[test]
736	fn src_line_1283() {
737	let input = r#"****
738	## foo
739	****"#;
740	let output = r#"<hr />
741	<h2>foo</h2>
742	<hr />"#;
743	run(input, output);
744	}
745
746	#[test]
747	fn src_line_1294() {
748	let input = r#"Foo bar
749	# baz
750	Bar foo"#;
751	let output = r#"<p>Foo bar</p>
752	<h1>baz</h1>
753	<p>Bar foo</p>"#;
754	run(input, output);
755	}
756
757	#[test]
758	fn src_line_1307() {
759	let input = "##\x20
760	#
761	### ###";
762	let output = r#"<h2></h2>
763	<h1></h1>
764	<h3></h3>"#;
765	run(input, output);
766	}
767
768	#[test]
769	fn src_line_1350() {
770	let input = r#"Foo bar
771	=========
772
773	Foo bar
774	---------"#;
775	let output = r#"<h1>Foo <em>bar</em></h1>
776	<h2>Foo <em>bar</em></h2>"#;
777	run(input, output);
778	}
779
780	#[test]
781	fn src_line_1364() {
782	let input = r#"Foo *bar
783	baz*
784	===="#;
785	let output = r#"<h1>Foo <em>bar
786	baz</em></h1>"#;
787	run(input, output);
788	}
789
790	#[test]
791	fn src_line_1378() {
792	let input = " Foo *bar
793	baz*\t
794	====";
795	let output = r#"<h1>Foo <em>bar
796	baz</em></h1>"#;
797	run(input, output);
798	}
799
800	#[test]
801	fn src_line_1390() {
802	let input = r#"Foo
803	-------------------------
804
805	Foo
806	="#;
807	let output = r#"<h2>Foo</h2>
808	<h1>Foo</h1>"#;
809	run(input, output);
810	}
811
812	#[test]
813	fn src_line_1405() {
814	let input = r#" Foo
815	---
816
817	Foo
818	-----
819
820	Foo
821	==="#;
822	let output = r#"<h2>Foo</h2>
823	<h2>Foo</h2>
824	<h1>Foo</h1>"#;
825	run(input, output);
826	}
827
828	#[test]
829	fn src_line_1423() {
830	let input = r#" Foo
831	---
832
833	Foo
834	---"#;
835	let output = r#"<pre><code>Foo
836	---
837
838	Foo
839	</code></pre>
840	<hr />"#;
841	run(input, output);
842	}
843
844	#[test]
845	fn src_line_1442() {
846	let input = "Foo
847	---- \x20";
848	let output = r#"<h2>Foo</h2>"#;
849	run(input, output);
850	}
851
852	#[test]
853	fn src_line_1452() {
854	let input = r#"Foo
855	---"#;
856	let output = r#"<p>Foo
857	---</p>"#;
858	run(input, output);
859	}
860
861	#[test]
862	fn src_line_1463() {
863	let input = r#"Foo
864	= =
865
866	Foo
867	--- -"#;
868	let output = r#"<p>Foo
869	= =</p>
870	<p>Foo</p>
871	<hr />"#;
872	run(input, output);
873	}
874
875	#[test]
876	fn src_line_1479() {
877	let input = "Foo \x20
878	-----";
879	let output = r#"<h2>Foo</h2>"#;
880	run(input, output);
881	}
882
883	#[test]
884	fn src_line_1489() {
885	let input = r#"Foo\
886	----"#;
887	let output = r#"<h2>Foo\</h2>"#;
888	run(input, output);
889	}
890
891	#[test]
892	fn src_line_1500() {
893	let input = r#"`Foo
894	----
895	`
896
897	<a title="a lot
898	---
899	of dashes"/>"#;
900	let output = r#"<h2>`Foo</h2>
901	<p>`</p>
902	<h2><a title="a lot</h2>
903	<p>of dashes"/></p>"#;
904	run(input, output);
905	}
906
907	#[test]
908	fn src_line_1519() {
909	let input = r#"> Foo
910	---"#;
911	let output = r#"<blockquote>
912	<p>Foo</p>
913	</blockquote>
914	<hr />"#;
915	run(input, output);
916	}
917
918	#[test]
919	fn src_line_1530() {
920	let input = r#"> foo
921	bar
922	==="#;
923	let output = r#"<blockquote>
924	<p>foo
925	bar
926	===</p>
927	</blockquote>"#;
928	run(input, output);
929	}
930
931	#[test]
932	fn src_line_1543() {
933	let input = r#"- Foo
934	---"#;
935	let output = r#"<ul>
936	<li>Foo</li>
937	</ul>
938	<hr />"#;
939	run(input, output);
940	}
941
942	#[test]
943	fn src_line_1558() {
944	let input = r#"Foo
945	Bar
946	---"#;
947	let output = r#"<h2>Foo
948	Bar</h2>"#;
949	run(input, output);
950	}
951
952	#[test]
953	fn src_line_1571() {
954	let input = r#"---
955	Foo
956	---
957	Bar
958	---
959	Baz"#;
960	let output = r#"<hr />
961	<h2>Foo</h2>
962	<h2>Bar</h2>
963	<p>Baz</p>"#;
964	run(input, output);
965	}
966
967	#[test]
968	fn src_line_1588() {
969	let input = r#"
970	===="#;
971	let output = r#"<p>====</p>"#;
972	run(input, output);
973	}
974
975	#[test]
976	fn src_line_1600() {
977	let input = r#"---
978	---"#;
979	let output = r#"<hr />
980	<hr />"#;
981	run(input, output);
982	}
983
984	#[test]
985	fn src_line_1609() {
986	let input = r#"- foo
987	-----"#;
988	let output = r#"<ul>
989	<li>foo</li>
990	</ul>
991	<hr />"#;
992	run(input, output);
993	}
994
995	#[test]
996	fn src_line_1620() {
997	let input = r#" foo
998	---"#;
999	let output = r#"<pre><code>foo
1000	</code></pre>
1001	<hr />"#;
1002	run(input, output);
1003	}
1004
1005	#[test]
1006	fn src_line_1630() {
1007	let input = r#"> foo
1008	-----"#;
1009	let output = r#"<blockquote>
1010	<p>foo</p>
1011	</blockquote>
1012	<hr />"#;
1013	run(input, output);
1014	}
1015
1016	#[test]
1017	fn src_line_1644() {
1018	let input = r#"\> foo
1019	------"#;
1020	let output = r#"<h2>> foo</h2>"#;
1021	run(input, output);
1022	}
1023
1024	#[test]
1025	fn src_line_1675() {
1026	let input = r#"Foo
1027
1028	bar
1029	---
1030	baz"#;
1031	let output = r#"<p>Foo</p>
1032	<h2>bar</h2>
1033	<p>baz</p>"#;
1034	run(input, output);
1035	}
1036
1037	#[test]
1038	fn src_line_1691() {
1039	let input = r#"Foo
1040	bar
1041
1042	---
1043
1044	baz"#;
1045	let output = r#"<p>Foo
1046	bar</p>
1047	<hr />
1048	<p>baz</p>"#;
1049	run(input, output);
1050	}
1051
1052	#[test]
1053	fn src_line_1709() {
1054	let input = r#"Foo
1055	bar
1056	* * *
1057	baz"#;
1058	let output = r#"<p>Foo
1059	bar</p>
1060	<hr />
1061	<p>baz</p>"#;
1062	run(input, output);
1063	}
1064
1065	#[test]
1066	fn src_line_1724() {
1067	let input = r#"Foo
1068	bar
1069	\---
1070	baz"#;
1071	let output = r#"<p>Foo
1072	bar
1073	---
1074	baz</p>"#;
1075	run(input, output);
1076	}
1077
1078	#[test]
1079	fn src_line_1752() {
1080	let input = r#" a simple
1081	indented code block"#;
1082	let output = r#"<pre><code>a simple
1083	indented code block
1084	</code></pre>"#;
1085	run(input, output);
1086	}
1087
1088	#[test]
1089	fn src_line_1766() {
1090	let input = r#" - foo
1091
1092	bar"#;
1093	let output = r#"<ul>
1094	<li>
1095	<p>foo</p>
1096	<p>bar</p>
1097	</li>
1098	</ul>"#;
1099	run(input, output);
1100	}
1101
1102	#[test]
1103	fn src_line_1780() {
1104	let input = r#"1. foo
1105
1106	- bar"#;
1107	let output = r#"<ol>
1108	<li>
1109	<p>foo</p>
1110	<ul>
1111	<li>bar</li>
1112	</ul>
1113	</li>
1114	</ol>"#;
1115	run(input, output);
1116	}
1117
1118	#[test]
1119	fn src_line_1800() {
1120	let input = r#" <a/>
1121	hi
1122
1123	- one"#;
1124	let output = r#"<pre><code><a/>
1125	hi
1126
1127	- one
1128	</code></pre>"#;
1129	run(input, output);
1130	}
1131
1132	#[test]
1133	fn src_line_1816() {
1134	let input = " chunk1
1135
1136	chunk2
1137	\x20
1138	\x20
1139	\x20
1140	chunk3";
1141	let output = r#"<pre><code>chunk1
1142
1143	chunk2
1144
1145
1146
1147	chunk3
1148	</code></pre>"#;
1149	run(input, output);
1150	}
1151
1152	#[test]
1153	fn src_line_1839() {
1154	let input = " chunk1
1155	\x20
1156	chunk2";
1157	let output = "<pre><code>chunk1
1158	\x20
1159	chunk2
1160	</code></pre>";
1161	run(input, output);
1162	}
1163
1164	#[test]
1165	fn src_line_1854() {
1166	let input = r#"Foo
1167	bar
1168	"#;
1169	let output = r#"<p>Foo
1170	bar</p>"#;
1171	run(input, output);
1172	}
1173
1174	#[test]
1175	fn src_line_1868() {
1176	let input = r#" foo
1177	bar"#;
1178	let output = r#"<pre><code>foo
1179	</code></pre>
1180	<p>bar</p>"#;
1181	run(input, output);
1182	}
1183
1184	#[test]
1185	fn src_line_1881() {
1186	let input = r#"# Heading
1187	foo
1188	Heading
1189	------
1190	foo
1191	----"#;
1192	let output = r#"<h1>Heading</h1>
1193	<pre><code>foo
1194	</code></pre>
1195	<h2>Heading</h2>
1196	<pre><code>foo
1197	</code></pre>
1198	<hr />"#;
1199	run(input, output);
1200	}
1201
1202	#[test]
1203	fn src_line_1901() {
1204	let input = r#" foo
1205	bar"#;
1206	let output = r#"<pre><code> foo
1207	bar
1208	</code></pre>"#;
1209	run(input, output);
1210	}
1211
1212	#[test]
1213	fn src_line_1914() {
1214	let input = "
1215	\x20
1216	foo
1217	\x20
1218	";
1219	let output = r#"<pre><code>foo
1220	</code></pre>"#;
1221	run(input, output);
1222	}
1223
1224	#[test]
1225	fn src_line_1928() {
1226	let input = " foo \x20";
1227	let output = "<pre><code>foo \x20
1228	</code></pre>";
1229	run(input, output);
1230	}
1231
1232	#[test]
1233	fn src_line_1983() {
1234	let input = r#"```
1235	<
1236	>
1237	```"#;
1238	let output = r#"<pre><code><
1239	>
1240	</code></pre>"#;
1241	run(input, output);
1242	}
1243
1244	#[test]
1245	fn src_line_1997() {
1246	let input = r#"~~~
1247	<
1248	>
1249	~~~"#;
1250	let output = r#"<pre><code><
1251	>
1252	</code></pre>"#;
1253	run(input, output);
1254	}
1255
1256	#[test]
1257	fn src_line_2010() {
1258	let input = r#"``
1259	foo
1260	``"#;
1261	let output = r#"<p><code>foo</code></p>"#;
1262	run(input, output);
1263	}
1264
1265	#[test]
1266	fn src_line_2021() {
1267	let input = r#"```
1268	aaa
1269	~~~
1270	```"#;
1271	let output = r#"<pre><code>aaa
1272	~~~
1273	</code></pre>"#;
1274	run(input, output);
1275	}
1276
1277	#[test]
1278	fn src_line_2033() {
1279	let input = r#"~~~
1280	aaa
1281	```
1282	~~~"#;
1283	let output = r#"<pre><code>aaa
1284	```
1285	</code></pre>"#;
1286	run(input, output);
1287	}
1288
1289	#[test]
1290	fn src_line_2047() {
1291	let input = r#"````
1292	aaa
1293	```
1294	``````"#;
1295	let output = r#"<pre><code>aaa
1296	```
1297	</code></pre>"#;
1298	run(input, output);
1299	}
1300
1301	#[test]
1302	fn src_line_2059() {
1303	let input = r#"~~~~
1304	aaa
1305	~~~
1306	~~~~"#;
1307	let output = r#"<pre><code>aaa
1308	~~~
1309	</code></pre>"#;
1310	run(input, output);
1311	}
1312
1313	#[test]
1314	fn src_line_2074() {
1315	let input = r#"```"#;
1316	let output = r#"<pre><code></code></pre>"#;
1317	run(input, output);
1318	}
1319
1320	#[test]
1321	fn src_line_2081() {
1322	let input = r#"`````
1323
1324	```
1325	aaa"#;
1326	let output = r#"<pre><code>
1327	```
1328	aaa
1329	</code></pre>"#;
1330	run(input, output);
1331	}
1332
1333	#[test]
1334	fn src_line_2094() {
1335	let input = r#"> ```
1336	> aaa
1337
1338	bbb"#;
1339	let output = r#"<blockquote>
1340	<pre><code>aaa
1341	</code></pre>
1342	</blockquote>
1343	<p>bbb</p>"#;
1344	run(input, output);
1345	}
1346
1347	#[test]
1348	fn src_line_2110() {
1349	let input = "```
1350
1351	\x20
1352	```";
1353	let output = "<pre><code>
1354	\x20
1355	</code></pre>";
1356	run(input, output);
1357	}
1358
1359	#[test]
1360	fn src_line_2124() {
1361	let input = r#"```
1362	```"#;
1363	let output = r#"<pre><code></code></pre>"#;
1364	run(input, output);
1365	}
1366
1367	#[test]
1368	fn src_line_2136() {
1369	let input = r#" ```
1370	aaa
1371	aaa
1372	```"#;
1373	let output = r#"<pre><code>aaa
1374	aaa
1375	</code></pre>"#;
1376	run(input, output);
1377	}
1378
1379	#[test]
1380	fn src_line_2148() {
1381	let input = r#" ```
1382	aaa
1383	aaa
1384	aaa
1385	```"#;
1386	let output = r#"<pre><code>aaa
1387	aaa
1388	aaa
1389	</code></pre>"#;
1390	run(input, output);
1391	}
1392
1393	#[test]
1394	fn src_line_2162() {
1395	let input = r#" ```
1396	aaa
1397	aaa
1398	aaa
1399	```"#;
1400	let output = r#"<pre><code>aaa
1401	aaa
1402	aaa
1403	</code></pre>"#;
1404	run(input, output);
1405	}
1406
1407	#[test]
1408	fn src_line_2178() {
1409	let input = r#" ```
1410	aaa
1411	```"#;
1412	let output = r#"<pre><code>```
1413	aaa
1414	```
1415	</code></pre>"#;
1416	run(input, output);
1417	}
1418
1419	#[test]
1420	fn src_line_2193() {
1421	let input = r#"```
1422	aaa
1423	```"#;
1424	let output = r#"<pre><code>aaa
1425	</code></pre>"#;
1426	run(input, output);
1427	}
1428
1429	#[test]
1430	fn src_line_2203() {
1431	let input = r#" ```
1432	aaa
1433	```"#;
1434	let output = r#"<pre><code>aaa
1435	</code></pre>"#;
1436	run(input, output);
1437	}
1438
1439	#[test]
1440	fn src_line_2215() {
1441	let input = r#"```
1442	aaa
1443	```"#;
1444	let output = r#"<pre><code>aaa
1445	```
1446	</code></pre>"#;
1447	run(input, output);
1448	}
1449
1450	#[test]
1451	fn src_line_2229() {
1452	let input = r#"``` ```
1453	aaa"#;
1454	let output = r#"<p><code> </code>
1455	aaa</p>"#;
1456	run(input, output);
1457	}
1458
1459	#[test]
1460	fn src_line_2238() {
1461	let input = r#"~~~~~~
1462	aaa
1463	~~~ ~~"#;
1464	let output = r#"<pre><code>aaa
1465	~~~ ~~
1466	</code></pre>"#;
1467	run(input, output);
1468	}
1469
1470	#[test]
1471	fn src_line_2252() {
1472	let input = r#"foo
1473	```
1474	bar
1475	```
1476	baz"#;
1477	let output = r#"<p>foo</p>
1478	<pre><code>bar
1479	</code></pre>
1480	<p>baz</p>"#;
1481	run(input, output);
1482	}
1483
1484	#[test]
1485	fn src_line_2269() {
1486	let input = r#"foo
1487	---
1488	~~~
1489	bar
1490	~~~
1491	# baz"#;
1492	let output = r#"<h2>foo</h2>
1493	<pre><code>bar
1494	</code></pre>
1495	<h1>baz</h1>"#;
1496	run(input, output);
1497	}
1498
1499	#[test]
1500	fn src_line_2291() {
1501	let input = r#"```ruby
1502	def foo(x)
1503	return 3
1504	end
1505	```"#;
1506	let output = r#"<pre><code class="language-ruby">def foo(x)
1507	return 3
1508	end
1509	</code></pre>"#;
1510	run(input, output);
1511	}
1512
1513	#[test]
1514	fn src_line_2305() {
1515	let input = r#"~~~~ ruby startline=3 $%@#$
1516	def foo(x)
1517	return 3
1518	end
1519	~~~~~~~"#;
1520	let output = r#"<pre><code class="language-ruby">def foo(x)
1521	return 3
1522	end
1523	</code></pre>"#;
1524	run(input, output);
1525	}
1526
1527	#[test]
1528	fn src_line_2319() {
1529	let input = r#"````;
1530	````"#;
1531	let output = r#"<pre><code class="language-;"></code></pre>"#;
1532	run(input, output);
1533	}
1534
1535	#[test]
1536	fn src_line_2329() {
1537	let input = r#"``` aa ```
1538	foo"#;
1539	let output = r#"<p><code>aa</code>
1540	foo</p>"#;
1541	run(input, output);
1542	}
1543
1544	#[test]
1545	fn src_line_2340() {
1546	let input = r#"~~~ aa ``` ~~~
1547	foo
1548	~~~"#;
1549	let output = r#"<pre><code class="language-aa">foo
1550	</code></pre>"#;
1551	run(input, output);
1552	}
1553
1554	#[test]
1555	fn src_line_2352() {
1556	let input = r#"```
1557	``` aaa
1558	```"#;
1559	let output = r#"<pre><code>``` aaa
1560	</code></pre>"#;
1561	run(input, output);
1562	}
1563
1564	#[test]
1565	fn src_line_2431() {
1566	let input = r#"<table><tr><td>
1567	<pre>
1568	Hello,
1569
1570	_world_.
1571	</pre>
1572	</td></tr></table>"#;
1573	let output = r#"<table><tr><td>
1574	<pre>
1575	Hello,
1576	<p><em>world</em>.
1577	</pre></p>
1578	</td></tr></table>"#;
1579	run(input, output);
1580	}
1581
1582	#[test]
1583	fn src_line_2460() {
1584	let input = r#"<table>
1585	<tr>
1586	<td>
1587	hi
1588	</td>
1589	</tr>
1590	</table>
1591
1592	okay."#;
1593	let output = r#"<table>
1594	<tr>
1595	<td>
1596	hi
1597	</td>
1598	</tr>
1599	</table>
1600	<p>okay.</p>"#;
1601	run(input, output);
1602	}
1603
1604	#[test]
1605	fn src_line_2482() {
1606	let input = r#" <div>
1607	hello
1608	<foo><a>"#;
1609	let output = r#" <div>
1610	hello
1611	<foo><a>"#;
1612	run(input, output);
1613	}
1614
1615	#[test]
1616	fn src_line_2495() {
1617	let input = r#"</div>
1618	foo"#;
1619	let output = r#"</div>
1620	foo"#;
1621	run(input, output);
1622	}
1623
1624	#[test]
1625	fn src_line_2506() {
1626	let input = r#"<DIV CLASS="foo">
1627
1628	Markdown
1629
1630	</DIV>"#;
1631	let output = r#"<DIV CLASS="foo">
1632	<p><em>Markdown</em></p>
1633	</DIV>"#;
1634	run(input, output);
1635	}
1636
1637	#[test]
1638	fn src_line_2522() {
1639	let input = r#"<div id="foo"
1640	class="bar">
1641	</div>"#;
1642	let output = r#"<div id="foo"
1643	class="bar">
1644	</div>"#;
1645	run(input, output);
1646	}
1647
1648	#[test]
1649	fn src_line_2533() {
1650	let input = r#"<div id="foo" class="bar
1651	baz">
1652	</div>"#;
1653	let output = r#"<div id="foo" class="bar
1654	baz">
1655	</div>"#;
1656	run(input, output);
1657	}
1658
1659	#[test]
1660	fn src_line_2545() {
1661	let input = r#"<div>
1662	foo
1663
1664	bar"#;
1665	let output = r#"<div>
1666	foo
1667	<p><em>bar</em></p>"#;
1668	run(input, output);
1669	}
1670
1671	#[test]
1672	fn src_line_2561() {
1673	let input = r#"<div id="foo"
1674	hi"#;
1675	let output = r#"<div id="foo"
1676	hi"#;
1677	run(input, output);
1678	}
1679
1680	#[test]
1681	fn src_line_2570() {
1682	let input = r#"<div class
1683	foo"#;
1684	let output = r#"<div class
1685	foo"#;
1686	run(input, output);
1687	}
1688
1689	#[test]
1690	fn src_line_2582() {
1691	let input = r#"<div *???-&&&-<---
1692	foo"#;
1693	let output = r#"<div *???-&&&-<---
1694	foo"#;
1695	run(input, output);
1696	}
1697
1698	#[test]
1699	fn src_line_2594() {
1700	let input = r#"<div><a href="bar">foo</a></div>"#;
1701	let output = r#"<div><a href="bar">foo</a></div>"#;
1702	run(input, output);
1703	}
1704
1705	#[test]
1706	fn src_line_2601() {
1707	let input = r#"<table><tr><td>
1708	foo
1709	</td></tr></table>"#;
1710	let output = r#"<table><tr><td>
1711	foo
1712	</td></tr></table>"#;
1713	run(input, output);
1714	}
1715
1716	#[test]
1717	fn src_line_2618() {
1718	let input = r#"<div></div>
1719	``` c
1720	int x = 33;
1721	```"#;
1722	let output = r#"<div></div>
1723	``` c
1724	int x = 33;
1725	```"#;
1726	run(input, output);
1727	}
1728
1729	#[test]
1730	fn src_line_2635() {
1731	let input = r#"<a href="foo">
1732	bar
1733	</a>"#;
1734	let output = r#"<a href="foo">
1735	bar
1736	</a>"#;
1737	run(input, output);
1738	}
1739
1740	#[test]
1741	fn src_line_2648() {
1742	let input = r#"<Warning>
1743	bar
1744	</Warning>"#;
1745	let output = r#"<Warning>
1746	bar
1747	</Warning>"#;
1748	run(input, output);
1749	}
1750
1751	#[test]
1752	fn src_line_2659() {
1753	let input = r#"<i class="foo">
1754	bar
1755	</i>"#;
1756	let output = r#"<i class="foo">
1757	bar
1758	</i>"#;
1759	run(input, output);
1760	}
1761
1762	#[test]
1763	fn src_line_2670() {
1764	let input = r#"</ins>
1765	bar"#;
1766	let output = r#"</ins>
1767	bar"#;
1768	run(input, output);
1769	}
1770
1771	#[test]
1772	fn src_line_2685() {
1773	let input = r#"<del>
1774	foo
1775	</del>"#;
1776	let output = r#"<del>
1777	foo
1778	</del>"#;
1779	run(input, output);
1780	}
1781
1782	#[test]
1783	fn src_line_2700() {
1784	let input = r#"<del>
1785
1786	foo
1787
1788	</del>"#;
1789	let output = r#"<del>
1790	<p><em>foo</em></p>
1791	</del>"#;
1792	run(input, output);
1793	}
1794
1795	#[test]
1796	fn src_line_2718() {
1797	let input = r#"<del>foo</del>"#;
1798	let output = r#"<p><del><em>foo</em></del></p>"#;
1799	run(input, output);
1800	}
1801
1802	#[test]
1803	fn src_line_2734() {
1804	let input = r#"<pre language="haskell"><code>
1805	import Text.HTML.TagSoup
1806
1807	main :: IO ()
1808	main = print $ parseTags tags
1809	</code></pre>
1810	okay"#;
1811	let output = r#"<pre language="haskell"><code>
1812	import Text.HTML.TagSoup
1813
1814	main :: IO ()
1815	main = print $ parseTags tags
1816	</code></pre>
1817	<p>okay</p>"#;
1818	run(input, output);
1819	}
1820
1821	#[test]
1822	fn src_line_2755() {
1823	let input = r#"<script type="text/javascript">
1824	// JavaScript example
1825
1826	document.getElementById("demo").innerHTML = "Hello JavaScript!";
1827	</script>
1828	okay"#;
1829	let output = r#"<script type="text/javascript">
1830	// JavaScript example
1831
1832	document.getElementById("demo").innerHTML = "Hello JavaScript!";
1833	</script>
1834	<p>okay</p>"#;
1835	run(input, output);
1836	}
1837
1838	#[test]
1839	fn src_line_2774() {
1840	let input = r#"<textarea>
1841
1842	foo
1843
1844	_bar_
1845
1846	</textarea>"#;
1847	let output = r#"<textarea>
1848
1849	foo
1850
1851	_bar_
1852
1853	</textarea>"#;
1854	run(input, output);
1855	}
1856
1857	#[test]
1858	fn src_line_2794() {
1859	let input = r#"<style
1860	type="text/css">
1861	h1 {color:red;}
1862
1863	p {color:blue;}
1864	</style>
1865	okay"#;
1866	let output = r#"<style
1867	type="text/css">
1868	h1 {color:red;}
1869
1870	p {color:blue;}
1871	</style>
1872	<p>okay</p>"#;
1873	run(input, output);
1874	}
1875
1876	#[test]
1877	fn src_line_2817() {
1878	let input = r#"<style
1879	type="text/css">
1880
1881	foo"#;
1882	let output = r#"<style
1883	type="text/css">
1884
1885	foo"#;
1886	run(input, output);
1887	}
1888
1889	#[test]
1890	fn src_line_2830() {
1891	let input = r#"> <div>
1892	> foo
1893
1894	bar"#;
1895	let output = r#"<blockquote>
1896	<div>
1897	foo
1898	</blockquote>
1899	<p>bar</p>"#;
1900	run(input, output);
1901	}
1902
1903	#[test]
1904	fn src_line_2844() {
1905	let input = r#"- <div>
1906	- foo"#;
1907	let output = r#"<ul>
1908	<li>
1909	<div>
1910	</li>
1911	<li>foo</li>
1912	</ul>"#;
1913	run(input, output);
1914	}
1915
1916	#[test]
1917	fn src_line_2859() {
1918	let input = r#"<style>p{color:red;}</style>
1919	foo"#;
1920	let output = r#"<style>p{color:red;}</style>
1921	<p><em>foo</em></p>"#;
1922	run(input, output);
1923	}
1924
1925	#[test]
1926	fn src_line_2868() {
1927	let input = r#"<!-- foo -->bar
1928	baz"#;
1929	let output = r#"<!-- foo -->bar
1930	<p><em>baz</em></p>"#;
1931	run(input, output);
1932	}
1933
1934	#[test]
1935	fn src_line_2880() {
1936	let input = r#"<script>
1937	foo
1938	</script>1. bar"#;
1939	let output = r#"<script>
1940	foo
1941	</script>1. bar"#;
1942	run(input, output);
1943	}
1944
1945	#[test]
1946	fn src_line_2893() {
1947	let input = r#"<!-- Foo
1948
1949	bar
1950	baz -->
1951	okay"#;
1952	let output = r#"<!-- Foo
1953
1954	bar
1955	baz -->
1956	<p>okay</p>"#;
1957	run(input, output);
1958	}
1959
1960	#[test]
1961	fn src_line_2911() {
1962	let input = r#"<?php
1963
1964	echo '>';
1965
1966	?>
1967	okay"#;
1968	let output = r#"<?php
1969
1970	echo '>';
1971
1972	?>
1973	<p>okay</p>"#;
1974	run(input, output);
1975	}
1976
1977	#[test]
1978	fn src_line_2930() {
1979	let input = r#"<!DOCTYPE html>"#;
1980	let output = r#"<!DOCTYPE html>"#;
1981	run(input, output);
1982	}
1983
1984	#[test]
1985	fn src_line_2939() {
1986	let input = r#"<![CDATA[
1987	function matchwo(a,b)
1988	{
1989	if (a < b && a < 0) then {
1990	return 1;
1991
1992	} else {
1993
1994	return 0;
1995	}
1996	}
1997	]]>
1998	okay"#;
1999	let output = r#"<![CDATA[
2000	function matchwo(a,b)
2001	{
2002	if (a < b && a < 0) then {
2003	return 1;
2004
2005	} else {
2006
2007	return 0;
2008	}
2009	}
2010	]]>
2011	<p>okay</p>"#;
2012	run(input, output);
2013	}
2014
2015	#[test]
2016	fn src_line_2973() {
2017	let input = r#" <!-- foo -->
2018
2019	<!-- foo -->"#;
2020	let output = r#" <!-- foo -->
2021	<pre><code><!-- foo -->
2022	</code></pre>"#;
2023	run(input, output);
2024	}
2025
2026	#[test]
2027	fn src_line_2984() {
2028	let input = r#" <div>
2029
2030	<div>"#;
2031	let output = r#" <div>
2032	<pre><code><div>
2033	</code></pre>"#;
2034	run(input, output);
2035	}
2036
2037	#[test]
2038	fn src_line_2998() {
2039	let input = r#"Foo
2040	<div>
2041	bar
2042	</div>"#;
2043	let output = r#"<p>Foo</p>
2044	<div>
2045	bar
2046	</div>"#;
2047	run(input, output);
2048	}
2049
2050	#[test]
2051	fn src_line_3015() {
2052	let input = r#"<div>
2053	bar
2054	</div>
2055	foo"#;
2056	let output = r#"<div>
2057	bar
2058	</div>
2059	foo"#;
2060	run(input, output);
2061	}
2062
2063	#[test]
2064	fn src_line_3030() {
2065	let input = r#"Foo
2066	<a href="bar">
2067	baz"#;
2068	let output = r#"<p>Foo
2069	<a href="bar">
2070	baz</p>"#;
2071	run(input, output);
2072	}
2073
2074	#[test]
2075	fn src_line_3071() {
2076	let input = r#"<div>
2077
2078	Emphasized text.
2079
2080	</div>"#;
2081	let output = r#"<div>
2082	<p><em>Emphasized</em> text.</p>
2083	</div>"#;
2084	run(input, output);
2085	}
2086
2087	#[test]
2088	fn src_line_3084() {
2089	let input = r#"<div>
2090	Emphasized text.
2091	</div>"#;
2092	let output = r#"<div>
2093	Emphasized text.
2094	</div>"#;
2095	run(input, output);
2096	}
2097
2098	#[test]
2099	fn src_line_3106() {
2100	let input = r#"<table>
2101
2102	<tr>
2103
2104	<td>
2105	Hi
2106	</td>
2107
2108	</tr>
2109
2110	</table>"#;
2111	let output = r#"<table>
2112	<tr>
2113	<td>
2114	Hi
2115	</td>
2116	</tr>
2117	</table>"#;
2118	run(input, output);
2119	}
2120
2121	#[test]
2122	fn src_line_3133() {
2123	let input = r#"<table>
2124
2125	<tr>
2126
2127	<td>
2128	Hi
2129	</td>
2130
2131	</tr>
2132
2133	</table>"#;
2134	let output = r#"<table>
2135	<tr>
2136	<pre><code><td>
2137	Hi
2138	</td>
2139	</code></pre>
2140	</tr>
2141	</table>"#;
2142	run(input, output);
2143	}
2144
2145	#[test]
2146	fn src_line_3182() {
2147	let input = r#"[foo]: /url "title"
2148
2149	[foo]"#;
2150	let output = r#"<p><a href="/url" title="title">foo</a></p>"#;
2151	run(input, output);
2152	}
2153
2154	#[test]
2155	fn src_line_3191() {
2156	let input = " [foo]:\x20
2157	/url \x20
2158	'the title' \x20
2159
2160	[foo]";
2161	let output = r#"<p><a href="/url" title="the title">foo</a></p>"#;
2162	run(input, output);
2163	}
2164
2165	#[test]
2166	fn src_line_3202() {
2167	let input = r#"[Foo*bar\]]:my_(url) 'title (with parens)'
2168
2169	[Foo*bar\]]"#;
2170	let output = r#"<p><a href="my_(url)" title="title (with parens)">Foo*bar]</a></p>"#;
2171	run(input, output);
2172	}
2173
2174	#[test]
2175	fn src_line_3211() {
2176	let input = r#"[Foo bar]:
2177	<my url>
2178	'title'
2179
2180	[Foo bar]"#;
2181	let output = r#"<p><a href="my%20url" title="title">Foo bar</a></p>"#;
2182	run(input, output);
2183	}
2184
2185	#[test]
2186	fn src_line_3224() {
2187	let input = r#"[foo]: /url '
2188	title
2189	line1
2190	line2
2191	'
2192
2193	[foo]"#;
2194	let output = r#"<p><a href="/url" title="
2195	title
2196	line1
2197	line2
2198	">foo</a></p>"#;
2199	run(input, output);
2200	}
2201
2202	#[test]
2203	fn src_line_3243() {
2204	let input = r#"[foo]: /url 'title
2205
2206	with blank line'
2207
2208	[foo]"#;
2209	let output = r#"<p>[foo]: /url 'title</p>
2210	<p>with blank line'</p>
2211	<p>[foo]</p>"#;
2212	run(input, output);
2213	}
2214
2215	#[test]
2216	fn src_line_3258() {
2217	let input = r#"[foo]:
2218	/url
2219
2220	[foo]"#;
2221	let output = r#"<p><a href="/url">foo</a></p>"#;
2222	run(input, output);
2223	}
2224
2225	#[test]
2226	fn src_line_3270() {
2227	let input = r#"[foo]:
2228
2229	[foo]"#;
2230	let output = r#"<p>[foo]:</p>
2231	<p>[foo]</p>"#;
2232	run(input, output);
2233	}
2234
2235	#[test]
2236	fn src_line_3282() {
2237	let input = r#"[foo]: <>
2238
2239	[foo]"#;
2240	let output = r#"<p><a href="">foo</a></p>"#;
2241	run(input, output);
2242	}
2243
2244	#[test]
2245	fn src_line_3293() {
2246	let input = r#"[foo]: <bar>(baz)
2247
2248	[foo]"#;
2249	let output = r#"<p>[foo]: <bar>(baz)</p>
2250	<p>[foo]</p>"#;
2251	run(input, output);
2252	}
2253
2254	#[test]
2255	fn src_line_3306() {
2256	let input = r#"[foo]: /url\bar\*baz "foo\"bar\baz"
2257
2258	[foo]"#;
2259	let output = r#"<p><a href="/url%5Cbar*baz" title="foo"bar\baz">foo</a></p>"#;
2260	run(input, output);
2261	}
2262
2263	#[test]
2264	fn src_line_3317() {
2265	let input = r#"[foo]
2266
2267	[foo]: url"#;
2268	let output = r#"<p><a href="url">foo</a></p>"#;
2269	run(input, output);
2270	}
2271
2272	#[test]
2273	fn src_line_3329() {
2274	let input = r#"[foo]
2275
2276	[foo]: first
2277	[foo]: second"#;
2278	let output = r#"<p><a href="first">foo</a></p>"#;
2279	run(input, output);
2280	}
2281
2282	#[test]
2283	fn src_line_3342() {
2284	let input = r#"[FOO]: /url
2285
2286	[Foo]"#;
2287	let output = r#"<p><a href="/url">Foo</a></p>"#;
2288	run(input, output);
2289	}
2290
2291	#[test]
2292	fn src_line_3351() {
2293	let input = r#"[ΑΓΩ]: /φου
2294
2295	[αγω]"#;
2296	let output = r#"<p><a href="/%CF%86%CE%BF%CF%85">αγω</a></p>"#;
2297	run(input, output);
2298	}
2299
2300	#[test]
2301	fn src_line_3366() {
2302	let input = r#"[foo]: /url"#;
2303	let output = r#""#;
2304	run(input, output);
2305	}
2306
2307	#[test]
2308	fn src_line_3374() {
2309	let input = r#"[
2310	foo
2311	]: /url
2312	bar"#;
2313	let output = r#"<p>bar</p>"#;
2314	run(input, output);
2315	}
2316
2317	#[test]
2318	fn src_line_3387() {
2319	let input = r#"[foo]: /url "title" ok"#;
2320	let output = r#"<p>[foo]: /url "title" ok</p>"#;
2321	run(input, output);
2322	}
2323
2324	#[test]
2325	fn src_line_3396() {
2326	let input = r#"[foo]: /url
2327	"title" ok"#;
2328	let output = r#"<p>"title" ok</p>"#;
2329	run(input, output);
2330	}
2331
2332	#[test]
2333	fn src_line_3407() {
2334	let input = r#" [foo]: /url "title"
2335
2336	[foo]"#;
2337	let output = r#"<pre><code>[foo]: /url "title"
2338	</code></pre>
2339	<p>[foo]</p>"#;
2340	run(input, output);
2341	}
2342
2343	#[test]
2344	fn src_line_3421() {
2345	let input = r#"```
2346	[foo]: /url
2347	```
2348
2349	[foo]"#;
2350	let output = r#"<pre><code>[foo]: /url
2351	</code></pre>
2352	<p>[foo]</p>"#;
2353	run(input, output);
2354	}
2355
2356	#[test]
2357	fn src_line_3436() {
2358	let input = r#"Foo
2359	[bar]: /baz
2360
2361	[bar]"#;
2362	let output = r#"<p>Foo
2363	[bar]: /baz</p>
2364	<p>[bar]</p>"#;
2365	run(input, output);
2366	}
2367
2368	#[test]
2369	fn src_line_3451() {
2370	let input = r#"# [Foo]
2371	[foo]: /url
2372	> bar"#;
2373	let output = r#"<h1><a href="/url">Foo</a></h1>
2374	<blockquote>
2375	<p>bar</p>
2376	</blockquote>"#;
2377	run(input, output);
2378	}
2379
2380	#[test]
2381	fn src_line_3462() {
2382	let input = r#"[foo]: /url
2383	bar
2384	===
2385	[foo]"#;
2386	let output = r#"<h1>bar</h1>
2387	<p><a href="/url">foo</a></p>"#;
2388	run(input, output);
2389	}
2390
2391	#[test]
2392	fn src_line_3472() {
2393	let input = r#"[foo]: /url
2394	===
2395	[foo]"#;
2396	let output = r#"<p>===
2397	<a href="/url">foo</a></p>"#;
2398	run(input, output);
2399	}
2400
2401	#[test]
2402	fn src_line_3485() {
2403	let input = r#"[foo]: /foo-url "foo"
2404	[bar]: /bar-url
2405	"bar"
2406	[baz]: /baz-url
2407
2408	[foo],
2409	[bar],
2410	[baz]"#;
2411	let output = r#"<p><a href="/foo-url" title="foo">foo</a>,
2412	<a href="/bar-url" title="bar">bar</a>,
2413	<a href="/baz-url">baz</a></p>"#;
2414	run(input, output);
2415	}
2416
2417	#[test]
2418	fn src_line_3506() {
2419	let input = r#"[foo]
2420
2421	> [foo]: /url"#;
2422	let output = r#"<p><a href="/url">foo</a></p>
2423	<blockquote>
2424	</blockquote>"#;
2425	run(input, output);
2426	}
2427
2428	#[test]
2429	fn src_line_3528() {
2430	let input = r#"aaa
2431
2432	bbb"#;
2433	let output = r#"<p>aaa</p>
2434	<p>bbb</p>"#;
2435	run(input, output);
2436	}
2437
2438	#[test]
2439	fn src_line_3540() {
2440	let input = r#"aaa
2441	bbb
2442
2443	ccc
2444	ddd"#;
2445	let output = r#"<p>aaa
2446	bbb</p>
2447	<p>ccc
2448	ddd</p>"#;
2449	run(input, output);
2450	}
2451
2452	#[test]
2453	fn src_line_3556() {
2454	let input = r#"aaa
2455
2456
2457	bbb"#;
2458	let output = r#"<p>aaa</p>
2459	<p>bbb</p>"#;
2460	run(input, output);
2461	}
2462
2463	#[test]
2464	fn src_line_3569() {
2465	let input = r#" aaa
2466	bbb"#;
2467	let output = r#"<p>aaa
2468	bbb</p>"#;
2469	run(input, output);
2470	}
2471
2472	#[test]
2473	fn src_line_3581() {
2474	let input = r#"aaa
2475	bbb
2476	ccc"#;
2477	let output = r#"<p>aaa
2478	bbb
2479	ccc</p>"#;
2480	run(input, output);
2481	}
2482
2483	#[test]
2484	fn src_line_3595() {
2485	let input = r#" aaa
2486	bbb"#;
2487	let output = r#"<p>aaa
2488	bbb</p>"#;
2489	run(input, output);
2490	}
2491
2492	#[test]
2493	fn src_line_3604() {
2494	let input = r#" aaa
2495	bbb"#;
2496	let output = r#"<pre><code>aaa
2497	</code></pre>
2498	<p>bbb</p>"#;
2499	run(input, output);
2500	}
2501
2502	#[test]
2503	fn src_line_3618() {
2504	let input = "aaa \x20
2505	bbb \x20";
2506	let output = r#"<p>aaa<br />
2507	bbb</p>"#;
2508	run(input, output);
2509	}
2510
2511	#[test]
2512	fn src_line_3635() {
2513	let input = " \x20
2514
2515	aaa
2516	\x20
2517
2518	# aaa
2519
2520	\x20";
2521	let output = r#"<p>aaa</p>
2522	<h1>aaa</h1>"#;
2523	run(input, output);
2524	}
2525
2526	#[test]
2527	fn src_line_3703() {
2528	let input = r#"> # Foo
2529	> bar
2530	> baz"#;
2531	let output = r#"<blockquote>
2532	<h1>Foo</h1>
2533	<p>bar
2534	baz</p>
2535	</blockquote>"#;
2536	run(input, output);
2537	}
2538
2539	#[test]
2540	fn src_line_3718() {
2541	let input = r#"># Foo
2542	>bar
2543	> baz"#;
2544	let output = r#"<blockquote>
2545	<h1>Foo</h1>
2546	<p>bar
2547	baz</p>
2548	</blockquote>"#;
2549	run(input, output);
2550	}
2551
2552	#[test]
2553	fn src_line_3733() {
2554	let input = r#" > # Foo
2555	> bar
2556	> baz"#;
2557	let output = r#"<blockquote>
2558	<h1>Foo</h1>
2559	<p>bar
2560	baz</p>
2561	</blockquote>"#;
2562	run(input, output);
2563	}
2564
2565	#[test]
2566	fn src_line_3748() {
2567	let input = r#" > # Foo
2568	> bar
2569	> baz"#;
2570	let output = r#"<pre><code>> # Foo
2571	> bar
2572	> baz
2573	</code></pre>"#;
2574	run(input, output);
2575	}
2576
2577	#[test]
2578	fn src_line_3763() {
2579	let input = r#"> # Foo
2580	> bar
2581	baz"#;
2582	let output = r#"<blockquote>
2583	<h1>Foo</h1>
2584	<p>bar
2585	baz</p>
2586	</blockquote>"#;
2587	run(input, output);
2588	}
2589
2590	#[test]
2591	fn src_line_3779() {
2592	let input = r#"> bar
2593	baz
2594	> foo"#;
2595	let output = r#"<blockquote>
2596	<p>bar
2597	baz
2598	foo</p>
2599	</blockquote>"#;
2600	run(input, output);
2601	}
2602
2603	#[test]
2604	fn src_line_3803() {
2605	let input = r#"> foo
2606	---"#;
2607	let output = r#"<blockquote>
2608	<p>foo</p>
2609	</blockquote>
2610	<hr />"#;
2611	run(input, output);
2612	}
2613
2614	#[test]
2615	fn src_line_3823() {
2616	let input = r#"> - foo
2617	- bar"#;
2618	let output = r#"<blockquote>
2619	<ul>
2620	<li>foo</li>
2621	</ul>
2622	</blockquote>
2623	<ul>
2624	<li>bar</li>
2625	</ul>"#;
2626	run(input, output);
2627	}
2628
2629	#[test]
2630	fn src_line_3841() {
2631	let input = r#"> foo
2632	bar"#;
2633	let output = r#"<blockquote>
2634	<pre><code>foo
2635	</code></pre>
2636	</blockquote>
2637	<pre><code>bar
2638	</code></pre>"#;
2639	run(input, output);
2640	}
2641
2642	#[test]
2643	fn src_line_3854() {
2644	let input = r#"> ```
2645	foo
2646	```"#;
2647	let output = r#"<blockquote>
2648	<pre><code></code></pre>
2649	</blockquote>
2650	<p>foo</p>
2651	<pre><code></code></pre>"#;
2652	run(input, output);
2653	}
2654
2655	#[test]
2656	fn src_line_3870() {
2657	let input = r#"> foo
2658	- bar"#;
2659	let output = r#"<blockquote>
2660	<p>foo
2661	- bar</p>
2662	</blockquote>"#;
2663	run(input, output);
2664	}
2665
2666	#[test]
2667	fn src_line_3894() {
2668	let input = r#">"#;
2669	let output = r#"<blockquote>
2670	</blockquote>"#;
2671	run(input, output);
2672	}
2673
2674	#[test]
2675	fn src_line_3902() {
2676	let input = ">
2677	> \x20
2678	>\x20";
2679	let output = r#"<blockquote>
2680	</blockquote>"#;
2681	run(input, output);
2682	}
2683
2684	#[test]
2685	fn src_line_3914() {
2686	let input = ">
2687	> foo
2688	> \x20";
2689	let output = r#"<blockquote>
2690	<p>foo</p>
2691	</blockquote>"#;
2692	run(input, output);
2693	}
2694
2695	#[test]
2696	fn src_line_3927() {
2697	let input = r#"> foo
2698
2699	> bar"#;
2700	let output = r#"<blockquote>
2701	<p>foo</p>
2702	</blockquote>
2703	<blockquote>
2704	<p>bar</p>
2705	</blockquote>"#;
2706	run(input, output);
2707	}
2708
2709	#[test]
2710	fn src_line_3949() {
2711	let input = r#"> foo
2712	> bar"#;
2713	let output = r#"<blockquote>
2714	<p>foo
2715	bar</p>
2716	</blockquote>"#;
2717	run(input, output);
2718	}
2719
2720	#[test]
2721	fn src_line_3962() {
2722	let input = r#"> foo
2723	>
2724	> bar"#;
2725	let output = r#"<blockquote>
2726	<p>foo</p>
2727	<p>bar</p>
2728	</blockquote>"#;
2729	run(input, output);
2730	}
2731
2732	#[test]
2733	fn src_line_3976() {
2734	let input = r#"foo
2735	> bar"#;
2736	let output = r#"<p>foo</p>
2737	<blockquote>
2738	<p>bar</p>
2739	</blockquote>"#;
2740	run(input, output);
2741	}
2742
2743	#[test]
2744	fn src_line_3990() {
2745	let input = r#"> aaa
2746	***
2747	> bbb"#;
2748	let output = r#"<blockquote>
2749	<p>aaa</p>
2750	</blockquote>
2751	<hr />
2752	<blockquote>
2753	<p>bbb</p>
2754	</blockquote>"#;
2755	run(input, output);
2756	}
2757
2758	#[test]
2759	fn src_line_4008() {
2760	let input = r#"> bar
2761	baz"#;
2762	let output = r#"<blockquote>
2763	<p>bar
2764	baz</p>
2765	</blockquote>"#;
2766	run(input, output);
2767	}
2768
2769	#[test]
2770	fn src_line_4019() {
2771	let input = r#"> bar
2772
2773	baz"#;
2774	let output = r#"<blockquote>
2775	<p>bar</p>
2776	</blockquote>
2777	<p>baz</p>"#;
2778	run(input, output);
2779	}
2780
2781	#[test]
2782	fn src_line_4031() {
2783	let input = r#"> bar
2784	>
2785	baz"#;
2786	let output = r#"<blockquote>
2787	<p>bar</p>
2788	</blockquote>
2789	<p>baz</p>"#;
2790	run(input, output);
2791	}
2792
2793	#[test]
2794	fn src_line_4047() {
2795	let input = r#"> > > foo
2796	bar"#;
2797	let output = r#"<blockquote>
2798	<blockquote>
2799	<blockquote>
2800	<p>foo
2801	bar</p>
2802	</blockquote>
2803	</blockquote>
2804	</blockquote>"#;
2805	run(input, output);
2806	}
2807
2808	#[test]
2809	fn src_line_4062() {
2810	let input = r#">>> foo
2811	> bar
2812	>>baz"#;
2813	let output = r#"<blockquote>
2814	<blockquote>
2815	<blockquote>
2816	<p>foo
2817	bar
2818	baz</p>
2819	</blockquote>
2820	</blockquote>
2821	</blockquote>"#;
2822	run(input, output);
2823	}
2824
2825	#[test]
2826	fn src_line_4084() {
2827	let input = r#"> code
2828
2829	> not code"#;
2830	let output = r#"<blockquote>
2831	<pre><code>code
2832	</code></pre>
2833	</blockquote>
2834	<blockquote>
2835	<p>not code</p>
2836	</blockquote>"#;
2837	run(input, output);
2838	}
2839
2840	#[test]
2841	fn src_line_4138() {
2842	let input = r#"A paragraph
2843	with two lines.
2844
2845	indented code
2846
2847	> A block quote."#;
2848	let output = r#"<p>A paragraph
2849	with two lines.</p>
2850	<pre><code>indented code
2851	</code></pre>
2852	<blockquote>
2853	<p>A block quote.</p>
2854	</blockquote>"#;
2855	run(input, output);
2856	}
2857
2858	#[test]
2859	fn src_line_4160() {
2860	let input = r#"1. A paragraph
2861	with two lines.
2862
2863	indented code
2864
2865	> A block quote."#;
2866	let output = r#"<ol>
2867	<li>
2868	<p>A paragraph
2869	with two lines.</p>
2870	<pre><code>indented code
2871	</code></pre>
2872	<blockquote>
2873	<p>A block quote.</p>
2874	</blockquote>
2875	</li>
2876	</ol>"#;
2877	run(input, output);
2878	}
2879
2880	#[test]
2881	fn src_line_4193() {
2882	let input = r#"- one
2883
2884	two"#;
2885	let output = r#"<ul>
2886	<li>one</li>
2887	</ul>
2888	<p>two</p>"#;
2889	run(input, output);
2890	}
2891
2892	#[test]
2893	fn src_line_4205() {
2894	let input = r#"- one
2895
2896	two"#;
2897	let output = r#"<ul>
2898	<li>
2899	<p>one</p>
2900	<p>two</p>
2901	</li>
2902	</ul>"#;
2903	run(input, output);
2904	}
2905
2906	#[test]
2907	fn src_line_4219() {
2908	let input = r#" - one
2909
2910	two"#;
2911	let output = r#"<ul>
2912	<li>one</li>
2913	</ul>
2914	<pre><code> two
2915	</code></pre>"#;
2916	run(input, output);
2917	}
2918
2919	#[test]
2920	fn src_line_4232() {
2921	let input = r#" - one
2922
2923	two"#;
2924	let output = r#"<ul>
2925	<li>
2926	<p>one</p>
2927	<p>two</p>
2928	</li>
2929	</ul>"#;
2930	run(input, output);
2931	}
2932
2933	#[test]
2934	fn src_line_4254() {
2935	let input = r#" > > 1. one
2936	>>
2937	>> two"#;
2938	let output = r#"<blockquote>
2939	<blockquote>
2940	<ol>
2941	<li>
2942	<p>one</p>
2943	<p>two</p>
2944	</li>
2945	</ol>
2946	</blockquote>
2947	</blockquote>"#;
2948	run(input, output);
2949	}
2950
2951	#[test]
2952	fn src_line_4281() {
2953	let input = r#">>- one
2954	>>
2955	> > two"#;
2956	let output = r#"<blockquote>
2957	<blockquote>
2958	<ul>
2959	<li>one</li>
2960	</ul>
2961	<p>two</p>
2962	</blockquote>
2963	</blockquote>"#;
2964	run(input, output);
2965	}
2966
2967	#[test]
2968	fn src_line_4300() {
2969	let input = r#"-one
2970
2971	2.two"#;
2972	let output = r#"<p>-one</p>
2973	<p>2.two</p>"#;
2974	run(input, output);
2975	}
2976
2977	#[test]
2978	fn src_line_4313() {
2979	let input = r#"- foo
2980
2981
2982	bar"#;
2983	let output = r#"<ul>
2984	<li>
2985	<p>foo</p>
2986	<p>bar</p>
2987	</li>
2988	</ul>"#;
2989	run(input, output);
2990	}
2991
2992	#[test]
2993	fn src_line_4330() {
2994	let input = r#"1. foo
2995
2996	```
2997	bar
2998	```
2999
3000	baz
3001
3002	> bam"#;
3003	let output = r#"<ol>
3004	<li>
3005	<p>foo</p>
3006	<pre><code>bar
3007	</code></pre>
3008	<p>baz</p>
3009	<blockquote>
3010	<p>bam</p>
3011	</blockquote>
3012	</li>
3013	</ol>"#;
3014	run(input, output);
3015	}
3016
3017	#[test]
3018	fn src_line_4358() {
3019	let input = r#"- Foo
3020
3021	bar
3022
3023
3024	baz"#;
3025	let output = r#"<ul>
3026	<li>
3027	<p>Foo</p>
3028	<pre><code>bar
3029
3030
3031	baz
3032	</code></pre>
3033	</li>
3034	</ul>"#;
3035	run(input, output);
3036	}
3037
3038	#[test]
3039	fn src_line_4380() {
3040	let input = r#"123456789. ok"#;
3041	let output = r#"<ol start="123456789">
3042	<li>ok</li>
3043	</ol>"#;
3044	run(input, output);
3045	}
3046
3047	#[test]
3048	fn src_line_4389() {
3049	let input = r#"1234567890. not ok"#;
3050	let output = r#"<p>1234567890. not ok</p>"#;
3051	run(input, output);
3052	}
3053
3054	#[test]
3055	fn src_line_4398() {
3056	let input = r#"0. ok"#;
3057	let output = r#"<ol start="0">
3058	<li>ok</li>
3059	</ol>"#;
3060	run(input, output);
3061	}
3062
3063	#[test]
3064	fn src_line_4407() {
3065	let input = r#"003. ok"#;
3066	let output = r#"<ol start="3">
3067	<li>ok</li>
3068	</ol>"#;
3069	run(input, output);
3070	}
3071
3072	#[test]
3073	fn src_line_4418() {
3074	let input = r#"-1. not ok"#;
3075	let output = r#"<p>-1. not ok</p>"#;
3076	run(input, output);
3077	}
3078
3079	#[test]
3080	fn src_line_4441() {
3081	let input = r#"- foo
3082
3083	bar"#;
3084	let output = r#"<ul>
3085	<li>
3086	<p>foo</p>
3087	<pre><code>bar
3088	</code></pre>
3089	</li>
3090	</ul>"#;
3091	run(input, output);
3092	}
3093
3094	#[test]
3095	fn src_line_4458() {
3096	let input = r#" 10. foo
3097
3098	bar"#;
3099	let output = r#"<ol start="10">
3100	<li>
3101	<p>foo</p>
3102	<pre><code>bar
3103	</code></pre>
3104	</li>
3105	</ol>"#;
3106	run(input, output);
3107	}
3108
3109	#[test]
3110	fn src_line_4477() {
3111	let input = r#" indented code
3112
3113	paragraph
3114
3115	more code"#;
3116	let output = r#"<pre><code>indented code
3117	</code></pre>
3118	<p>paragraph</p>
3119	<pre><code>more code
3120	</code></pre>"#;
3121	run(input, output);
3122	}
3123
3124	#[test]
3125	fn src_line_4492() {
3126	let input = r#"1. indented code
3127
3128	paragraph
3129
3130	more code"#;
3131	let output = r#"<ol>
3132	<li>
3133	<pre><code>indented code
3134	</code></pre>
3135	<p>paragraph</p>
3136	<pre><code>more code
3137	</code></pre>
3138	</li>
3139	</ol>"#;
3140	run(input, output);
3141	}
3142
3143	#[test]
3144	fn src_line_4514() {
3145	let input = r#"1. indented code
3146
3147	paragraph
3148
3149	more code"#;
3150	let output = r#"<ol>
3151	<li>
3152	<pre><code> indented code
3153	</code></pre>
3154	<p>paragraph</p>
3155	<pre><code>more code
3156	</code></pre>
3157	</li>
3158	</ol>"#;
3159	run(input, output);
3160	}
3161
3162	#[test]
3163	fn src_line_4541() {
3164	let input = r#" foo
3165
3166	bar"#;
3167	let output = r#"<p>foo</p>
3168	<p>bar</p>"#;
3169	run(input, output);
3170	}
3171
3172	#[test]
3173	fn src_line_4551() {
3174	let input = r#"- foo
3175
3176	bar"#;
3177	let output = r#"<ul>
3178	<li>foo</li>
3179	</ul>
3180	<p>bar</p>"#;
3181	run(input, output);
3182	}
3183
3184	#[test]
3185	fn src_line_4568() {
3186	let input = r#"- foo
3187
3188	bar"#;
3189	let output = r#"<ul>
3190	<li>
3191	<p>foo</p>
3192	<p>bar</p>
3193	</li>
3194	</ul>"#;
3195	run(input, output);
3196	}
3197
3198	#[test]
3199	fn src_line_4595() {
3200	let input = r#"-
3201	foo
3202	-
3203	```
3204	bar
3205	```
3206	-
3207	baz"#;
3208	let output = r#"<ul>
3209	<li>foo</li>
3210	<li>
3211	<pre><code>bar
3212	</code></pre>
3213	</li>
3214	<li>
3215	<pre><code>baz
3216	</code></pre>
3217	</li>
3218	</ul>"#;
3219	run(input, output);
3220	}
3221
3222	#[test]
3223	fn src_line_4621() {
3224	let input = "- \x20
3225	foo";
3226	let output = r#"<ul>
3227	<li>foo</li>
3228	</ul>"#;
3229	run(input, output);
3230	}
3231
3232	#[test]
3233	fn src_line_4635() {
3234	let input = r#"-
3235
3236	foo"#;
3237	let output = r#"<ul>
3238	<li></li>
3239	</ul>
3240	<p>foo</p>"#;
3241	run(input, output);
3242	}
3243
3244	#[test]
3245	fn src_line_4649() {
3246	let input = r#"- foo
3247	-
3248	- bar"#;
3249	let output = r#"<ul>
3250	<li>foo</li>
3251	<li></li>
3252	<li>bar</li>
3253	</ul>"#;
3254	run(input, output);
3255	}
3256
3257	#[test]
3258	fn src_line_4664() {
3259	let input = "- foo
3260	- \x20
3261	- bar";
3262	let output = r#"<ul>
3263	<li>foo</li>
3264	<li></li>
3265	<li>bar</li>
3266	</ul>"#;
3267	run(input, output);
3268	}
3269
3270	#[test]
3271	fn src_line_4679() {
3272	let input = r#"1. foo
3273	2.
3274	3. bar"#;
3275	let output = r#"<ol>
3276	<li>foo</li>
3277	<li></li>
3278	<li>bar</li>
3279	</ol>"#;
3280	run(input, output);
3281	}
3282
3283	#[test]
3284	fn src_line_4694() {
3285	let input = r#"*"#;
3286	let output = r#"<ul>
3287	<li></li>
3288	</ul>"#;
3289	run(input, output);
3290	}
3291
3292	#[test]
3293	fn src_line_4704() {
3294	let input = r#"foo
3295	*
3296
3297	foo
3298	1."#;
3299	let output = r#"<p>foo
3300	*</p>
3301	<p>foo
3302	1.</p>"#;
3303	run(input, output);
3304	}
3305
3306	#[test]
3307	fn src_line_4726() {
3308	let input = r#" 1. A paragraph
3309	with two lines.
3310
3311	indented code
3312
3313	> A block quote."#;
3314	let output = r#"<ol>
3315	<li>
3316	<p>A paragraph
3317	with two lines.</p>
3318	<pre><code>indented code
3319	</code></pre>
3320	<blockquote>
3321	<p>A block quote.</p>
3322	</blockquote>
3323	</li>
3324	</ol>"#;
3325	run(input, output);
3326	}
3327
3328	#[test]
3329	fn src_line_4750() {
3330	let input = r#" 1. A paragraph
3331	with two lines.
3332
3333	indented code
3334
3335	> A block quote."#;
3336	let output = r#"<ol>
3337	<li>
3338	<p>A paragraph
3339	with two lines.</p>
3340	<pre><code>indented code
3341	</code></pre>
3342	<blockquote>
3343	<p>A block quote.</p>
3344	</blockquote>
3345	</li>
3346	</ol>"#;
3347	run(input, output);
3348	}
3349
3350	#[test]
3351	fn src_line_4774() {
3352	let input = r#" 1. A paragraph
3353	with two lines.
3354
3355	indented code
3356
3357	> A block quote."#;
3358	let output = r#"<ol>
3359	<li>
3360	<p>A paragraph
3361	with two lines.</p>
3362	<pre><code>indented code
3363	</code></pre>
3364	<blockquote>
3365	<p>A block quote.</p>
3366	</blockquote>
3367	</li>
3368	</ol>"#;
3369	run(input, output);
3370	}
3371
3372	#[test]
3373	fn src_line_4798() {
3374	let input = r#" 1. A paragraph
3375	with two lines.
3376
3377	indented code
3378
3379	> A block quote."#;
3380	let output = r#"<pre><code>1. A paragraph
3381	with two lines.
3382
3383	indented code
3384
3385	> A block quote.
3386	</code></pre>"#;
3387	run(input, output);
3388	}
3389
3390	#[test]
3391	fn src_line_4828() {
3392	let input = r#" 1. A paragraph
3393	with two lines.
3394
3395	indented code
3396
3397	> A block quote."#;
3398	let output = r#"<ol>
3399	<li>
3400	<p>A paragraph
3401	with two lines.</p>
3402	<pre><code>indented code
3403	</code></pre>
3404	<blockquote>
3405	<p>A block quote.</p>
3406	</blockquote>
3407	</li>
3408	</ol>"#;
3409	run(input, output);
3410	}
3411
3412	#[test]
3413	fn src_line_4852() {
3414	let input = r#" 1. A paragraph
3415	with two lines."#;
3416	let output = r#"<ol>
3417	<li>A paragraph
3418	with two lines.</li>
3419	</ol>"#;
3420	run(input, output);
3421	}
3422
3423	#[test]
3424	fn src_line_4865() {
3425	let input = r#"> 1. > Blockquote
3426	continued here."#;
3427	let output = r#"<blockquote>
3428	<ol>
3429	<li>
3430	<blockquote>
3431	<p>Blockquote
3432	continued here.</p>
3433	</blockquote>
3434	</li>
3435	</ol>
3436	</blockquote>"#;
3437	run(input, output);
3438	}
3439
3440	#[test]
3441	fn src_line_4882() {
3442	let input = r#"> 1. > Blockquote
3443	> continued here."#;
3444	let output = r#"<blockquote>
3445	<ol>
3446	<li>
3447	<blockquote>
3448	<p>Blockquote
3449	continued here.</p>
3450	</blockquote>
3451	</li>
3452	</ol>
3453	</blockquote>"#;
3454	run(input, output);
3455	}
3456
3457	#[test]
3458	fn src_line_4910() {
3459	let input = r#"- foo
3460	- bar
3461	- baz
3462	- boo"#;
3463	let output = r#"<ul>
3464	<li>foo
3465	<ul>
3466	<li>bar
3467	<ul>
3468	<li>baz
3469	<ul>
3470	<li>boo</li>
3471	</ul>
3472	</li>
3473	</ul>
3474	</li>
3475	</ul>
3476	</li>
3477	</ul>"#;
3478	run(input, output);
3479	}
3480
3481	#[test]
3482	fn src_line_4936() {
3483	let input = r#"- foo
3484	- bar
3485	- baz
3486	- boo"#;
3487	let output = r#"<ul>
3488	<li>foo</li>
3489	<li>bar</li>
3490	<li>baz</li>
3491	<li>boo</li>
3492	</ul>"#;
3493	run(input, output);
3494	}
3495
3496	#[test]
3497	fn src_line_4953() {
3498	let input = r#"10) foo
3499	- bar"#;
3500	let output = r#"<ol start="10">
3501	<li>foo
3502	<ul>
3503	<li>bar</li>
3504	</ul>
3505	</li>
3506	</ol>"#;
3507	run(input, output);
3508	}
3509
3510	#[test]
3511	fn src_line_4969() {
3512	let input = r#"10) foo
3513	- bar"#;
3514	let output = r#"<ol start="10">
3515	<li>foo</li>
3516	</ol>
3517	<ul>
3518	<li>bar</li>
3519	</ul>"#;
3520	run(input, output);
3521	}
3522
3523	#[test]
3524	fn src_line_4984() {
3525	let input = r#"- - foo"#;
3526	let output = r#"<ul>
3527	<li>
3528	<ul>
3529	<li>foo</li>
3530	</ul>
3531	</li>
3532	</ul>"#;
3533	run(input, output);
3534	}
3535
3536	#[test]
3537	fn src_line_4997() {
3538	let input = r#"1. - 2. foo"#;
3539	let output = r#"<ol>
3540	<li>
3541	<ul>
3542	<li>
3543	<ol start="2">
3544	<li>foo</li>
3545	</ol>
3546	</li>
3547	</ul>
3548	</li>
3549	</ol>"#;
3550	run(input, output);
3551	}
3552
3553	#[test]
3554	fn src_line_5016() {
3555	let input = r#"- # Foo
3556	- Bar
3557	---
3558	baz"#;
3559	let output = r#"<ul>
3560	<li>
3561	<h1>Foo</h1>
3562	</li>
3563	<li>
3564	<h2>Bar</h2>
3565	baz</li>
3566	</ul>"#;
3567	run(input, output);
3568	}
3569
3570	#[test]
3571	fn src_line_5252() {
3572	let input = r#"- foo
3573	- bar
3574	+ baz"#;
3575	let output = r#"<ul>
3576	<li>foo</li>
3577	<li>bar</li>
3578	</ul>
3579	<ul>
3580	<li>baz</li>
3581	</ul>"#;
3582	run(input, output);
3583	}
3584
3585	#[test]
3586	fn src_line_5267() {
3587	let input = r#"1. foo
3588	2. bar
3589	3) baz"#;
3590	let output = r#"<ol>
3591	<li>foo</li>
3592	<li>bar</li>
3593	</ol>
3594	<ol start="3">
3595	<li>baz</li>
3596	</ol>"#;
3597	run(input, output);
3598	}
3599
3600	#[test]
3601	fn src_line_5286() {
3602	let input = r#"Foo
3603	- bar
3604	- baz"#;
3605	let output = r#"<p>Foo</p>
3606	<ul>
3607	<li>bar</li>
3608	<li>baz</li>
3609	</ul>"#;
3610	run(input, output);
3611	}
3612
3613	#[test]
3614	fn src_line_5363() {
3615	let input = r#"The number of windows in my house is
3616	14. The number of doors is 6."#;
3617	let output = r#"<p>The number of windows in my house is
3618	14. The number of doors is 6.</p>"#;
3619	run(input, output);
3620	}
3621
3622	#[test]
3623	fn src_line_5373() {
3624	let input = r#"The number of windows in my house is
3625	1. The number of doors is 6."#;
3626	let output = r#"<p>The number of windows in my house is</p>
3627	<ol>
3628	<li>The number of doors is 6.</li>
3629	</ol>"#;
3630	run(input, output);
3631	}
3632
3633	#[test]
3634	fn src_line_5387() {
3635	let input = r#"- foo
3636
3637	- bar
3638
3639
3640	- baz"#;
3641	let output = r#"<ul>
3642	<li>
3643	<p>foo</p>
3644	</li>
3645	<li>
3646	<p>bar</p>
3647	</li>
3648	<li>
3649	<p>baz</p>
3650	</li>
3651	</ul>"#;
3652	run(input, output);
3653	}
3654
3655	#[test]
3656	fn src_line_5408() {
3657	let input = r#"- foo
3658	- bar
3659	- baz
3660
3661
3662	bim"#;
3663	let output = r#"<ul>
3664	<li>foo
3665	<ul>
3666	<li>bar
3667	<ul>
3668	<li>
3669	<p>baz</p>
3670	<p>bim</p>
3671	</li>
3672	</ul>
3673	</li>
3674	</ul>
3675	</li>
3676	</ul>"#;
3677	run(input, output);
3678	}
3679
3680	#[test]
3681	fn src_line_5438() {
3682	let input = r#"- foo
3683	- bar
3684
3685	<!-- -->
3686
3687	- baz
3688	- bim"#;
3689	let output = r#"<ul>
3690	<li>foo</li>
3691	<li>bar</li>
3692	</ul>
3693	<!-- -->
3694	<ul>
3695	<li>baz</li>
3696	<li>bim</li>
3697	</ul>"#;
3698	run(input, output);
3699	}
3700
3701	#[test]
3702	fn src_line_5459() {
3703	let input = r#"- foo
3704
3705	notcode
3706
3707	- foo
3708
3709	<!-- -->
3710
3711	code"#;
3712	let output = r#"<ul>
3713	<li>
3714	<p>foo</p>
3715	<p>notcode</p>
3716	</li>
3717	<li>
3718	<p>foo</p>
3719	</li>
3720	</ul>
3721	<!-- -->
3722	<pre><code>code
3723	</code></pre>"#;
3724	run(input, output);
3725	}
3726
3727	#[test]
3728	fn src_line_5490() {
3729	let input = r#"- a
3730	- b
3731	- c
3732	- d
3733	- e
3734	- f
3735	- g"#;
3736	let output = r#"<ul>
3737	<li>a</li>
3738	<li>b</li>
3739	<li>c</li>
3740	<li>d</li>
3741	<li>e</li>
3742	<li>f</li>
3743	<li>g</li>
3744	</ul>"#;
3745	run(input, output);
3746	}
3747
3748	#[test]
3749	fn src_line_5511() {
3750	let input = r#"1. a
3751
3752	2. b
3753
3754	3. c"#;
3755	let output = r#"<ol>
3756	<li>
3757	<p>a</p>
3758	</li>
3759	<li>
3760	<p>b</p>
3761	</li>
3762	<li>
3763	<p>c</p>
3764	</li>
3765	</ol>"#;
3766	run(input, output);
3767	}
3768
3769	#[test]
3770	fn src_line_5535() {
3771	let input = r#"- a
3772	- b
3773	- c
3774	- d
3775	- e"#;
3776	let output = r#"<ul>
3777	<li>a</li>
3778	<li>b</li>
3779	<li>c</li>
3780	<li>d
3781	- e</li>
3782	</ul>"#;
3783	run(input, output);
3784	}
3785
3786	#[test]
3787	fn src_line_5555() {
3788	let input = r#"1. a
3789
3790	2. b
3791
3792	3. c"#;
3793	let output = r#"<ol>
3794	<li>
3795	<p>a</p>
3796	</li>
3797	<li>
3798	<p>b</p>
3799	</li>
3800	</ol>
3801	<pre><code>3. c
3802	</code></pre>"#;
3803	run(input, output);
3804	}
3805
3806	#[test]
3807	fn src_line_5578() {
3808	let input = r#"- a
3809	- b
3810
3811	- c"#;
3812	let output = r#"<ul>
3813	<li>
3814	<p>a</p>
3815	</li>
3816	<li>
3817	<p>b</p>
3818	</li>
3819	<li>
3820	<p>c</p>
3821	</li>
3822	</ul>"#;
3823	run(input, output);
3824	}
3825
3826	#[test]
3827	fn src_line_5600() {
3828	let input = r#"* a
3829	*
3830
3831	* c"#;
3832	let output = r#"<ul>
3833	<li>
3834	<p>a</p>
3835	</li>
3836	<li></li>
3837	<li>
3838	<p>c</p>
3839	</li>
3840	</ul>"#;
3841	run(input, output);
3842	}
3843
3844	#[test]
3845	fn src_line_5622() {
3846	let input = r#"- a
3847	- b
3848
3849	c
3850	- d"#;
3851	let output = r#"<ul>
3852	<li>
3853	<p>a</p>
3854	</li>
3855	<li>
3856	<p>b</p>
3857	<p>c</p>
3858	</li>
3859	<li>
3860	<p>d</p>
3861	</li>
3862	</ul>"#;
3863	run(input, output);
3864	}
3865
3866	#[test]
3867	fn src_line_5644() {
3868	let input = r#"- a
3869	- b
3870
3871	[ref]: /url
3872	- d"#;
3873	let output = r#"<ul>
3874	<li>
3875	<p>a</p>
3876	</li>
3877	<li>
3878	<p>b</p>
3879	</li>
3880	<li>
3881	<p>d</p>
3882	</li>
3883	</ul>"#;
3884	run(input, output);
3885	}
3886
3887	#[test]
3888	fn src_line_5667() {
3889	let input = r#"- a
3890	- ```
3891	b
3892
3893
3894	```
3895	- c"#;
3896	let output = r#"<ul>
3897	<li>a</li>
3898	<li>
3899	<pre><code>b
3900
3901
3902	</code></pre>
3903	</li>
3904	<li>c</li>
3905	</ul>"#;
3906	run(input, output);
3907	}
3908
3909	#[test]
3910	fn src_line_5693() {
3911	let input = r#"- a
3912	- b
3913
3914	c
3915	- d"#;
3916	let output = r#"<ul>
3917	<li>a
3918	<ul>
3919	<li>
3920	<p>b</p>
3921	<p>c</p>
3922	</li>
3923	</ul>
3924	</li>
3925	<li>d</li>
3926	</ul>"#;
3927	run(input, output);
3928	}
3929
3930	#[test]
3931	fn src_line_5717() {
3932	let input = r#"* a
3933	> b
3934	>
3935	* c"#;
3936	let output = r#"<ul>
3937	<li>a
3938	<blockquote>
3939	<p>b</p>
3940	</blockquote>
3941	</li>
3942	<li>c</li>
3943	</ul>"#;
3944	run(input, output);
3945	}
3946
3947	#[test]
3948	fn src_line_5737() {
3949	let input = r#"- a
3950	> b
3951	```
3952	c
3953	```
3954	- d"#;
3955	let output = r#"<ul>
3956	<li>a
3957	<blockquote>
3958	<p>b</p>
3959	</blockquote>
3960	<pre><code>c
3961	</code></pre>
3962	</li>
3963	<li>d</li>
3964	</ul>"#;
3965	run(input, output);
3966	}
3967
3968	#[test]
3969	fn src_line_5760() {
3970	let input = r#"- a"#;
3971	let output = r#"<ul>
3972	<li>a</li>
3973	</ul>"#;
3974	run(input, output);
3975	}
3976
3977	#[test]
3978	fn src_line_5769() {
3979	let input = r#"- a
3980	- b"#;
3981	let output = r#"<ul>
3982	<li>a
3983	<ul>
3984	<li>b</li>
3985	</ul>
3986	</li>
3987	</ul>"#;
3988	run(input, output);
3989	}
3990
3991	#[test]
3992	fn src_line_5786() {
3993	let input = r#"1. ```
3994	foo
3995	```
3996
3997	bar"#;
3998	let output = r#"<ol>
3999	<li>
4000	<pre><code>foo
4001	</code></pre>
4002	<p>bar</p>
4003	</li>
4004	</ol>"#;
4005	run(input, output);
4006	}
4007
4008	#[test]
4009	fn src_line_5805() {
4010	let input = r#"* foo
4011	* bar
4012
4013	baz"#;
4014	let output = r#"<ul>
4015	<li>
4016	<p>foo</p>
4017	<ul>
4018	<li>bar</li>
4019	</ul>
4020	<p>baz</p>
4021	</li>
4022	</ul>"#;
4023	run(input, output);
4024	}
4025
4026	#[test]
4027	fn src_line_5823() {
4028	let input = r#"- a
4029	- b
4030	- c
4031
4032	- d
4033	- e
4034	- f"#;
4035	let output = r#"<ul>
4036	<li>
4037	<p>a</p>
4038	<ul>
4039	<li>b</li>
4040	<li>c</li>
4041	</ul>
4042	</li>
4043	<li>
4044	<p>d</p>
4045	<ul>
4046	<li>e</li>
4047	<li>f</li>
4048	</ul>
4049	</li>
4050	</ul>"#;
4051	run(input, output);
4052	}
4053
4054	#[test]
4055	fn src_line_5857() {
4056	let input = r#"`hi`lo`"#;
4057	let output = r#"<p><code>hi</code>lo`</p>"#;
4058	run(input, output);
4059	}
4060
4061	#[test]
4062	fn src_line_5889() {
4063	let input = r#"`foo`"#;
4064	let output = r#"<p><code>foo</code></p>"#;
4065	run(input, output);
4066	}
4067
4068	#[test]
4069	fn src_line_5900() {
4070	let input = r#"`` foo ` bar ``"#;
4071	let output = r#"<p><code>foo ` bar</code></p>"#;
4072	run(input, output);
4073	}
4074
4075	#[test]
4076	fn src_line_5910() {
4077	let input = r#"` `` `"#;
4078	let output = r#"<p><code>``</code></p>"#;
4079	run(input, output);
4080	}
4081
4082	#[test]
4083	fn src_line_5918() {
4084	let input = r#"` `` `"#;
4085	let output = r#"<p><code> `` </code></p>"#;
4086	run(input, output);
4087	}
4088
4089	#[test]
4090	fn src_line_5927() {
4091	let input = r#"` a`"#;
4092	let output = r#"<p><code> a</code></p>"#;
4093	run(input, output);
4094	}
4095
4096	#[test]
4097	fn src_line_5936() {
4098	let input = r#"` b `"#;
4099	let output = r#"<p><code> b </code></p>"#;
4100	run(input, output);
4101	}
4102
4103	#[test]
4104	fn src_line_5944() {
4105	let input = r#"` `
4106	` `"#;
4107	let output = r#"<p><code> </code>
4108	<code> </code></p>"#;
4109	run(input, output);
4110	}
4111
4112	#[test]
4113	fn src_line_5955() {
4114	let input = "``
4115	foo
4116	bar \x20
4117	baz
4118	``";
4119	let output = r#"<p><code>foo bar baz</code></p>"#;
4120	run(input, output);
4121	}
4122
4123	#[test]
4124	fn src_line_5965() {
4125	let input = "``
4126	foo\x20
4127	``";
4128	let output = r#"<p><code>foo </code></p>"#;
4129	run(input, output);
4130	}
4131
4132	#[test]
4133	fn src_line_5976() {
4134	let input = "`foo bar\x20
4135	baz`";
4136	let output = r#"<p><code>foo bar baz</code></p>"#;
4137	run(input, output);
4138	}
4139
4140	#[test]
4141	fn src_line_5993() {
4142	let input = r#"`foo\`bar`"#;
4143	let output = r#"<p><code>foo\</code>bar`</p>"#;
4144	run(input, output);
4145	}
4146
4147	#[test]
4148	fn src_line_6004() {
4149	let input = r#"``foo`bar``"#;
4150	let output = r#"<p><code>foo`bar</code></p>"#;
4151	run(input, output);
4152	}
4153
4154	#[test]
4155	fn src_line_6010() {
4156	let input = r#"` foo `` bar `"#;
4157	let output = r#"<p><code>foo `` bar</code></p>"#;
4158	run(input, output);
4159	}
4160
4161	#[test]
4162	fn src_line_6022() {
4163	let input = r#"foo``"#;
4164	let output = r#"<p>foo<code></code></p>"#;
4165	run(input, output);
4166	}
4167
4168	#[test]
4169	fn src_line_6031() {
4170	let input = r#"[not a `link](/foo`)"#;
4171	let output = r#"<p>[not a <code>link](/foo</code>)</p>"#;
4172	run(input, output);
4173	}
4174
4175	#[test]
4176	fn src_line_6041() {
4177	let input = r#"`<a href="`">`"#;
4178	let output = r#"<p><code><a href="</code>">`</p>"#;
4179	run(input, output);
4180	}
4181
4182	#[test]
4183	fn src_line_6050() {
4184	let input = r#"<a href="`">`"#;
4185	let output = r#"<p><a href="`">`</p>"#;
4186	run(input, output);
4187	}
4188
4189	#[test]
4190	fn src_line_6059() {
4191	let input = r#"`<http://foo.bar.`baz>`"#;
4192	let output = r#"<p><code><http://foo.bar.</code>baz>`</p>"#;
4193	run(input, output);
4194	}
4195
4196	#[test]
4197	fn src_line_6068() {
4198	let input = r#"<http://foo.bar.`baz>`"#;
4199	let output = r#"<p><a href="http://foo.bar.%60baz">http://foo.bar.`baz</a>`</p>"#;
4200	run(input, output);
4201	}
4202
4203	#[test]
4204	fn src_line_6078() {
4205	let input = r#"```foo``"#;
4206	let output = r#"<p>```foo``</p>"#;
4207	run(input, output);
4208	}
4209
4210	#[test]
4211	fn src_line_6085() {
4212	let input = r#"`foo"#;
4213	let output = r#"<p>`foo</p>"#;
4214	run(input, output);
4215	}
4216
4217	#[test]
4218	fn src_line_6094() {
4219	let input = r#"`foo``bar``"#;
4220	let output = r#"<p>`foo<code>bar</code></p>"#;
4221	run(input, output);
4222	}
4223
4224	#[test]
4225	fn src_line_6311() {
4226	let input = r#"foo bar"#;
4227	let output = r#"<p><em>foo bar</em></p>"#;
4228	run(input, output);
4229	}
4230
4231	#[test]
4232	fn src_line_6321() {
4233	let input = r#"a * foo bar*"#;
4234	let output = r#"<p>a * foo bar*</p>"#;
4235	run(input, output);
4236	}
4237
4238	#[test]
4239	fn src_line_6332() {
4240	let input = r#"a"foo""#;
4241	let output = r#"<p>a"foo"</p>"#;
4242	run(input, output);
4243	}
4244
4245	#[test]
4246	fn src_line_6341() {
4247	let input = r#"* a *"#;
4248	let output = r#"<p>* a *</p>"#;
4249	run(input, output);
4250	}
4251
4252	#[test]
4253	fn src_line_6350() {
4254	let input = r#"foobar"#;
4255	let output = r#"<p>foo<em>bar</em></p>"#;
4256	run(input, output);
4257	}
4258
4259	#[test]
4260	fn src_line_6357() {
4261	let input = r#"5678"#;
4262	let output = r#"<p>5<em>6</em>78</p>"#;
4263	run(input, output);
4264	}
4265
4266	#[test]
4267	fn src_line_6366() {
4268	let input = r#"_foo bar_"#;
4269	let output = r#"<p><em>foo bar</em></p>"#;
4270	run(input, output);
4271	}
4272
4273	#[test]
4274	fn src_line_6376() {
4275	let input = r#"_ foo bar_"#;
4276	let output = r#"<p>_ foo bar_</p>"#;
4277	run(input, output);
4278	}
4279
4280	#[test]
4281	fn src_line_6386() {
4282	let input = r#"a_"foo"_"#;
4283	let output = r#"<p>a_"foo"_</p>"#;
4284	run(input, output);
4285	}
4286
4287	#[test]
4288	fn src_line_6395() {
4289	let input = r#"foo_bar_"#;
4290	let output = r#"<p>foo_bar_</p>"#;
4291	run(input, output);
4292	}
4293
4294	#[test]
4295	fn src_line_6402() {
4296	let input = r#"5_6_78"#;
4297	let output = r#"<p>5_6_78</p>"#;
4298	run(input, output);
4299	}
4300
4301	#[test]
4302	fn src_line_6409() {
4303	let input = r#"пристаням_стремятся_"#;
4304	let output = r#"<p>пристаням_стремятся_</p>"#;
4305	run(input, output);
4306	}
4307
4308	#[test]
4309	fn src_line_6419() {
4310	let input = r#"aa_"bb"_cc"#;
4311	let output = r#"<p>aa_"bb"_cc</p>"#;
4312	run(input, output);
4313	}
4314
4315	#[test]
4316	fn src_line_6430() {
4317	let input = r#"foo-_(bar)_"#;
4318	let output = r#"<p>foo-<em>(bar)</em></p>"#;
4319	run(input, output);
4320	}
4321
4322	#[test]
4323	fn src_line_6442() {
4324	let input = r#"_foo*"#;
4325	let output = r#"<p>_foo*</p>"#;
4326	run(input, output);
4327	}
4328
4329	#[test]
4330	fn src_line_6452() {
4331	let input = r#"foo bar "#;
4332	let output = r#"<p>foo bar </p>"#;
4333	run(input, output);
4334	}
4335
4336	#[test]
4337	fn src_line_6461() {
4338	let input = r#"*foo bar
4339	*"#;
4340	let output = r#"<p>*foo bar
4341	*</p>"#;
4342	run(input, output);
4343	}
4344
4345	#[test]
4346	fn src_line_6474() {
4347	let input = r#"(foo)"#;
4348	let output = r#"<p>(foo)</p>"#;
4349	run(input, output);
4350	}
4351
4352	#[test]
4353	fn src_line_6484() {
4354	let input = r#"(foo)"#;
4355	let output = r#"<p><em>(<em>foo</em>)</em></p>"#;
4356	run(input, output);
4357	}
4358
4359	#[test]
4360	fn src_line_6493() {
4361	let input = r#"foobar"#;
4362	let output = r#"<p><em>foo</em>bar</p>"#;
4363	run(input, output);
4364	}
4365
4366	#[test]
4367	fn src_line_6506() {
4368	let input = r#"_foo bar _"#;
4369	let output = r#"<p>_foo bar _</p>"#;
4370	run(input, output);
4371	}
4372
4373	#[test]
4374	fn src_line_6516() {
4375	let input = r#"_(_foo)"#;
4376	let output = r#"<p>_(_foo)</p>"#;
4377	run(input, output);
4378	}
4379
4380	#[test]
4381	fn src_line_6525() {
4382	let input = r#"_(_foo_)_"#;
4383	let output = r#"<p><em>(<em>foo</em>)</em></p>"#;
4384	run(input, output);
4385	}
4386
4387	#[test]
4388	fn src_line_6534() {
4389	let input = r#"_foo_bar"#;
4390	let output = r#"<p>_foo_bar</p>"#;
4391	run(input, output);
4392	}
4393
4394	#[test]
4395	fn src_line_6541() {
4396	let input = r#"_пристаням_стремятся"#;
4397	let output = r#"<p>_пристаням_стремятся</p>"#;
4398	run(input, output);
4399	}
4400
4401	#[test]
4402	fn src_line_6548() {
4403	let input = r#"_foo_bar_baz_"#;
4404	let output = r#"<p><em>foo_bar_baz</em></p>"#;
4405	run(input, output);
4406	}
4407
4408	#[test]
4409	fn src_line_6559() {
4410	let input = r#"_(bar)_."#;
4411	let output = r#"<p><em>(bar)</em>.</p>"#;
4412	run(input, output);
4413	}
4414
4415	#[test]
4416	fn src_line_6568() {
4417	let input = r#"foo bar"#;
4418	let output = r#"<p><strong>foo bar</strong></p>"#;
4419	run(input, output);
4420	}
4421
4422	#[test]
4423	fn src_line_6578() {
4424	let input = r#" foo bar"#;
4425	let output = r#"<p> foo bar</p>"#;
4426	run(input, output);
4427	}
4428
4429	#[test]
4430	fn src_line_6589() {
4431	let input = r#"a"foo""#;
4432	let output = r#"<p>a"foo"</p>"#;
4433	run(input, output);
4434	}
4435
4436	#[test]
4437	fn src_line_6598() {
4438	let input = r#"foobar"#;
4439	let output = r#"<p>foo<strong>bar</strong></p>"#;
4440	run(input, output);
4441	}
4442
4443	#[test]
4444	fn src_line_6607() {
4445	let input = r#"__foo bar__"#;
4446	let output = r#"<p><strong>foo bar</strong></p>"#;
4447	run(input, output);
4448	}
4449
4450	#[test]
4451	fn src_line_6617() {
4452	let input = r#"__ foo bar__"#;
4453	let output = r#"<p>__ foo bar__</p>"#;
4454	run(input, output);
4455	}
4456
4457	#[test]
4458	fn src_line_6625() {
4459	let input = r#"__
4460	foo bar__"#;
4461	let output = r#"<p>__
4462	foo bar__</p>"#;
4463	run(input, output);
4464	}
4465
4466	#[test]
4467	fn src_line_6637() {
4468	let input = r#"a__"foo"__"#;
4469	let output = r#"<p>a__"foo"__</p>"#;
4470	run(input, output);
4471	}
4472
4473	#[test]
4474	fn src_line_6646() {
4475	let input = r#"foo__bar__"#;
4476	let output = r#"<p>foo__bar__</p>"#;
4477	run(input, output);
4478	}
4479
4480	#[test]
4481	fn src_line_6653() {
4482	let input = r#"5__6__78"#;
4483	let output = r#"<p>5__6__78</p>"#;
4484	run(input, output);
4485	}
4486
4487	#[test]
4488	fn src_line_6660() {
4489	let input = r#"пристаням__стремятся__"#;
4490	let output = r#"<p>пристаням__стремятся__</p>"#;
4491	run(input, output);
4492	}
4493
4494	#[test]
4495	fn src_line_6667() {
4496	let input = r#"__foo, __bar__, baz__"#;
4497	let output = r#"<p><strong>foo, <strong>bar</strong>, baz</strong></p>"#;
4498	run(input, output);
4499	}
4500
4501	#[test]
4502	fn src_line_6678() {
4503	let input = r#"foo-__(bar)__"#;
4504	let output = r#"<p>foo-<strong>(bar)</strong></p>"#;
4505	run(input, output);
4506	}
4507
4508	#[test]
4509	fn src_line_6691() {
4510	let input = r#"foo bar "#;
4511	let output = r#"<p>foo bar </p>"#;
4512	run(input, output);
4513	}
4514
4515	#[test]
4516	fn src_line_6704() {
4517	let input = r#"(foo)"#;
4518	let output = r#"<p>(foo)</p>"#;
4519	run(input, output);
4520	}
4521
4522	#[test]
4523	fn src_line_6714() {
4524	let input = r#"(foo)"#;
4525	let output = r#"<p><em>(<strong>foo</strong>)</em></p>"#;
4526	run(input, output);
4527	}
4528
4529	#[test]
4530	fn src_line_6721() {
4531	let input = r#"*Gomphocarpus (Gomphocarpus physocarpus*, syn.
4532	Asclepias physocarpa)**"#;
4533	let output = r#"<p><strong>Gomphocarpus (<em>Gomphocarpus physocarpus</em>, syn.
4534	<em>Asclepias physocarpa</em>)</strong></p>"#;
4535	run(input, output);
4536	}
4537
4538	#[test]
4539	fn src_line_6730() {
4540	let input = r#"*foo "bar" foo*"#;
4541	let output = r#"<p><strong>foo "<em>bar</em>" foo</strong></p>"#;
4542	run(input, output);
4543	}
4544
4545	#[test]
4546	fn src_line_6739() {
4547	let input = r#"foobar"#;
4548	let output = r#"<p><strong>foo</strong>bar</p>"#;
4549	run(input, output);
4550	}
4551
4552	#[test]
4553	fn src_line_6751() {
4554	let input = r#"__foo bar __"#;
4555	let output = r#"<p>__foo bar __</p>"#;
4556	run(input, output);
4557	}
4558
4559	#[test]
4560	fn src_line_6761() {
4561	let input = r#"__(__foo)"#;
4562	let output = r#"<p>__(__foo)</p>"#;
4563	run(input, output);
4564	}
4565
4566	#[test]
4567	fn src_line_6771() {
4568	let input = r#"_(__foo__)_"#;
4569	let output = r#"<p><em>(<strong>foo</strong>)</em></p>"#;
4570	run(input, output);
4571	}
4572
4573	#[test]
4574	fn src_line_6780() {
4575	let input = r#"__foo__bar"#;
4576	let output = r#"<p>__foo__bar</p>"#;
4577	run(input, output);
4578	}
4579
4580	#[test]
4581	fn src_line_6787() {
4582	let input = r#"__пристаням__стремятся"#;
4583	let output = r#"<p>__пристаням__стремятся</p>"#;
4584	run(input, output);
4585	}
4586
4587	#[test]
4588	fn src_line_6794() {
4589	let input = r#"__foo__bar__baz__"#;
4590	let output = r#"<p><strong>foo__bar__baz</strong></p>"#;
4591	run(input, output);
4592	}
4593
4594	#[test]
4595	fn src_line_6805() {
4596	let input = r#"__(bar)__."#;
4597	let output = r#"<p><strong>(bar)</strong>.</p>"#;
4598	run(input, output);
4599	}
4600
4601	#[test]
4602	fn src_line_6817() {
4603	let input = r#"foo [bar](/url)"#;
4604	let output = r#"<p><em>foo <a href="/url">bar</a></em></p>"#;
4605	run(input, output);
4606	}
4607
4608	#[test]
4609	fn src_line_6824() {
4610	let input = r#"*foo
4611	bar*"#;
4612	let output = r#"<p><em>foo
4613	bar</em></p>"#;
4614	run(input, output);
4615	}
4616
4617	#[test]
4618	fn src_line_6836() {
4619	let input = r#"_foo __bar__ baz_"#;
4620	let output = r#"<p><em>foo <strong>bar</strong> baz</em></p>"#;
4621	run(input, output);
4622	}
4623
4624	#[test]
4625	fn src_line_6843() {
4626	let input = r#"_foo _bar_ baz_"#;
4627	let output = r#"<p><em>foo <em>bar</em> baz</em></p>"#;
4628	run(input, output);
4629	}
4630
4631	#[test]
4632	fn src_line_6850() {
4633	let input = r#"__foo_ bar_"#;
4634	let output = r#"<p><em><em>foo</em> bar</em></p>"#;
4635	run(input, output);
4636	}
4637
4638	#[test]
4639	fn src_line_6857() {
4640	let input = r#"foo bar**"#;
4641	let output = r#"<p><em>foo <em>bar</em></em></p>"#;
4642	run(input, output);
4643	}
4644
4645	#[test]
4646	fn src_line_6864() {
4647	let input = r#"foo bar* baz*"#;
4648	let output = r#"<p><em>foo <strong>bar</strong> baz</em></p>"#;
4649	run(input, output);
4650	}
4651
4652	#[test]
4653	fn src_line_6870() {
4654	let input = r#"foobarbaz"#;
4655	let output = r#"<p><em>foo<strong>bar</strong>baz</em></p>"#;
4656	run(input, output);
4657	}
4658
4659	#[test]
4660	fn src_line_6894() {
4661	let input = r#"foobar"#;
4662	let output = r#"<p><em>foo**bar</em></p>"#;
4663	run(input, output);
4664	}
4665
4666	#[test]
4667	fn src_line_6907() {
4668	let input = r#"*foo bar*"#;
4669	let output = r#"<p><em><strong>foo</strong> bar</em></p>"#;
4670	run(input, output);
4671	}
4672
4673	#[test]
4674	fn src_line_6914() {
4675	let input = r#"foo bar**"#;
4676	let output = r#"<p><em>foo <strong>bar</strong></em></p>"#;
4677	run(input, output);
4678	}
4679
4680	#[test]
4681	fn src_line_6921() {
4682	let input = r#"foobar**"#;
4683	let output = r#"<p><em>foo<strong>bar</strong></em></p>"#;
4684	run(input, output);
4685	}
4686
4687	#[test]
4688	fn src_line_6932() {
4689	let input = r#"foo*bar*baz"#;
4690	let output = r#"<p>foo<em><strong>bar</strong></em>baz</p>"#;
4691	run(input, output);
4692	}
4693
4694	#[test]
4695	fn src_line_6938() {
4696	let input = r#"foo****bar*******baz"#;
4697	let output = r#"<p>foo<strong><strong><strong>bar</strong></strong></strong>***baz</p>"#;
4698	run(input, output);
4699	}
4700
4701	#[test]
4702	fn src_line_6947() {
4703	let input = r#"foo bar baz* bim** bop*"#;
4704	let output = r#"<p><em>foo <strong>bar <em>baz</em> bim</strong> bop</em></p>"#;
4705	run(input, output);
4706	}
4707
4708	#[test]
4709	fn src_line_6954() {
4710	let input = r#"foo [bar](/url)"#;
4711	let output = r#"<p><em>foo <a href="/url"><em>bar</em></a></em></p>"#;
4712	run(input, output);
4713	}
4714
4715	#[test]
4716	fn src_line_6963() {
4717	let input = r#"** is not an empty emphasis"#;
4718	let output = r#"<p>** is not an empty emphasis</p>"#;
4719	run(input, output);
4720	}
4721
4722	#[test]
4723	fn src_line_6970() {
4724	let input = r#"**** is not an empty strong emphasis"#;
4725	let output = r#"<p>**** is not an empty strong emphasis</p>"#;
4726	run(input, output);
4727	}
4728
4729	#[test]
4730	fn src_line_6983() {
4731	let input = r#"foo [bar](/url)"#;
4732	let output = r#"<p><strong>foo <a href="/url">bar</a></strong></p>"#;
4733	run(input, output);
4734	}
4735
4736	#[test]
4737	fn src_line_6990() {
4738	let input = r#"**foo
4739	bar**"#;
4740	let output = r#"<p><strong>foo
4741	bar</strong></p>"#;
4742	run(input, output);
4743	}
4744
4745	#[test]
4746	fn src_line_7002() {
4747	let input = r#"__foo _bar_ baz__"#;
4748	let output = r#"<p><strong>foo <em>bar</em> baz</strong></p>"#;
4749	run(input, output);
4750	}
4751
4752	#[test]
4753	fn src_line_7009() {
4754	let input = r#"__foo __bar__ baz__"#;
4755	let output = r#"<p><strong>foo <strong>bar</strong> baz</strong></p>"#;
4756	run(input, output);
4757	}
4758
4759	#[test]
4760	fn src_line_7016() {
4761	let input = r#"____foo__ bar__"#;
4762	let output = r#"<p><strong><strong>foo</strong> bar</strong></p>"#;
4763	run(input, output);
4764	}
4765
4766	#[test]
4767	fn src_line_7023() {
4768	let input = r#"foo bar****"#;
4769	let output = r#"<p><strong>foo <strong>bar</strong></strong></p>"#;
4770	run(input, output);
4771	}
4772
4773	#[test]
4774	fn src_line_7030() {
4775	let input = r#"*foo bar* baz**"#;
4776	let output = r#"<p><strong>foo <em>bar</em> baz</strong></p>"#;
4777	run(input, output);
4778	}
4779
4780	#[test]
4781	fn src_line_7037() {
4782	let input = r#"*foobarbaz*"#;
4783	let output = r#"<p><strong>foo<em>bar</em>baz</strong></p>"#;
4784	run(input, output);
4785	}
4786
4787	#[test]
4788	fn src_line_7044() {
4789	let input = r#"**foo bar**"#;
4790	let output = r#"<p><strong><em>foo</em> bar</strong></p>"#;
4791	run(input, output);
4792	}
4793
4794	#[test]
4795	fn src_line_7051() {
4796	let input = r#"*foo bar***"#;
4797	let output = r#"<p><strong>foo <em>bar</em></strong></p>"#;
4798	run(input, output);
4799	}
4800
4801	#[test]
4802	fn src_line_7060() {
4803	let input = r#"*foo bar baz
4804	bim* bop**"#;
4805	let output = r#"<p><strong>foo <em>bar <strong>baz</strong>
4806	bim</em> bop</strong></p>"#;
4807	run(input, output);
4808	}
4809
4810	#[test]
4811	fn src_line_7069() {
4812	let input = r#"*foo [bar](/url)*"#;
4813	let output = r#"<p><strong>foo <a href="/url"><em>bar</em></a></strong></p>"#;
4814	run(input, output);
4815	}
4816
4817	#[test]
4818	fn src_line_7078() {
4819	let input = r#"__ is not an empty emphasis"#;
4820	let output = r#"<p>__ is not an empty emphasis</p>"#;
4821	run(input, output);
4822	}
4823
4824	#[test]
4825	fn src_line_7085() {
4826	let input = r#"____ is not an empty strong emphasis"#;
4827	let output = r#"<p>____ is not an empty strong emphasis</p>"#;
4828	run(input, output);
4829	}
4830
4831	#[test]
4832	fn src_line_7095() {
4833	let input = r#"foo ***"#;
4834	let output = r#"<p>foo ***</p>"#;
4835	run(input, output);
4836	}
4837
4838	#[test]
4839	fn src_line_7102() {
4840	let input = r#"foo \*"#;
4841	let output = r#"<p>foo <em>*</em></p>"#;
4842	run(input, output);
4843	}
4844
4845	#[test]
4846	fn src_line_7109() {
4847	let input = r#"foo _"#;
4848	let output = r#"<p>foo <em>_</em></p>"#;
4849	run(input, output);
4850	}
4851
4852	#[test]
4853	fn src_line_7116() {
4854	let input = r#"foo *****"#;
4855	let output = r#"<p>foo *****</p>"#;
4856	run(input, output);
4857	}
4858
4859	#[test]
4860	fn src_line_7123() {
4861	let input = r#"foo \*"#;
4862	let output = r#"<p>foo <strong>*</strong></p>"#;
4863	run(input, output);
4864	}
4865
4866	#[test]
4867	fn src_line_7130() {
4868	let input = r#"foo _"#;
4869	let output = r#"<p>foo <strong>_</strong></p>"#;
4870	run(input, output);
4871	}
4872
4873	#[test]
4874	fn src_line_7141() {
4875	let input = r#"*foo"#;
4876	let output = r#"<p>*<em>foo</em></p>"#;
4877	run(input, output);
4878	}
4879
4880	#[test]
4881	fn src_line_7148() {
4882	let input = r#"foo*"#;
4883	let output = r#"<p><em>foo</em>*</p>"#;
4884	run(input, output);
4885	}
4886
4887	#[test]
4888	fn src_line_7155() {
4889	let input = r#"*foo"#;
4890	let output = r#"<p>*<strong>foo</strong></p>"#;
4891	run(input, output);
4892	}
4893
4894	#[test]
4895	fn src_line_7162() {
4896	let input = r#"***foo"#;
4897	let output = r#"<p>***<em>foo</em></p>"#;
4898	run(input, output);
4899	}
4900
4901	#[test]
4902	fn src_line_7169() {
4903	let input = r#"foo*"#;
4904	let output = r#"<p><strong>foo</strong>*</p>"#;
4905	run(input, output);
4906	}
4907
4908	#[test]
4909	fn src_line_7176() {
4910	let input = r#"foo***"#;
4911	let output = r#"<p><em>foo</em>***</p>"#;
4912	run(input, output);
4913	}
4914
4915	#[test]
4916	fn src_line_7186() {
4917	let input = r#"foo ___"#;
4918	let output = r#"<p>foo ___</p>"#;
4919	run(input, output);
4920	}
4921
4922	#[test]
4923	fn src_line_7193() {
4924	let input = r#"foo _\__"#;
4925	let output = r#"<p>foo <em>_</em></p>"#;
4926	run(input, output);
4927	}
4928
4929	#[test]
4930	fn src_line_7200() {
4931	let input = r#"foo _*_"#;
4932	let output = r#"<p>foo <em>*</em></p>"#;
4933	run(input, output);
4934	}
4935
4936	#[test]
4937	fn src_line_7207() {
4938	let input = r#"foo _____"#;
4939	let output = r#"<p>foo _____</p>"#;
4940	run(input, output);
4941	}
4942
4943	#[test]
4944	fn src_line_7214() {
4945	let input = r#"foo __\___"#;
4946	let output = r#"<p>foo <strong>_</strong></p>"#;
4947	run(input, output);
4948	}
4949
4950	#[test]
4951	fn src_line_7221() {
4952	let input = r#"foo __*__"#;
4953	let output = r#"<p>foo <strong>*</strong></p>"#;
4954	run(input, output);
4955	}
4956
4957	#[test]
4958	fn src_line_7228() {
4959	let input = r#"__foo_"#;
4960	let output = r#"<p>_<em>foo</em></p>"#;
4961	run(input, output);
4962	}
4963
4964	#[test]
4965	fn src_line_7239() {
4966	let input = r#"_foo__"#;
4967	let output = r#"<p><em>foo</em>_</p>"#;
4968	run(input, output);
4969	}
4970
4971	#[test]
4972	fn src_line_7246() {
4973	let input = r#"___foo__"#;
4974	let output = r#"<p>_<strong>foo</strong></p>"#;
4975	run(input, output);
4976	}
4977
4978	#[test]
4979	fn src_line_7253() {
4980	let input = r#"____foo_"#;
4981	let output = r#"<p>___<em>foo</em></p>"#;
4982	run(input, output);
4983	}
4984
4985	#[test]
4986	fn src_line_7260() {
4987	let input = r#"__foo___"#;
4988	let output = r#"<p><strong>foo</strong>_</p>"#;
4989	run(input, output);
4990	}
4991
4992	#[test]
4993	fn src_line_7267() {
4994	let input = r#"_foo____"#;
4995	let output = r#"<p><em>foo</em>___</p>"#;
4996	run(input, output);
4997	}
4998
4999	#[test]
5000	fn src_line_7277() {
5001	let input = r#"foo"#;
5002	let output = r#"<p><strong>foo</strong></p>"#;
5003	run(input, output);
5004	}
5005
5006	#[test]
5007	fn src_line_7284() {
5008	let input = r#"_foo_"#;
5009	let output = r#"<p><em><em>foo</em></em></p>"#;
5010	run(input, output);
5011	}
5012
5013	#[test]
5014	fn src_line_7291() {
5015	let input = r#"__foo__"#;
5016	let output = r#"<p><strong>foo</strong></p>"#;
5017	run(input, output);
5018	}
5019
5020	#[test]
5021	fn src_line_7298() {
5022	let input = r#"_foo_"#;
5023	let output = r#"<p><em><em>foo</em></em></p>"#;
5024	run(input, output);
5025	}
5026
5027	#[test]
5028	fn src_line_7308() {
5029	let input = r#"**foo**"#;
5030	let output = r#"<p><strong><strong>foo</strong></strong></p>"#;
5031	run(input, output);
5032	}
5033
5034	#[test]
5035	fn src_line_7315() {
5036	let input = r#"____foo____"#;
5037	let output = r#"<p><strong><strong>foo</strong></strong></p>"#;
5038	run(input, output);
5039	}
5040
5041	#[test]
5042	fn src_line_7326() {
5043	let input = r#"****foo****"#;
5044	let output = r#"<p><strong><strong><strong>foo</strong></strong></strong></p>"#;
5045	run(input, output);
5046	}
5047
5048	#[test]
5049	fn src_line_7335() {
5050	let input = r#"*foo*"#;
5051	let output = r#"<p><em><strong>foo</strong></em></p>"#;
5052	run(input, output);
5053	}
5054
5055	#[test]
5056	fn src_line_7342() {
5057	let input = r#"_____foo_____"#;
5058	let output = r#"<p><em><strong><strong>foo</strong></strong></em></p>"#;
5059	run(input, output);
5060	}
5061
5062	#[test]
5063	fn src_line_7351() {
5064	let input = r#"foo _bar baz_"#;
5065	let output = r#"<p><em>foo _bar</em> baz_</p>"#;
5066	run(input, output);
5067	}
5068
5069	#[test]
5070	fn src_line_7358() {
5071	let input = r#"foo __bar baz bim__ bam*"#;
5072	let output = r#"<p><em>foo <strong>bar *baz bim</strong> bam</em></p>"#;
5073	run(input, output);
5074	}
5075
5076	#[test]
5077	fn src_line_7367() {
5078	let input = r#"foo bar baz**"#;
5079	let output = r#"<p>**foo <strong>bar baz</strong></p>"#;
5080	run(input, output);
5081	}
5082
5083	#[test]
5084	fn src_line_7374() {
5085	let input = r#"foo bar baz*"#;
5086	let output = r#"<p>*foo <em>bar baz</em></p>"#;
5087	run(input, output);
5088	}
5089
5090	#[test]
5091	fn src_line_7383() {
5092	let input = r#"[bar](/url)"#;
5093	let output = r#"<p><a href="/url">bar</a></p>"#;
5094	run(input, output);
5095	}
5096
5097	#[test]
5098	fn src_line_7390() {
5099	let input = r#"_foo [bar_](/url)"#;
5100	let output = r#"<p>_foo <a href="/url">bar_</a></p>"#;
5101	run(input, output);
5102	}
5103
5104	#[test]
5105	fn src_line_7397() {
5106	let input = r#"<img src="foo" title=""/>"#;
5107	let output = r#"<p><img src="foo" title=""/></p>"#;
5108	run(input, output);
5109	}
5110
5111	#[test]
5112	fn src_line_7404() {
5113	let input = r#"<a href="">"#;
5114	let output = r#"<p><a href=""></p>"#;
5115	run(input, output);
5116	}
5117
5118	#[test]
5119	fn src_line_7411() {
5120	let input = r#"__<a href="__">"#;
5121	let output = r#"<p>__<a href="__"></p>"#;
5122	run(input, output);
5123	}
5124
5125	#[test]
5126	fn src_line_7418() {
5127	let input = r#"a ``*"#;
5128	let output = r#"<p><em>a <code>*</code></em></p>"#;
5129	run(input, output);
5130	}
5131
5132	#[test]
5133	fn src_line_7425() {
5134	let input = r#"_a `_`_"#;
5135	let output = r#"<p><em>a <code>_</code></em></p>"#;
5136	run(input, output);
5137	}
5138
5139	#[test]
5140	fn src_line_7432() {
5141	let input = r#"a<http://foo.bar/?q=>"#;
5142	let output = r#"<p>a<a href="http://foo.bar/?q=">http://foo.bar/?q=**</a></p>"#;
5143	run(input, output);
5144	}
5145
5146	#[test]
5147	fn src_line_7439() {
5148	let input = r#"__a<http://foo.bar/?q=__>"#;
5149	let output = r#"<p>__a<a href="http://foo.bar/?q=__">http://foo.bar/?q=__</a></p>"#;
5150	run(input, output);
5151	}
5152
5153	#[test]
5154	fn src_line_7527() {
5155	let input = r#"[link](/uri "title")"#;
5156	let output = r#"<p><a href="/uri" title="title">link</a></p>"#;
5157	run(input, output);
5158	}
5159
5160	#[test]
5161	fn src_line_7537() {
5162	let input = r#"[link](/uri)"#;
5163	let output = r#"<p><a href="/uri">link</a></p>"#;
5164	run(input, output);
5165	}
5166
5167	#[test]
5168	fn src_line_7543() {
5169	let input = r#"[](./target.md)"#;
5170	let output = r#"<p><a href="./target.md"></a></p>"#;
5171	run(input, output);
5172	}
5173
5174	#[test]
5175	fn src_line_7550() {
5176	let input = r#"[link]()"#;
5177	let output = r#"<p><a href="">link</a></p>"#;
5178	run(input, output);
5179	}
5180
5181	#[test]
5182	fn src_line_7557() {
5183	let input = r#"[link](<>)"#;
5184	let output = r#"<p><a href="">link</a></p>"#;
5185	run(input, output);
5186	}
5187
5188	#[test]
5189	fn src_line_7564() {
5190	let input = r#"[]()"#;
5191	let output = r#"<p><a href=""></a></p>"#;
5192	run(input, output);
5193	}
5194
5195	#[test]
5196	fn src_line_7573() {
5197	let input = r#"[link](/my uri)"#;
5198	let output = r#"<p>[link](/my uri)</p>"#;
5199	run(input, output);
5200	}
5201
5202	#[test]
5203	fn src_line_7579() {
5204	let input = r#"[link](</my uri>)"#;
5205	let output = r#"<p><a href="/my%20uri">link</a></p>"#;
5206	run(input, output);
5207	}
5208
5209	#[test]
5210	fn src_line_7588() {
5211	let input = r#"[link](foo
5212	bar)"#;
5213	let output = r#"<p>[link](foo
5214	bar)</p>"#;
5215	run(input, output);
5216	}
5217
5218	#[test]
5219	fn src_line_7596() {
5220	let input = r#"[link](<foo
5221	bar>)"#;
5222	let output = r#"<p>[link](<foo
5223	bar>)</p>"#;
5224	run(input, output);
5225	}
5226
5227	#[test]
5228	fn src_line_7607() {
5229	let input = r#"[a](<b)c>)"#;
5230	let output = r#"<p><a href="b)c">a</a></p>"#;
5231	run(input, output);
5232	}
5233
5234	#[test]
5235	fn src_line_7615() {
5236	let input = r#"[link](<foo\>)"#;
5237	let output = r#"<p>[link](<foo>)</p>"#;
5238	run(input, output);
5239	}
5240
5241	#[test]
5242	fn src_line_7624() {
5243	let input = r#"[a](<b)c
5244	[a](<b)c>
5245	[a](<b>c)"#;
5246	let output = r#"<p>[a](<b)c
5247	[a](<b)c>
5248	[a](<b>c)</p>"#;
5249	run(input, output);
5250	}
5251
5252	#[test]
5253	fn src_line_7636() {
5254	let input = r#"[link]($foo$)"#;
5255	let output = r#"<p><a href="(foo)">link</a></p>"#;
5256	run(input, output);
5257	}
5258
5259	#[test]
5260	fn src_line_7645() {
5261	let input = r#"[link](foo(and(bar)))"#;
5262	let output = r#"<p><a href="foo(and(bar))">link</a></p>"#;
5263	run(input, output);
5264	}
5265
5266	#[test]
5267	fn src_line_7654() {
5268	let input = r#"[link](foo(and(bar))"#;
5269	let output = r#"<p>[link](foo(and(bar))</p>"#;
5270	run(input, output);
5271	}
5272
5273	#[test]
5274	fn src_line_7661() {
5275	let input = r#"[link](foo$and\(bar$)"#;
5276	let output = r#"<p><a href="foo(and(bar)">link</a></p>"#;
5277	run(input, output);
5278	}
5279
5280	#[test]
5281	fn src_line_7668() {
5282	let input = r#"[link](<foo(and(bar)>)"#;
5283	let output = r#"<p><a href="foo(and(bar)">link</a></p>"#;
5284	run(input, output);
5285	}
5286
5287	#[test]
5288	fn src_line_7678() {
5289	let input = r#"[link](foo\)\:)"#;
5290	let output = r#"<p><a href="foo):">link</a></p>"#;
5291	run(input, output);
5292	}
5293
5294	#[test]
5295	fn src_line_7687() {
5296	let input = r#"[link](#fragment)
5297
5298	[link](http://example.com#fragment)
5299
5300	[link](http://example.com?foo=3#frag)"#;
5301	let output = r##"<p><a href="#fragment">link</a></p>
5302	<p><a href="http://example.com#fragment">link</a></p>
5303	<p><a href="http://example.com?foo=3#frag">link</a></p>"##;
5304	run(input, output);
5305	}
5306
5307	#[test]
5308	fn src_line_7703() {
5309	let input = r#"[link](foo\bar)"#;
5310	let output = r#"<p><a href="foo%5Cbar">link</a></p>"#;
5311	run(input, output);
5312	}
5313
5314	#[test]
5315	fn src_line_7719() {
5316	let input = r#"[link](foo%20bä)"#;
5317	let output = r#"<p><a href="foo%20b%C3%A4">link</a></p>"#;
5318	run(input, output);
5319	}
5320
5321	#[test]
5322	fn src_line_7730() {
5323	let input = r#"[link]("title")"#;
5324	let output = r#"<p><a href="%22title%22">link</a></p>"#;
5325	run(input, output);
5326	}
5327
5328	#[test]
5329	fn src_line_7739() {
5330	let input = r#"[link](/url "title")
5331	[link](/url 'title')
5332	[link](/url (title))"#;
5333	let output = r#"<p><a href="/url" title="title">link</a>
5334	<a href="/url" title="title">link</a>
5335	<a href="/url" title="title">link</a></p>"#;
5336	run(input, output);
5337	}
5338
5339	#[test]
5340	fn src_line_7753() {
5341	let input = r#"[link](/url "title \""")"#;
5342	let output = r#"<p><a href="/url" title="title """>link</a></p>"#;
5343	run(input, output);
5344	}
5345
5346	#[test]
5347	fn src_line_7764() {
5348	let input = r#"[link](/url "title")"#;
5349	let output = r#"<p><a href="/url%C2%A0%22title%22">link</a></p>"#;
5350	run(input, output);
5351	}
5352
5353	#[test]
5354	fn src_line_7773() {
5355	let input = r#"[link](/url "title "and" title")"#;
5356	let output = r#"<p>[link](/url "title "and" title")</p>"#;
5357	run(input, output);
5358	}
5359
5360	#[test]
5361	fn src_line_7782() {
5362	let input = r#"[link](/url 'title "and" title')"#;
5363	let output = r#"<p><a href="/url" title="title "and" title">link</a></p>"#;
5364	run(input, output);
5365	}
5366
5367	#[test]
5368	fn src_line_7807() {
5369	let input = r#"[link]( /uri
5370	"title" )"#;
5371	let output = r#"<p><a href="/uri" title="title">link</a></p>"#;
5372	run(input, output);
5373	}
5374
5375	#[test]
5376	fn src_line_7818() {
5377	let input = r#"[link] (/uri)"#;
5378	let output = r#"<p>[link] (/uri)</p>"#;
5379	run(input, output);
5380	}
5381
5382	#[test]
5383	fn src_line_7828() {
5384	let input = r#"[link [foo [bar]]](/uri)"#;
5385	let output = r#"<p><a href="/uri">link [foo [bar]]</a></p>"#;
5386	run(input, output);
5387	}
5388
5389	#[test]
5390	fn src_line_7835() {
5391	let input = r#"[link] bar](/uri)"#;
5392	let output = r#"<p>[link] bar](/uri)</p>"#;
5393	run(input, output);
5394	}
5395
5396	#[test]
5397	fn src_line_7842() {
5398	let input = r#"[link [bar](/uri)"#;
5399	let output = r#"<p>[link <a href="/uri">bar</a></p>"#;
5400	run(input, output);
5401	}
5402
5403	#[test]
5404	fn src_line_7849() {
5405	let input = r#"[link \[bar](/uri)"#;
5406	let output = r#"<p><a href="/uri">link [bar</a></p>"#;
5407	run(input, output);
5408	}
5409
5410	#[test]
5411	fn src_line_7858() {
5412	let input = r#"[link foo bar* `#`*](/uri)"#;
5413	let output = r#"<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>"#;
5414	run(input, output);
5415	}
5416
5417	#[test]
5418	fn src_line_7865() {
5419	let input = r#"[![moon](moon.jpg)](/uri)"#;
5420	let output = r#"<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>"#;
5421	run(input, output);
5422	}
5423
5424	#[test]
5425	fn src_line_7874() {
5426	let input = r#"[foo [bar](/uri)](/uri)"#;
5427	let output = r#"<p>[foo <a href="/uri">bar</a>](/uri)</p>"#;
5428	run(input, output);
5429	}
5430
5431	#[test]
5432	fn src_line_7881() {
5433	let input = r#"[foo [bar [baz](/uri)](/uri)](/uri)"#;
5434	let output = r#"<p>[foo <em>[bar <a href="/uri">baz</a>](/uri)</em>](/uri)</p>"#;
5435	run(input, output);
5436	}
5437
5438	#[test]
5439	fn src_line_7888() {
5440	let input = r#"![[[foo](uri1)](uri2)](uri3)"#;
5441	let output = r#"<p><img src="uri3" alt="[foo](uri2)" /></p>"#;
5442	run(input, output);
5443	}
5444
5445	#[test]
5446	fn src_line_7898() {
5447	let input = r#"[foo](/uri)"#;
5448	let output = r#"<p><a href="/uri">foo</a></p>"#;
5449	run(input, output);
5450	}
5451
5452	#[test]
5453	fn src_line_7905() {
5454	let input = r#"[foo bar](baz)"#;
5455	let output = r#"<p><a href="baz">foo bar</a></p>"#;
5456	run(input, output);
5457	}
5458
5459	#[test]
5460	fn src_line_7915() {
5461	let input = r#"foo [bar baz]"#;
5462	let output = r#"<p><em>foo [bar</em> baz]</p>"#;
5463	run(input, output);
5464	}
5465
5466	#[test]
5467	fn src_line_7925() {
5468	let input = r#"[foo <bar attr="](baz)">"#;
5469	let output = r#"<p>[foo <bar attr="](baz)"></p>"#;
5470	run(input, output);
5471	}
5472
5473	#[test]
5474	fn src_line_7932() {
5475	let input = r#"[foo`](/uri)`"#;
5476	let output = r#"<p>[foo<code>](/uri)</code></p>"#;
5477	run(input, output);
5478	}
5479
5480	#[test]
5481	fn src_line_7939() {
5482	let input = r#"[foo<http://example.com/?search=](uri)>"#;
5483	let output = r#"<p>[foo<a href="http://example.com/?search=%5D(uri)">http://example.com/?search=](uri)</a></p>"#;
5484	run(input, output);
5485	}
5486
5487	#[test]
5488	fn src_line_7977() {
5489	let input = r#"[foo][bar]
5490
5491	[bar]: /url "title""#;
5492	let output = r#"<p><a href="/url" title="title">foo</a></p>"#;
5493	run(input, output);
5494	}
5495
5496	#[test]
5497	fn src_line_7992() {
5498	let input = r#"[link [foo [bar]]][ref]
5499
5500	[ref]: /uri"#;
5501	let output = r#"<p><a href="/uri">link [foo [bar]]</a></p>"#;
5502	run(input, output);
5503	}
5504
5505	#[test]
5506	fn src_line_8001() {
5507	let input = r#"[link \[bar][ref]
5508
5509	[ref]: /uri"#;
5510	let output = r#"<p><a href="/uri">link [bar</a></p>"#;
5511	run(input, output);
5512	}
5513
5514	#[test]
5515	fn src_line_8012() {
5516	let input = r#"[link foo bar* `#`*][ref]
5517
5518	[ref]: /uri"#;
5519	let output = r#"<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>"#;
5520	run(input, output);
5521	}
5522
5523	#[test]
5524	fn src_line_8021() {
5525	let input = r#"[![moon](moon.jpg)][ref]
5526
5527	[ref]: /uri"#;
5528	let output = r#"<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>"#;
5529	run(input, output);
5530	}
5531
5532	#[test]
5533	fn src_line_8032() {
5534	let input = r#"[foo [bar](/uri)][ref]
5535
5536	[ref]: /uri"#;
5537	let output = r#"<p>[foo <a href="/uri">bar</a>]<a href="/uri">ref</a></p>"#;
5538	run(input, output);
5539	}
5540
5541	#[test]
5542	fn src_line_8041() {
5543	let input = r#"[foo bar [baz][ref]][ref]
5544
5545	[ref]: /uri"#;
5546	let output = r#"<p>[foo <em>bar <a href="/uri">baz</a></em>]<a href="/uri">ref</a></p>"#;
5547	run(input, output);
5548	}
5549
5550	#[test]
5551	fn src_line_8056() {
5552	let input = r#"[foo][ref]
5553
5554	[ref]: /uri"#;
5555	let output = r#"<p><a href="/uri">foo</a></p>"#;
5556	run(input, output);
5557	}
5558
5559	#[test]
5560	fn src_line_8065() {
5561	let input = r#"[foo bar][ref]
5562
5563	[ref]: /uri"#;
5564	let output = r#"<p><a href="/uri">foo bar</a></p>"#;
5565	run(input, output);
5566	}
5567
5568	#[test]
5569	fn src_line_8077() {
5570	let input = r#"[foo <bar attr="][ref]">
5571
5572	[ref]: /uri"#;
5573	let output = r#"<p>[foo <bar attr="][ref]"></p>"#;
5574	run(input, output);
5575	}
5576
5577	#[test]
5578	fn src_line_8086() {
5579	let input = r#"[foo`][ref]`
5580
5581	[ref]: /uri"#;
5582	let output = r#"<p>[foo<code>][ref]</code></p>"#;
5583	run(input, output);
5584	}
5585
5586	#[test]
5587	fn src_line_8095() {
5588	let input = r#"[foo<http://example.com/?search=][ref]>
5589
5590	[ref]: /uri"#;
5591	let output = r#"<p>[foo<a href="http://example.com/?search=%5D%5Bref%5D">http://example.com/?search=][ref]</a></p>"#;
5592	run(input, output);
5593	}
5594
5595	#[test]
5596	fn src_line_8106() {
5597	let input = r#"[foo][BaR]
5598
5599	[bar]: /url "title""#;
5600	let output = r#"<p><a href="/url" title="title">foo</a></p>"#;
5601	run(input, output);
5602	}
5603
5604	#[test]
5605	fn src_line_8117() {
5606	let input = r#"[ẞ]
5607
5608	[SS]: /url"#;
5609	let output = r#"<p><a href="/url">ẞ</a></p>"#;
5610	run(input, output);
5611	}
5612
5613	#[test]
5614	fn src_line_8129() {
5615	let input = r#"[Foo
5616	bar]: /url
5617
5618	[Baz][Foo bar]"#;
5619	let output = r#"<p><a href="/url">Baz</a></p>"#;
5620	run(input, output);
5621	}
5622
5623	#[test]
5624	fn src_line_8142() {
5625	let input = r#"[foo] [bar]
5626
5627	[bar]: /url "title""#;
5628	let output = r#"<p>[foo] <a href="/url" title="title">bar</a></p>"#;
5629	run(input, output);
5630	}
5631
5632	#[test]
5633	fn src_line_8151() {
5634	let input = r#"[foo]
5635	[bar]
5636
5637	[bar]: /url "title""#;
5638	let output = r#"<p>[foo]
5639	<a href="/url" title="title">bar</a></p>"#;
5640	run(input, output);
5641	}
5642
5643	#[test]
5644	fn src_line_8192() {
5645	let input = r#"[foo]: /url1
5646
5647	[foo]: /url2
5648
5649	[bar][foo]"#;
5650	let output = r#"<p><a href="/url1">bar</a></p>"#;
5651	run(input, output);
5652	}
5653
5654	#[test]
5655	fn src_line_8207() {
5656	let input = r#"[bar][foo\!]
5657
5658	[foo!]: /url"#;
5659	let output = r#"<p>[bar][foo!]</p>"#;
5660	run(input, output);
5661	}
5662
5663	#[test]
5664	fn src_line_8219() {
5665	let input = r#"[foo][ref[]
5666
5667	[ref[]: /uri"#;
5668	let output = r#"<p>[foo][ref[]</p>
5669	<p>[ref[]: /uri</p>"#;
5670	run(input, output);
5671	}
5672
5673	#[test]
5674	fn src_line_8229() {
5675	let input = r#"[foo][ref[bar]]
5676
5677	[ref[bar]]: /uri"#;
5678	let output = r#"<p>[foo][ref[bar]]</p>
5679	<p>[ref[bar]]: /uri</p>"#;
5680	run(input, output);
5681	}
5682
5683	#[test]
5684	fn src_line_8239() {
5685	let input = r#"[[[foo]]]
5686
5687	[[[foo]]]: /url"#;
5688	let output = r#"<p>[[[foo]]]</p>
5689	<p>[[[foo]]]: /url</p>"#;
5690	run(input, output);
5691	}
5692
5693	#[test]
5694	fn src_line_8249() {
5695	let input = r#"[foo][ref\[]
5696
5697	[ref\[]: /uri"#;
5698	let output = r#"<p><a href="/uri">foo</a></p>"#;
5699	run(input, output);
5700	}
5701
5702	#[test]
5703	fn src_line_8260() {
5704	let input = r#"[bar\\]: /uri
5705
5706	[bar\\]"#;
5707	let output = r#"<p><a href="/uri">bar\</a></p>"#;
5708	run(input, output);
5709	}
5710
5711	#[test]
5712	fn src_line_8272() {
5713	let input = r#"[]
5714
5715	[]: /uri"#;
5716	let output = r#"<p>[]</p>
5717	<p>[]: /uri</p>"#;
5718	run(input, output);
5719	}
5720
5721	#[test]
5722	fn src_line_8282() {
5723	let input = r#"[
5724	]
5725
5726	[
5727	]: /uri"#;
5728	let output = r#"<p>[
5729	]</p>
5730	<p>[
5731	]: /uri</p>"#;
5732	run(input, output);
5733	}
5734
5735	#[test]
5736	fn src_line_8305() {
5737	let input = r#"[foo][]
5738
5739	[foo]: /url "title""#;
5740	let output = r#"<p><a href="/url" title="title">foo</a></p>"#;
5741	run(input, output);
5742	}
5743
5744	#[test]
5745	fn src_line_8314() {
5746	let input = r#"[foo bar][]
5747
5748	[foo bar]: /url "title""#;
5749	let output = r#"<p><a href="/url" title="title"><em>foo</em> bar</a></p>"#;
5750	run(input, output);
5751	}
5752
5753	#[test]
5754	fn src_line_8325() {
5755	let input = r#"[Foo][]
5756
5757	[foo]: /url "title""#;
5758	let output = r#"<p><a href="/url" title="title">Foo</a></p>"#;
5759	run(input, output);
5760	}
5761
5762	#[test]
5763	fn src_line_8338() {
5764	let input = "[foo]\x20
5765	[]
5766
5767	[foo]: /url \"title\"";
5768	let output = r#"<p><a href="/url" title="title">foo</a>
5769	[]</p>"#;
5770	run(input, output);
5771	}
5772
5773	#[test]
5774	fn src_line_8358() {
5775	let input = r#"[foo]
5776
5777	[foo]: /url "title""#;
5778	let output = r#"<p><a href="/url" title="title">foo</a></p>"#;
5779	run(input, output);
5780	}
5781
5782	#[test]
5783	fn src_line_8367() {
5784	let input = r#"[foo bar]
5785
5786	[foo bar]: /url "title""#;
5787	let output = r#"<p><a href="/url" title="title"><em>foo</em> bar</a></p>"#;
5788	run(input, output);
5789	}
5790
5791	#[test]
5792	fn src_line_8376() {
5793	let input = r#"[[foo bar]]
5794
5795	[foo bar]: /url "title""#;
5796	let output = r#"<p>[<a href="/url" title="title"><em>foo</em> bar</a>]</p>"#;
5797	run(input, output);
5798	}
5799
5800	#[test]
5801	fn src_line_8385() {
5802	let input = r#"[[bar [foo]
5803
5804	[foo]: /url"#;
5805	let output = r#"<p>[[bar <a href="/url">foo</a></p>"#;
5806	run(input, output);
5807	}
5808
5809	#[test]
5810	fn src_line_8396() {
5811	let input = r#"[Foo]
5812
5813	[foo]: /url "title""#;
5814	let output = r#"<p><a href="/url" title="title">Foo</a></p>"#;
5815	run(input, output);
5816	}
5817
5818	#[test]
5819	fn src_line_8407() {
5820	let input = r#"[foo] bar
5821
5822	[foo]: /url"#;
5823	let output = r#"<p><a href="/url">foo</a> bar</p>"#;
5824	run(input, output);
5825	}
5826
5827	#[test]
5828	fn src_line_8419() {
5829	let input = r#"\[foo]
5830
5831	[foo]: /url "title""#;
5832	let output = r#"<p>[foo]</p>"#;
5833	run(input, output);
5834	}
5835
5836	#[test]
5837	fn src_line_8431() {
5838	let input = r#"[foo*]: /url
5839
5840	[foo]"#;
5841	let output = r#"<p><a href="/url">foo</a></p>"#;
5842	run(input, output);
5843	}
5844
5845	#[test]
5846	fn src_line_8443() {
5847	let input = r#"[foo][bar]
5848
5849	[foo]: /url1
5850	[bar]: /url2"#;
5851	let output = r#"<p><a href="/url2">foo</a></p>"#;
5852	run(input, output);
5853	}
5854
5855	#[test]
5856	fn src_line_8452() {
5857	let input = r#"[foo][]
5858
5859	[foo]: /url1"#;
5860	let output = r#"<p><a href="/url1">foo</a></p>"#;
5861	run(input, output);
5862	}
5863
5864	#[test]
5865	fn src_line_8462() {
5866	let input = r#"[foo]()
5867
5868	[foo]: /url1"#;
5869	let output = r#"<p><a href="">foo</a></p>"#;
5870	run(input, output);
5871	}
5872
5873	#[test]
5874	fn src_line_8470() {
5875	let input = r#"[foo](not a link)
5876
5877	[foo]: /url1"#;
5878	let output = r#"<p><a href="/url1">foo</a>(not a link)</p>"#;
5879	run(input, output);
5880	}
5881
5882	#[test]
5883	fn src_line_8481() {
5884	let input = r#"[foo][bar][baz]
5885
5886	[baz]: /url"#;
5887	let output = r#"<p>[foo]<a href="/url">bar</a></p>"#;
5888	run(input, output);
5889	}
5890
5891	#[test]
5892	fn src_line_8493() {
5893	let input = r#"[foo][bar][baz]
5894
5895	[baz]: /url1
5896	[bar]: /url2"#;
5897	let output = r#"<p><a href="/url2">foo</a><a href="/url1">baz</a></p>"#;
5898	run(input, output);
5899	}
5900
5901	#[test]
5902	fn src_line_8506() {
5903	let input = r#"[foo][bar][baz]
5904
5905	[baz]: /url1
5906	[foo]: /url2"#;
5907	let output = r#"<p>[foo]<a href="/url1">bar</a></p>"#;
5908	run(input, output);
5909	}
5910
5911	#[test]
5912	fn src_line_8529() {
5913	let input = r#"![foo](/url "title")"#;
5914	let output = r#"<p><img src="/url" alt="foo" title="title" /></p>"#;
5915	run(input, output);
5916	}
5917
5918	#[test]
5919	fn src_line_8536() {
5920	let input = r#"![foo bar]
5921
5922	[foo bar]: train.jpg "train & tracks""#;
5923	let output = r#"<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>"#;
5924	run(input, output);
5925	}
5926
5927	#[test]
5928	fn src_line_8545() {
5929	let input = r#"![foo ![bar](/url)](/url2)"#;
5930	let output = r#"<p><img src="/url2" alt="foo bar" /></p>"#;
5931	run(input, output);
5932	}
5933
5934	#[test]
5935	fn src_line_8552() {
5936	let input = r#"![foo [bar](/url)](/url2)"#;
5937	let output = r#"<p><img src="/url2" alt="foo bar" /></p>"#;
5938	run(input, output);
5939	}
5940
5941	#[test]
5942	fn src_line_8566() {
5943	let input = r#"![foo bar][]
5944
5945	[foo bar]: train.jpg "train & tracks""#;
5946	let output = r#"<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>"#;
5947	run(input, output);
5948	}
5949
5950	#[test]
5951	fn src_line_8575() {
5952	let input = r#"![foo bar][foobar]
5953
5954	[FOOBAR]: train.jpg "train & tracks""#;
5955	let output = r#"<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>"#;
5956	run(input, output);
5957	}
5958
5959	#[test]
5960	fn src_line_8584() {
5961	let input = r#"![foo](train.jpg)"#;
5962	let output = r#"<p><img src="train.jpg" alt="foo" /></p>"#;
5963	run(input, output);
5964	}
5965
5966	#[test]
5967	fn src_line_8591() {
5968	let input = r#"My ![foo bar](/path/to/train.jpg "title" )"#;
5969	let output = r#"<p>My <img src="/path/to/train.jpg" alt="foo bar" title="title" /></p>"#;
5970	run(input, output);
5971	}
5972
5973	#[test]
5974	fn src_line_8598() {
5975	let input = r#"![foo](<url>)"#;
5976	let output = r#"<p><img src="url" alt="foo" /></p>"#;
5977	run(input, output);
5978	}
5979
5980	#[test]
5981	fn src_line_8605() {
5982	let input = r#"![](/url)"#;
5983	let output = r#"<p><img src="/url" alt="" /></p>"#;
5984	run(input, output);
5985	}
5986
5987	#[test]
5988	fn src_line_8614() {
5989	let input = r#"![foo][bar]
5990
5991	[bar]: /url"#;
5992	let output = r#"<p><img src="/url" alt="foo" /></p>"#;
5993	run(input, output);
5994	}
5995
5996	#[test]
5997	fn src_line_8623() {
5998	let input = r#"![foo][bar]
5999
6000	[BAR]: /url"#;
6001	let output = r#"<p><img src="/url" alt="foo" /></p>"#;
6002	run(input, output);
6003	}
6004
6005	#[test]
6006	fn src_line_8634() {
6007	let input = r#"![foo][]
6008
6009	[foo]: /url "title""#;
6010	let output = r#"<p><img src="/url" alt="foo" title="title" /></p>"#;
6011	run(input, output);
6012	}
6013
6014	#[test]
6015	fn src_line_8643() {
6016	let input = r#"![foo bar][]
6017
6018	[foo bar]: /url "title""#;
6019	let output = r#"<p><img src="/url" alt="foo bar" title="title" /></p>"#;
6020	run(input, output);
6021	}
6022
6023	#[test]
6024	fn src_line_8654() {
6025	let input = r#"![Foo][]
6026
6027	[foo]: /url "title""#;
6028	let output = r#"<p><img src="/url" alt="Foo" title="title" /></p>"#;
6029	run(input, output);
6030	}
6031
6032	#[test]
6033	fn src_line_8666() {
6034	let input = "![foo]\x20
6035	[]
6036
6037	[foo]: /url \"title\"";
6038	let output = r#"<p><img src="/url" alt="foo" title="title" />
6039	[]</p>"#;
6040	run(input, output);
6041	}
6042
6043	#[test]
6044	fn src_line_8679() {
6045	let input = r#"![foo]
6046
6047	[foo]: /url "title""#;
6048	let output = r#"<p><img src="/url" alt="foo" title="title" /></p>"#;
6049	run(input, output);
6050	}
6051
6052	#[test]
6053	fn src_line_8688() {
6054	let input = r#"![foo bar]
6055
6056	[foo bar]: /url "title""#;
6057	let output = r#"<p><img src="/url" alt="foo bar" title="title" /></p>"#;
6058	run(input, output);
6059	}
6060
6061	#[test]
6062	fn src_line_8699() {
6063	let input = r#"![[foo]]
6064
6065	[[foo]]: /url "title""#;
6066	let output = r#"<p>![[foo]]</p>
6067	<p>[[foo]]: /url "title"</p>"#;
6068	run(input, output);
6069	}
6070
6071	#[test]
6072	fn src_line_8711() {
6073	let input = r#"![Foo]
6074
6075	[foo]: /url "title""#;
6076	let output = r#"<p><img src="/url" alt="Foo" title="title" /></p>"#;
6077	run(input, output);
6078	}
6079
6080	#[test]
6081	fn src_line_8723() {
6082	let input = r#"!\[foo]
6083
6084	[foo]: /url "title""#;
6085	let output = r#"<p>![foo]</p>"#;
6086	run(input, output);
6087	}
6088
6089	#[test]
6090	fn src_line_8735() {
6091	let input = r#"\![foo]
6092
6093	[foo]: /url "title""#;
6094	let output = r#"<p>!<a href="/url" title="title">foo</a></p>"#;
6095	run(input, output);
6096	}
6097
6098	#[test]
6099	fn src_line_8768() {
6100	let input = r#"<http://foo.bar.baz>"#;
6101	let output = r#"<p><a href="http://foo.bar.baz">http://foo.bar.baz</a></p>"#;
6102	run(input, output);
6103	}
6104
6105	#[test]
6106	fn src_line_8775() {
6107	let input = r#"<http://foo.bar.baz/test?q=hello&id=22&boolean>"#;
6108	let output = r#"<p><a href="http://foo.bar.baz/test?q=hello&id=22&boolean">http://foo.bar.baz/test?q=hello&id=22&boolean</a></p>"#;
6109	run(input, output);
6110	}
6111
6112	#[test]
6113	fn src_line_8782() {
6114	let input = r#"<irc://foo.bar:2233/baz>"#;
6115	let output = r#"<p><a href="irc://foo.bar:2233/baz">irc://foo.bar:2233/baz</a></p>"#;
6116	run(input, output);
6117	}
6118
6119	#[test]
6120	fn src_line_8791() {
6121	let input = r#"<MAILTO:FOO@BAR.BAZ>"#;
6122	let output = r#"<p><a href="MAILTO:FOO@BAR.BAZ">MAILTO:FOO@BAR.BAZ</a></p>"#;
6123	run(input, output);
6124	}
6125
6126	#[test]
6127	fn src_line_8803() {
6128	let input = r#"<a+b+c:d>"#;
6129	let output = r#"<p><a href="a+b+c:d">a+b+c:d</a></p>"#;
6130	run(input, output);
6131	}
6132
6133	#[test]
6134	fn src_line_8810() {
6135	let input = r#"<made-up-scheme://foo,bar>"#;
6136	let output = r#"<p><a href="made-up-scheme://foo,bar">made-up-scheme://foo,bar</a></p>"#;
6137	run(input, output);
6138	}
6139
6140	#[test]
6141	fn src_line_8817() {
6142	let input = r#"<http://../>"#;
6143	let output = r#"<p><a href="http://../">http://../</a></p>"#;
6144	run(input, output);
6145	}
6146
6147	#[test]
6148	fn src_line_8824() {
6149	let input = r#"<localhost:5001/foo>"#;
6150	let output = r#"<p><a href="localhost:5001/foo">localhost:5001/foo</a></p>"#;
6151	run(input, output);
6152	}
6153
6154	#[test]
6155	fn src_line_8833() {
6156	let input = r#"<http://foo.bar/baz bim>"#;
6157	let output = r#"<p><http://foo.bar/baz bim></p>"#;
6158	run(input, output);
6159	}
6160
6161	#[test]
6162	fn src_line_8842() {
6163	let input = r#"<http://example.com/\[\>"#;
6164	let output = r#"<p><a href="http://example.com/%5C%5B%5C">http://example.com/\[\</a></p>"#;
6165	run(input, output);
6166	}
6167
6168	#[test]
6169	fn src_line_8864() {
6170	let input = r#"<foo@bar.example.com>"#;
6171	let output = r#"<p><a href="mailto:foo@bar.example.com">foo@bar.example.com</a></p>"#;
6172	run(input, output);
6173	}
6174
6175	#[test]
6176	fn src_line_8871() {
6177	let input = r#"<foo+special@Bar.baz-bar0.com>"#;
6178	let output = r#"<p><a href="mailto:foo+special@Bar.baz-bar0.com">foo+special@Bar.baz-bar0.com</a></p>"#;
6179	run(input, output);
6180	}
6181
6182	#[test]
6183	fn src_line_8880() {
6184	let input = r#"<foo\+@bar.example.com>"#;
6185	let output = r#"<p><foo+@bar.example.com></p>"#;
6186	run(input, output);
6187	}
6188
6189	#[test]
6190	fn src_line_8889() {
6191	let input = r#"<>"#;
6192	let output = r#"<p><></p>"#;
6193	run(input, output);
6194	}
6195
6196	#[test]
6197	fn src_line_8896() {
6198	let input = r#"< http://foo.bar >"#;
6199	let output = r#"<p>< http://foo.bar ></p>"#;
6200	run(input, output);
6201	}
6202
6203	#[test]
6204	fn src_line_8903() {
6205	let input = r#"<m:abc>"#;
6206	let output = r#"<p><m:abc></p>"#;
6207	run(input, output);
6208	}
6209
6210	#[test]
6211	fn src_line_8910() {
6212	let input = r#"<foo.bar.baz>"#;
6213	let output = r#"<p><foo.bar.baz></p>"#;
6214	run(input, output);
6215	}
6216
6217	#[test]
6218	fn src_line_8917() {
6219	let input = r#"http://example.com"#;
6220	let output = r#"<p>http://example.com</p>"#;
6221	run(input, output);
6222	}
6223
6224	#[test]
6225	fn src_line_8924() {
6226	let input = r#"foo@bar.example.com"#;
6227	let output = r#"<p>foo@bar.example.com</p>"#;
6228	run(input, output);
6229	}
6230
6231	#[test]
6232	fn src_line_9005() {
6233	let input = r#"<a><bab><c2c>"#;
6234	let output = r#"<p><a><bab><c2c></p>"#;
6235	run(input, output);
6236	}
6237
6238	#[test]
6239	fn src_line_9014() {
6240	let input = r#"<a/><b2/>"#;
6241	let output = r#"<p><a/><b2/></p>"#;
6242	run(input, output);
6243	}
6244
6245	#[test]
6246	fn src_line_9023() {
6247	let input = r#"<a /><b2
6248	data="foo" >"#;
6249	let output = r#"<p><a /><b2
6250	data="foo" ></p>"#;
6251	run(input, output);
6252	}
6253
6254	#[test]
6255	fn src_line_9034() {
6256	let input = r#"<a foo="bar" bam = 'baz <em>"</em>'
6257	_boolean zoop:33=zoop:33 />"#;
6258	let output = r#"<p><a foo="bar" bam = 'baz <em>"</em>'
6259	_boolean zoop:33=zoop:33 /></p>"#;
6260	run(input, output);
6261	}
6262
6263	#[test]
6264	fn src_line_9045() {
6265	let input = r#"Foo <responsive-image src="foo.jpg" />"#;
6266	let output = r#"<p>Foo <responsive-image src="foo.jpg" /></p>"#;
6267	run(input, output);
6268	}
6269
6270	#[test]
6271	fn src_line_9054() {
6272	let input = r#"<33> <__>"#;
6273	let output = r#"<p><33> <__></p>"#;
6274	run(input, output);
6275	}
6276
6277	#[test]
6278	fn src_line_9063() {
6279	let input = r#"<a h*#ref="hi">"#;
6280	let output = r#"<p><a h*#ref="hi"></p>"#;
6281	run(input, output);
6282	}
6283
6284	#[test]
6285	fn src_line_9072() {
6286	let input = r#"<a href="hi'> <a href=hi'>"#;
6287	let output = r#"<p><a href="hi'> <a href=hi'></p>"#;
6288	run(input, output);
6289	}
6290
6291	#[test]
6292	fn src_line_9081() {
6293	let input = r#"< a><
6294	foo><bar/ >
6295	<foo bar=baz
6296	bim!bop />"#;
6297	let output = r#"<p>< a><
6298	foo><bar/ >
6299	<foo bar=baz
6300	bim!bop /></p>"#;
6301	run(input, output);
6302	}
6303
6304	#[test]
6305	fn src_line_9096() {
6306	let input = r#"<a href='bar'title=title>"#;
6307	let output = r#"<p><a href='bar'title=title></p>"#;
6308	run(input, output);
6309	}
6310
6311	#[test]
6312	fn src_line_9105() {
6313	let input = r#"</a></foo >"#;
6314	let output = r#"<p></a></foo ></p>"#;
6315	run(input, output);
6316	}
6317
6318	#[test]
6319	fn src_line_9114() {
6320	let input = r#"</a href="foo">"#;
6321	let output = r#"<p></a href="foo"></p>"#;
6322	run(input, output);
6323	}
6324
6325	#[test]
6326	fn src_line_9123() {
6327	let input = r#"foo <!-- this is a
6328	comment - with hyphen -->"#;
6329	let output = r#"<p>foo <!-- this is a
6330	comment - with hyphen --></p>"#;
6331	run(input, output);
6332	}
6333
6334	#[test]
6335	fn src_line_9132() {
6336	let input = r#"foo <!-- not a comment -- two hyphens -->"#;
6337	let output = r#"<p>foo <!-- not a comment -- two hyphens --></p>"#;
6338	run(input, output);
6339	}
6340
6341	#[test]
6342	fn src_line_9141() {
6343	let input = r#"foo <!--> foo -->
6344
6345	foo <!-- foo--->"#;
6346	let output = r#"<p>foo <!--> foo --></p>
6347	<p>foo <!-- foo---></p>"#;
6348	run(input, output);
6349	}
6350
6351	#[test]
6352	fn src_line_9153() {
6353	let input = r#"foo <?php echo $a; ?>"#;
6354	let output = r#"<p>foo <?php echo $a; ?></p>"#;
6355	run(input, output);
6356	}
6357
6358	#[test]
6359	fn src_line_9162() {
6360	let input = r#"foo <!ELEMENT br EMPTY>"#;
6361	let output = r#"<p>foo <!ELEMENT br EMPTY></p>"#;
6362	run(input, output);
6363	}
6364
6365	#[test]
6366	fn src_line_9171() {
6367	let input = r#"foo <![CDATA[>&<]]>"#;
6368	let output = r#"<p>foo <![CDATA[>&<]]></p>"#;
6369	run(input, output);
6370	}
6371
6372	#[test]
6373	fn src_line_9181() {
6374	let input = r#"foo <a href="ö">"#;
6375	let output = r#"<p>foo <a href="ö"></p>"#;
6376	run(input, output);
6377	}
6378
6379	#[test]
6380	fn src_line_9190() {
6381	let input = r#"foo <a href="\*">"#;
6382	let output = r#"<p>foo <a href="\*"></p>"#;
6383	run(input, output);
6384	}
6385
6386	#[test]
6387	fn src_line_9197() {
6388	let input = r#"<a href="\"">"#;
6389	let output = r#"<p><a href="""></p>"#;
6390	run(input, output);
6391	}
6392
6393	#[test]
6394	fn src_line_9211() {
6395	let input = "foo \x20
6396	baz";
6397	let output = r#"<p>foo<br />
6398	baz</p>"#;
6399	run(input, output);
6400	}
6401
6402	#[test]
6403	fn src_line_9223() {
6404	let input = r#"foo\
6405	baz"#;
6406	let output = r#"<p>foo<br />
6407	baz</p>"#;
6408	run(input, output);
6409	}
6410
6411	#[test]
6412	fn src_line_9234() {
6413	let input = "foo \x20
6414	baz";
6415	let output = r#"<p>foo<br />
6416	baz</p>"#;
6417	run(input, output);
6418	}
6419
6420	#[test]
6421	fn src_line_9245() {
6422	let input = "foo \x20
6423	bar";
6424	let output = r#"<p>foo<br />
6425	bar</p>"#;
6426	run(input, output);
6427	}
6428
6429	#[test]
6430	fn src_line_9254() {
6431	let input = r#"foo\
6432	bar"#;
6433	let output = r#"<p>foo<br />
6434	bar</p>"#;
6435	run(input, output);
6436	}
6437
6438	#[test]
6439	fn src_line_9266() {
6440	let input = "*foo \x20
6441	bar*";
6442	let output = r#"<p><em>foo<br />
6443	bar</em></p>"#;
6444	run(input, output);
6445	}
6446
6447	#[test]
6448	fn src_line_9275() {
6449	let input = r#"*foo\
6450	bar*"#;
6451	let output = r#"<p><em>foo<br />
6452	bar</em></p>"#;
6453	run(input, output);
6454	}
6455
6456	#[test]
6457	fn src_line_9286() {
6458	let input = "`code \x20
6459	span`";
6460	let output = r#"<p><code>code span</code></p>"#;
6461	run(input, output);
6462	}
6463
6464	#[test]
6465	fn src_line_9294() {
6466	let input = r#"`code\
6467	span`"#;
6468	let output = r#"<p><code>code\ span</code></p>"#;
6469	run(input, output);
6470	}
6471
6472	#[test]
6473	fn src_line_9304() {
6474	let input = "<a href=\"foo \x20
6475	bar\">";
6476	let output = "<p><a href=\"foo \x20
6477	bar\"></p>";
6478	run(input, output);
6479	}
6480
6481	#[test]
6482	fn src_line_9313() {
6483	let input = r#"<a href="foo\
6484	bar">"#;
6485	let output = r#"<p><a href="foo\
6486	bar"></p>"#;
6487	run(input, output);
6488	}
6489
6490	#[test]
6491	fn src_line_9326() {
6492	let input = r#"foo\"#;
6493	let output = r#"<p>foo\</p>"#;
6494	run(input, output);
6495	}
6496
6497	#[test]
6498	fn src_line_9333() {
6499	let input = "foo \x20";
6500	let output = r#"<p>foo</p>"#;
6501	run(input, output);
6502	}
6503
6504	#[test]
6505	fn src_line_9340() {
6506	let input = r#"### foo\"#;
6507	let output = r#"<h3>foo\</h3>"#;
6508	run(input, output);
6509	}
6510
6511	#[test]
6512	fn src_line_9347() {
6513	let input = "### foo \x20";
6514	let output = r#"<h3>foo</h3>"#;
6515	run(input, output);
6516	}
6517
6518	#[test]
6519	fn src_line_9362() {
6520	let input = r#"foo
6521	baz"#;
6522	let output = r#"<p>foo
6523	baz</p>"#;
6524	run(input, output);
6525	}
6526
6527	#[test]
6528	fn src_line_9374() {
6529	let input = "foo\x20
6530	baz";
6531	let output = r#"<p>foo
6532	baz</p>"#;
6533	run(input, output);
6534	}
6535
6536	#[test]
6537	fn src_line_9394() {
6538	let input = r#"hello $.;'there"#;
6539	let output = r#"<p>hello $.;'there</p>"#;
6540	run(input, output);
6541	}
6542
6543	#[test]
6544	fn src_line_9401() {
6545	let input = r#"Foo χρῆν"#;
6546	let output = r#"<p>Foo χρῆν</p>"#;
6547	run(input, output);
6548	}
6549
6550	#[test]
6551	fn src_line_9410() {
6552	let input = r#"Multiple spaces"#;
6553	let output = r#"<p>Multiple spaces</p>"#;
6554	run(input, output);
6555	}
6556	// end of auto-generated module
6557	}

crates/markdown-it/tests/extras.rs created+202

...	@@ -0,0 +1,202 @@
1	use once_cell::sync::Lazy;
2
3
4	#[test]
5	fn title_example() {
6	let parser = &mut markdown_it::MarkdownIt::new();
7	markdown_it::plugins::cmark::add(parser);
8
9	let ast = parser.parse("Hello world!");
10	let html = ast.render();
11
12	assert_eq!(html, "<p>Hello <strong>world</strong>!</p>\n");
13	}
14
15	#[test]
16	fn lazy_singleton() {
17	static MD : Lazy<markdown_it::MarkdownIt> = Lazy::new(\|\| {
18	let mut parser = markdown_it::MarkdownIt::new();
19	markdown_it::plugins::cmark::add(&mut parser);
20	parser
21	});
22
23	let ast = MD.parse("Hello world!");
24	let html = ast.render();
25
26	assert_eq!(html, "<p>Hello <strong>world</strong>!</p>\n");
27	}
28
29	#[test]
30	fn no_plugins() {
31	let md = &mut markdown_it::MarkdownIt::new();
32	let node = md.parse("hello\nworld");
33	let result = node.render();
34	assert_eq!(result, "hello\nworld\n");
35	}
36
37	#[test]
38	fn no_max_indent() {
39	let md = &mut markdown_it::MarkdownIt::new();
40	markdown_it::plugins::cmark::block::paragraph::add(md);
41	markdown_it::plugins::cmark::block::list::add(md);
42	md.max_indent = i32::MAX;
43	let node = md.parse(" paragraph\n - item");
44	let result = node.render();
45	assert_eq!(result, "<p>paragraph</p>\n<ul>\n<li>item</li>\n</ul>\n");
46	}
47
48
49	/*#[test]
50	fn no_block_parser() {
51	let md = &mut markdown_it::MarkdownIt::new();
52	markdown_it::plugins::cmark::add(md);
53	md.remove_rule::<markdown_it::parser::block::builtin::BlockParserRule>();
54	let node = md.parse("hello world");
55	let result = node.render();
56	assert_eq!(result, "hello <em>world</em>");
57	}*/
58
59	fn run(input: &str, output: &str) {
60	let output = if output.is_empty() { "".to_owned() } else { output.to_owned() + "\n" };
61	let md = &mut markdown_it::MarkdownIt::new();
62	markdown_it::plugins::cmark::add(md);
63	markdown_it::plugins::html::add(md);
64	markdown_it::plugins::extra::beautify_links::add(md);
65	let node = md.parse(&(input.to_owned() + "\n"));
66	node.walk(\|node, _\| assert!(node.srcmap.is_some()));
67	let result = node.render();
68	assert_eq!(result, output);
69	}
70
71	mod markdown_it_rs_extras {
72	use super::run;
73
74	#[test]
75	fn regression_test_img() {
76	// ! at end of line
77	run("Hello!", "<p>Hello!</p>");
78	}
79
80	#[test]
81	fn regression_list_markers() {
82	run("- foo\n- bar", "<ul>\n<li>foo</li>\n<li>bar</li>\n</ul>");
83	run("1. foo\n1. bar", "<ol>\n<li>foo</li>\n<li>bar</li>\n</ol>");
84	}
85
86	#[test]
87	fn tab_offset_in_lists() {
88	run(" > -\tfoo\n >\n > foo\n",
89	r#"<blockquote>
90	<ul>
91	<li>
92	<p>foo</p>
93	<pre><code> foo
94	</code></pre>
95	</li>
96	</ul>
97	</blockquote>"#);
98	}
99
100	#[test]
101	fn null_char_replacement() {
102	run("", "<p>\u{FFFD}</p>");
103	run("\0", "<p>\u{FFFD}</p>");
104	}
105
106	#[test]
107	fn cr_only_newlines() {
108	run("foo\rbar", "<p>foo\nbar</p>");
109	run(" foo\r bar", "<pre><code>foo\nbar\n</code></pre>");
110	}
111
112	#[test]
113	fn cr_lf_newlines() {
114	run("foo\r\nbar", "<p>foo\nbar</p>");
115	run(" foo\r\n bar", "<pre><code>foo\nbar\n</code></pre>");
116	}
117
118	#[test]
119	fn beautify_links() {
120	run("<https://www.reddit.com/r/programming/comments/vxttiq/comment/ifyqsqt/?utm_source=reddit&utm_medium=web2x&context=3>",
121	"<p><a href=\"https://www.reddit.com/r/programming/comments/vxttiq/comment/ifyqsqt/?utm_source=reddit&utm_medium=web2x&context=3\">www.reddit.com/r/programming/comments/…/ifyqsqt/?…</a></p>");
122	}
123
124	#[test]
125	fn regression_test_newlines_with_images() {
126	run("There is a newline in this image ![here\nit is](https://github.com/executablebooks/)",
127	"<p>There is a newline in this image <img src=\"https://github.com/executablebooks/\" alt=\"here\nit is\"></p>");
128	}
129
130	#[test]
131	fn test_node_ext_propagation() {
132	use markdown_it::parser::block::{BlockRule, BlockState};
133	use markdown_it::parser::core::CoreRule;
134	use markdown_it::parser::extset::NodeExt;
135	use markdown_it::parser::inline::{InlineRule, InlineState};
136	use markdown_it::{MarkdownIt, Node};
137
138	#[derive(Debug, Default)]
139	struct NodeErrors(Vec<&'static str>);
140	impl NodeExt for NodeErrors {}
141
142	struct MyInlineRule;
143	impl InlineRule for MyInlineRule {
144	const MARKER: char = '@';
145
146	fn run(state: &mut InlineState) -> Option<(Node, usize)> {
147	let err = state.node.ext.get_or_insert_default::<NodeErrors>();
148	err.0.push("inline");
149	None
150	}
151	}
152
153	struct MyBlockRule;
154	impl BlockRule for MyBlockRule {
155	fn run(state: &mut BlockState) -> Option<(Node, usize)> {
156	let err = state.node.ext.get_or_insert_default::<NodeErrors>();
157	err.0.push("block");
158	None
159	}
160	}
161
162	struct MyCoreRule;
163	impl CoreRule for MyCoreRule {
164	fn run(root: &mut Node, _md: &MarkdownIt) {
165	let err = root.ext.get_or_insert_default::<NodeErrors>();
166	err.0.push("core");
167	}
168	}
169
170	let md = &mut markdown_it::MarkdownIt::new();
171	markdown_it::plugins::cmark::add(md);
172
173	md.inline.add_rule::<MyInlineRule>();
174	md.block.add_rule::<MyBlockRule>();
175	md.add_rule::<MyCoreRule>().after_all();
176
177	let text1 = r#"hello @world"#;
178	let ast = md.parse(text1);
179	let mut collected: Vec<&str> = vec![];
180
181	ast.walk_post(\|node, _\| {
182	if let Some(errors) = node.ext.get::<NodeErrors>() {
183	collected.extend(errors.0.iter());
184	}
185	});
186
187	assert_eq!(
188	collected,
189	vec!["inline", "block", "core"],
190	);
191	}
192	}
193
194	mod examples {
195	include!("../examples/ferris/main.rs");
196
197	#[test]
198	fn test_examples() {
199	main();
200	}
201	}
202

crates/markdown-it/tests/fixtures/README.md created+28

...	@@ -0,0 +1,28 @@
1	This file generates tests for markdown-it rust library. It gets one argument
2	(file name) and edits that file in-place, replacing special markers inside
3	with tests generated from fixtures.
4
5	Run it like this from tests/ folder:
6	```sh
7	for I in *.rs ; do deno run --allow-read --allow-write ./fixtures/testgen.js $I ; done
8	```
9
10	As an example, it replaces this:
11	```rs
12	///////////////////////////////////////////////////////////////////////////
13	// TESTGEN: fixtures/commonmark/spec.txt
14	... any content here ...
15	///////////////////////////////////////////////////////////////////////////
16	```
17
18	With approximately this:
19	```rs
20	///////////////////////////////////////////////////////////////////////////
21	// TESTGEN: fixtures/commonmark/spec.txt
22	#[test]
23	fn line_123() {
24	run("foo", "<em>foo</em>");
25	}
26	... more tests here ...
27	///////////////////////////////////////////////////////////////////////////
28	```

crates/markdown-it/tests/fixtures/commonmark/bad.txt

crates/markdown-it/tests/fixtures/commonmark/good.txt created+7834

...	@@ -0,0 +1,7834 @@
1	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2	src line: 355
3
4	.
5	foo baz bim
6	.
7	<pre><code>foo baz bim
8	</code></pre>
9	.
10
11	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
12	src line: 362
13
14	.
15	foo baz bim
16	.
17	<pre><code>foo baz bim
18	</code></pre>
19	.
20
21	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
22	src line: 369
23
24	.
25	a a
26	ὐ a
27	.
28	<pre><code>a a
29	ὐ a
30	</code></pre>
31	.
32
33	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
34	src line: 382
35
36	.
37	- foo
38
39	bar
40	.
41	<ul>
42	<li>
43	<p>foo</p>
44	<p>bar</p>
45	</li>
46	</ul>
47	.
48
49	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
50	src line: 395
51
52	.
53	- foo
54
55	bar
56	.
57	<ul>
58	<li>
59	<p>foo</p>
60	<pre><code> bar
61	</code></pre>
62	</li>
63	</ul>
64	.
65
66	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
67	src line: 418
68
69	.
70	> foo
71	.
72	<blockquote>
73	<pre><code> foo
74	</code></pre>
75	</blockquote>
76	.
77
78	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
79	src line: 427
80
81	.
82	- foo
83	.
84	<ul>
85	<li>
86	<pre><code> foo
87	</code></pre>
88	</li>
89	</ul>
90	.
91
92	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
93	src line: 439
94
95	.
96	foo
97	bar
98	.
99	<pre><code>foo
100	bar
101	</code></pre>
102	.
103
104	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
105	src line: 448
106
107	.
108	- foo
109	- bar
110	- baz
111	.
112	<ul>
113	<li>foo
114	<ul>
115	<li>bar
116	<ul>
117	<li>baz</li>
118	</ul>
119	</li>
120	</ul>
121	</li>
122	</ul>
123	.
124
125	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
126	src line: 466
127
128	.
129	# Foo
130	.
131	<h1>Foo</h1>
132	.
133
134	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
135	src line: 472
136
137	.
138	* * *
139	.
140	<hr />
141	.
142
143	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
144	src line: 489
145
146	.
147	\!\"\#\$\%\&\'\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\\|\}\~
148	.
149	<p>!"#$%&'()*+,-./:;<=>?@[\]^_`{\|}~</p>
150	.
151
152	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
153	src line: 499
154
155	.
156	\ \A\a\ \3\φ\«
157	.
158	<p>\ \A\a\ \3\φ\«</p>
159	.
160
161	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
162	src line: 509
163
164	.
165	\not emphasized
166	\<br/> not a tag
167	\[not a link](/foo)
168	\`not code`
169	1\. not a list
170	\* not a list
171	\# not a heading
172	\[foo]: /url "not a reference"
173	\ö not a character entity
174	.
175	<p>not emphasized
176	<br/> not a tag
177	[not a link](/foo)
178	`not code`
179	1. not a list
180	* not a list
181	# not a heading
182	[foo]: /url "not a reference"
183	&ouml; not a character entity</p>
184	.
185
186	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
187	src line: 534
188
189	.
190	\\emphasis
191	.
192	<p>\<em>emphasis</em></p>
193	.
194
195	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
196	src line: 543
197
198	.
199	foo\
200	bar
201	.
202	<p>foo<br />
203	bar</p>
204	.
205
206	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
207	src line: 555
208
209	.
210	`` \[\` ``
211	.
212	<p><code>\[\`</code></p>
213	.
214
215	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
216	src line: 562
217
218	.
219	\[\]
220	.
221	<pre><code>\[\]
222	</code></pre>
223	.
224
225	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
226	src line: 570
227
228	.
229	~~~
230	\[\]
231	~~~
232	.
233	<pre><code>\[\]
234	</code></pre>
235	.
236
237	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
238	src line: 580
239
240	.
241	<http://example.com?find=\*>
242	.
243	<p><a href="http://example.com?find=%5C">http://example.com?find=\</a></p>
244	.
245
246	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
247	src line: 587
248
249	.
250	<a href="/bar\/)">
251	.
252	<a href="/bar\/)">
253	.
254
255	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
256	src line: 597
257
258	.
259	[foo](/bar\* "ti\*tle")
260	.
261	<p><a href="/bar" title="title">foo</a></p>
262	.
263
264	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
265	src line: 604
266
267	.
268	[foo]
269
270	[foo]: /bar\* "ti\*tle"
271	.
272	<p><a href="/bar" title="title">foo</a></p>
273	.
274
275	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
276	src line: 613
277
278	.
279	``` foo\+bar
280	foo
281	```
282	.
283	<pre><code class="language-foo+bar">foo
284	</code></pre>
285	.
286
287	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
288	src line: 649
289
290	.
291	& © Æ &Dcaron;
292	¾ &HilbertSpace; &DifferentialD;
293	&ClockwiseContourIntegral; &ngE;
294	.
295	<p> & © Æ Ď
296	¾ ℋ ⅆ
297	∲ ≧̸</p>
298	.
299
300	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
301	src line: 668
302
303	.
304	# Ӓ Ϡ
305	.
306	<p># Ӓ Ϡ �</p>
307	.
308
309	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
310	src line: 681
311
312	.
313	&#X22; &#XD06; ಫ
314	.
315	<p>" ആ ಫ</p>
316	.
317
318	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
319	src line: 690
320
321	.
322	&nbsp &x; &#; &#x;
323	&#87654321;
324	&#abcdef0;
325	&ThisIsNotDefined; &hi?;
326	.
327	<p>&nbsp &x; &#; &#x;
328	&#87654321;
329	&#abcdef0;
330	&ThisIsNotDefined; &hi?;</p>
331	.
332
333	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
334	src line: 707
335
336	.
337	&copy
338	.
339	<p>&copy</p>
340	.
341
342	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
343	src line: 717
344
345	.
346	&MadeUpEntity;
347	.
348	<p>&MadeUpEntity;</p>
349	.
350
351	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
352	src line: 728
353
354	.
355	<a href="öö.html">
356	.
357	<a href="öö.html">
358	.
359
360	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
361	src line: 735
362
363	.
364	[foo](/föö "föö")
365	.
366	<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
367	.
368
369	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
370	src line: 742
371
372	.
373	[foo]
374
375	[foo]: /föö "föö"
376	.
377	<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
378	.
379
380	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
381	src line: 751
382
383	.
384	``` föö
385	foo
386	```
387	.
388	<pre><code class="language-föö">foo
389	</code></pre>
390	.
391
392	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
393	src line: 764
394
395	.
396	`föö`
397	.
398	<p><code>f&ouml;&ouml;</code></p>
399	.
400
401	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
402	src line: 771
403
404	.
405	föfö
406	.
407	<pre><code>f&ouml;f&ouml;
408	</code></pre>
409	.
410
411	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
412	src line: 783
413
414	.
415	foo
416	foo
417	.
418	<p>foo
419	<em>foo</em></p>
420	.
421
422	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
423	src line: 791
424
425	.
426	* foo
427
428	* foo
429	.
430	<p>* foo</p>
431	<ul>
432	<li>foo</li>
433	</ul>
434	.
435
436	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
437	src line: 802
438
439	.
440	foo bar
441	.
442	<p>foo
443
444	bar</p>
445	.
446
447	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
448	src line: 810
449
450	.
451	foo
452	.
453	<p> foo</p>
454	.
455
456	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
457	src line: 817
458
459	.
460	[a](url "tit")
461	.
462	<p>[a](url "tit")</p>
463	.
464
465	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
466	src line: 840
467
468	.
469	- `one
470	- two`
471	.
472	<ul>
473	<li>`one</li>
474	<li>two`</li>
475	</ul>
476	.
477
478	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
479	src line: 879
480
481	.
482	***
483	---
484	___
485	.
486	<hr />
487	<hr />
488	<hr />
489	.
490
491	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
492	src line: 892
493
494	.
495	+++
496	.
497	<p>+++</p>
498	.
499
500	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
501	src line: 899
502
503	.
504	===
505	.
506	<p>===</p>
507	.
508
509	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
510	src line: 908
511
512	.
513	--
514	**
515	__
516	.
517	<p>--
518	**
519	__</p>
520	.
521
522	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
523	src line: 921
524
525	.
526	***
527	***
528	***
529	.
530	<hr />
531	<hr />
532	<hr />
533	.
534
535	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
536	src line: 934
537
538	.
539	***
540	.
541	<pre><code>***
542	</code></pre>
543	.
544
545	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
546	src line: 942
547
548	.
549	Foo
550	***
551	.
552	<p>Foo
553	***</p>
554	.
555
556	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
557	src line: 953
558
559	.
560	_____________________________________
561	.
562	<hr />
563	.
564
565	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
566	src line: 962
567
568	.
569	- - -
570	.
571	<hr />
572	.
573
574	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
575	src line: 969
576
577	.
578	** * ** * ** * **
579	.
580	<hr />
581	.
582
583	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
584	src line: 976
585
586	.
587	- - - -
588	.
589	<hr />
590	.
591
592	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
593	src line: 985
594
595	.
596	- - - -
597	.
598	<hr />
599	.
600
601	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
602	src line: 994
603
604	.
605	_ _ _ _ a
606
607	a------
608
609	---a---
610	.
611	<p>_ _ _ _ a</p>
612	<p>a------</p>
613	<p>---a---</p>
614	.
615
616	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
617	src line: 1010
618
619	.
620	-
621	.
622	<p><em>-</em></p>
623	.
624
625	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
626	src line: 1019
627
628	.
629	- foo
630	***
631	- bar
632	.
633	<ul>
634	<li>foo</li>
635	</ul>
636	<hr />
637	<ul>
638	<li>bar</li>
639	</ul>
640	.
641
642	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
643	src line: 1036
644
645	.
646	Foo
647	***
648	bar
649	.
650	<p>Foo</p>
651	<hr />
652	<p>bar</p>
653	.
654
655	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
656	src line: 1053
657
658	.
659	Foo
660	---
661	bar
662	.
663	<h2>Foo</h2>
664	<p>bar</p>
665	.
666
667	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
668	src line: 1066
669
670	.
671	* Foo
672	* * *
673	* Bar
674	.
675	<ul>
676	<li>Foo</li>
677	</ul>
678	<hr />
679	<ul>
680	<li>Bar</li>
681	</ul>
682	.
683
684	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
685	src line: 1083
686
687	.
688	- Foo
689	- * * *
690	.
691	<ul>
692	<li>Foo</li>
693	<li>
694	<hr />
695	</li>
696	</ul>
697	.
698
699	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
700	src line: 1112
701
702	.
703	# foo
704	## foo
705	### foo
706	#### foo
707	##### foo
708	###### foo
709	.
710	<h1>foo</h1>
711	<h2>foo</h2>
712	<h3>foo</h3>
713	<h4>foo</h4>
714	<h5>foo</h5>
715	<h6>foo</h6>
716	.
717
718	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
719	src line: 1131
720
721	.
722	####### foo
723	.
724	<p>####### foo</p>
725	.
726
727	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
728	src line: 1146
729
730	.
731	#5 bolt
732
733	#hashtag
734	.
735	<p>#5 bolt</p>
736	<p>#hashtag</p>
737	.
738
739	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
740	src line: 1158
741
742	.
743	\## foo
744	.
745	<p>## foo</p>
746	.
747
748	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
749	src line: 1167
750
751	.
752	# foo bar \baz\
753	.
754	<h1>foo <em>bar</em> baz</h1>
755	.
756
757	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
758	src line: 1176
759
760	.
761	# foo
762	.
763	<h1>foo</h1>
764	.
765
766	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
767	src line: 1185
768
769	.
770	### foo
771	## foo
772	# foo
773	.
774	<h3>foo</h3>
775	<h2>foo</h2>
776	<h1>foo</h1>
777	.
778
779	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
780	src line: 1198
781
782	.
783	# foo
784	.
785	<pre><code># foo
786	</code></pre>
787	.
788
789	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
790	src line: 1206
791
792	.
793	foo
794	# bar
795	.
796	<p>foo
797	# bar</p>
798	.
799
800	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
801	src line: 1217
802
803	.
804	## foo ##
805	### bar ###
806	.
807	<h2>foo</h2>
808	<h3>bar</h3>
809	.
810
811	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
812	src line: 1228
813
814	.
815	# foo ##################################
816	##### foo ##
817	.
818	<h1>foo</h1>
819	<h5>foo</h5>
820	.
821
822	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
823	src line: 1239
824
825	.
826	### foo ###
827	.
828	<h3>foo</h3>
829	.
830
831	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
832	src line: 1250
833
834	.
835	### foo ### b
836	.
837	<h3>foo ### b</h3>
838	.
839
840	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
841	src line: 1259
842
843	.
844	# foo#
845	.
846	<h1>foo#</h1>
847	.
848
849	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
850	src line: 1269
851
852	.
853	### foo \###
854	## foo #\##
855	# foo \#
856	.
857	<h3>foo ###</h3>
858	<h2>foo ###</h2>
859	<h1>foo #</h1>
860	.
861
862	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
863	src line: 1283
864
865	.
866	****
867	## foo
868	****
869	.
870	<hr />
871	<h2>foo</h2>
872	<hr />
873	.
874
875	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
876	src line: 1294
877
878	.
879	Foo bar
880	# baz
881	Bar foo
882	.
883	<p>Foo bar</p>
884	<h1>baz</h1>
885	<p>Bar foo</p>
886	.
887
888	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
889	src line: 1307
890
891	.
892	##
893	#
894	### ###
895	.
896	<h2></h2>
897	<h1></h1>
898	<h3></h3>
899	.
900
901	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
902	src line: 1350
903
904	.
905	Foo bar
906	=========
907
908	Foo bar
909	---------
910	.
911	<h1>Foo <em>bar</em></h1>
912	<h2>Foo <em>bar</em></h2>
913	.
914
915	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
916	src line: 1364
917
918	.
919	Foo *bar
920	baz*
921	====
922	.
923	<h1>Foo <em>bar
924	baz</em></h1>
925	.
926
927	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
928	src line: 1378
929
930	.
931	Foo *bar
932	baz*
933	====
934	.
935	<h1>Foo <em>bar
936	baz</em></h1>
937	.
938
939	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
940	src line: 1390
941
942	.
943	Foo
944	-------------------------
945
946	Foo
947	=
948	.
949	<h2>Foo</h2>
950	<h1>Foo</h1>
951	.
952
953	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
954	src line: 1405
955
956	.
957	Foo
958	---
959
960	Foo
961	-----
962
963	Foo
964	===
965	.
966	<h2>Foo</h2>
967	<h2>Foo</h2>
968	<h1>Foo</h1>
969	.
970
971	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
972	src line: 1423
973
974	.
975	Foo
976	---
977
978	Foo
979	---
980	.
981	<pre><code>Foo
982	---
983
984	Foo
985	</code></pre>
986	<hr />
987	.
988
989	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
990	src line: 1442
991
992	.
993	Foo
994	----
995	.
996	<h2>Foo</h2>
997	.
998
999	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1000	src line: 1452
1001
1002	.
1003	Foo
1004	---
1005	.
1006	<p>Foo
1007	---</p>
1008	.
1009
1010	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1011	src line: 1463
1012
1013	.
1014	Foo
1015	= =
1016
1017	Foo
1018	--- -
1019	.
1020	<p>Foo
1021	= =</p>
1022	<p>Foo</p>
1023	<hr />
1024	.
1025
1026	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1027	src line: 1479
1028
1029	.
1030	Foo
1031	-----
1032	.
1033	<h2>Foo</h2>
1034	.
1035
1036	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1037	src line: 1489
1038
1039	.
1040	Foo\
1041	----
1042	.
1043	<h2>Foo\</h2>
1044	.
1045
1046	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1047	src line: 1500
1048
1049	.
1050	`Foo
1051	----
1052	`
1053
1054	<a title="a lot
1055	---
1056	of dashes"/>
1057	.
1058	<h2>`Foo</h2>
1059	<p>`</p>
1060	<h2><a title="a lot</h2>
1061	<p>of dashes"/></p>
1062	.
1063
1064	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1065	src line: 1519
1066
1067	.
1068	> Foo
1069	---
1070	.
1071	<blockquote>
1072	<p>Foo</p>
1073	</blockquote>
1074	<hr />
1075	.
1076
1077	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1078	src line: 1530
1079
1080	.
1081	> foo
1082	bar
1083	===
1084	.
1085	<blockquote>
1086	<p>foo
1087	bar
1088	===</p>
1089	</blockquote>
1090	.
1091
1092	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1093	src line: 1543
1094
1095	.
1096	- Foo
1097	---
1098	.
1099	<ul>
1100	<li>Foo</li>
1101	</ul>
1102	<hr />
1103	.
1104
1105	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1106	src line: 1558
1107
1108	.
1109	Foo
1110	Bar
1111	---
1112	.
1113	<h2>Foo
1114	Bar</h2>
1115	.
1116
1117	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1118	src line: 1571
1119
1120	.
1121	---
1122	Foo
1123	---
1124	Bar
1125	---
1126	Baz
1127	.
1128	<hr />
1129	<h2>Foo</h2>
1130	<h2>Bar</h2>
1131	<p>Baz</p>
1132	.
1133
1134	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1135	src line: 1588
1136
1137	.
1138
1139	====
1140	.
1141	<p>====</p>
1142	.
1143
1144	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1145	src line: 1600
1146
1147	.
1148	---
1149	---
1150	.
1151	<hr />
1152	<hr />
1153	.
1154
1155	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1156	src line: 1609
1157
1158	.
1159	- foo
1160	-----
1161	.
1162	<ul>
1163	<li>foo</li>
1164	</ul>
1165	<hr />
1166	.
1167
1168	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1169	src line: 1620
1170
1171	.
1172	foo
1173	---
1174	.
1175	<pre><code>foo
1176	</code></pre>
1177	<hr />
1178	.
1179
1180	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1181	src line: 1630
1182
1183	.
1184	> foo
1185	-----
1186	.
1187	<blockquote>
1188	<p>foo</p>
1189	</blockquote>
1190	<hr />
1191	.
1192
1193	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1194	src line: 1644
1195
1196	.
1197	\> foo
1198	------
1199	.
1200	<h2>> foo</h2>
1201	.
1202
1203	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1204	src line: 1675
1205
1206	.
1207	Foo
1208
1209	bar
1210	---
1211	baz
1212	.
1213	<p>Foo</p>
1214	<h2>bar</h2>
1215	<p>baz</p>
1216	.
1217
1218	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1219	src line: 1691
1220
1221	.
1222	Foo
1223	bar
1224
1225	---
1226
1227	baz
1228	.
1229	<p>Foo
1230	bar</p>
1231	<hr />
1232	<p>baz</p>
1233	.
1234
1235	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1236	src line: 1709
1237
1238	.
1239	Foo
1240	bar
1241	* * *
1242	baz
1243	.
1244	<p>Foo
1245	bar</p>
1246	<hr />
1247	<p>baz</p>
1248	.
1249
1250	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1251	src line: 1724
1252
1253	.
1254	Foo
1255	bar
1256	\---
1257	baz
1258	.
1259	<p>Foo
1260	bar
1261	---
1262	baz</p>
1263	.
1264
1265	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1266	src line: 1752
1267
1268	.
1269	a simple
1270	indented code block
1271	.
1272	<pre><code>a simple
1273	indented code block
1274	</code></pre>
1275	.
1276
1277	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1278	src line: 1766
1279
1280	.
1281	- foo
1282
1283	bar
1284	.
1285	<ul>
1286	<li>
1287	<p>foo</p>
1288	<p>bar</p>
1289	</li>
1290	</ul>
1291	.
1292
1293	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1294	src line: 1780
1295
1296	.
1297	1. foo
1298
1299	- bar
1300	.
1301	<ol>
1302	<li>
1303	<p>foo</p>
1304	<ul>
1305	<li>bar</li>
1306	</ul>
1307	</li>
1308	</ol>
1309	.
1310
1311	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1312	src line: 1800
1313
1314	.
1315	<a/>
1316	hi
1317
1318	- one
1319	.
1320	<pre><code><a/>
1321	hi
1322
1323	- one
1324	</code></pre>
1325	.
1326
1327	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1328	src line: 1816
1329
1330	.
1331	chunk1
1332
1333	chunk2
1334
1335
1336
1337	chunk3
1338	.
1339	<pre><code>chunk1
1340
1341	chunk2
1342
1343
1344
1345	chunk3
1346	</code></pre>
1347	.
1348
1349	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1350	src line: 1839
1351
1352	.
1353	chunk1
1354
1355	chunk2
1356	.
1357	<pre><code>chunk1
1358
1359	chunk2
1360	</code></pre>
1361	.
1362
1363	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1364	src line: 1854
1365
1366	.
1367	Foo
1368	bar
1369
1370	.
1371	<p>Foo
1372	bar</p>
1373	.
1374
1375	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1376	src line: 1868
1377
1378	.
1379	foo
1380	bar
1381	.
1382	<pre><code>foo
1383	</code></pre>
1384	<p>bar</p>
1385	.
1386
1387	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1388	src line: 1881
1389
1390	.
1391	# Heading
1392	foo
1393	Heading
1394	------
1395	foo
1396	----
1397	.
1398	<h1>Heading</h1>
1399	<pre><code>foo
1400	</code></pre>
1401	<h2>Heading</h2>
1402	<pre><code>foo
1403	</code></pre>
1404	<hr />
1405	.
1406
1407	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1408	src line: 1901
1409
1410	.
1411	foo
1412	bar
1413	.
1414	<pre><code> foo
1415	bar
1416	</code></pre>
1417	.
1418
1419	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1420	src line: 1914
1421
1422	.
1423
1424
1425	foo
1426
1427
1428	.
1429	<pre><code>foo
1430	</code></pre>
1431	.
1432
1433	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1434	src line: 1928
1435
1436	.
1437	foo
1438	.
1439	<pre><code>foo
1440	</code></pre>
1441	.
1442
1443	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1444	src line: 1983
1445
1446	.
1447	```
1448	<
1449	>
1450	```
1451	.
1452	<pre><code><
1453	>
1454	</code></pre>
1455	.
1456
1457	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1458	src line: 1997
1459
1460	.
1461	~~~
1462	<
1463	>
1464	~~~
1465	.
1466	<pre><code><
1467	>
1468	</code></pre>
1469	.
1470
1471	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1472	src line: 2010
1473
1474	.
1475	``
1476	foo
1477	``
1478	.
1479	<p><code>foo</code></p>
1480	.
1481
1482	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1483	src line: 2021
1484
1485	.
1486	```
1487	aaa
1488	~~~
1489	```
1490	.
1491	<pre><code>aaa
1492	~~~
1493	</code></pre>
1494	.
1495
1496	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1497	src line: 2033
1498
1499	.
1500	~~~
1501	aaa
1502	```
1503	~~~
1504	.
1505	<pre><code>aaa
1506	```
1507	</code></pre>
1508	.
1509
1510	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1511	src line: 2047
1512
1513	.
1514	````
1515	aaa
1516	```
1517	``````
1518	.
1519	<pre><code>aaa
1520	```
1521	</code></pre>
1522	.
1523
1524	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1525	src line: 2059
1526
1527	.
1528	~~~~
1529	aaa
1530	~~~
1531	~~~~
1532	.
1533	<pre><code>aaa
1534	~~~
1535	</code></pre>
1536	.
1537
1538	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1539	src line: 2074
1540
1541	.
1542	```
1543	.
1544	<pre><code></code></pre>
1545	.
1546
1547	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1548	src line: 2081
1549
1550	.
1551	`````
1552
1553	```
1554	aaa
1555	.
1556	<pre><code>
1557	```
1558	aaa
1559	</code></pre>
1560	.
1561
1562	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1563	src line: 2094
1564
1565	.
1566	> ```
1567	> aaa
1568
1569	bbb
1570	.
1571	<blockquote>
1572	<pre><code>aaa
1573	</code></pre>
1574	</blockquote>
1575	<p>bbb</p>
1576	.
1577
1578	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1579	src line: 2110
1580
1581	.
1582	```
1583
1584
1585	```
1586	.
1587	<pre><code>
1588
1589	</code></pre>
1590	.
1591
1592	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1593	src line: 2124
1594
1595	.
1596	```
1597	```
1598	.
1599	<pre><code></code></pre>
1600	.
1601
1602	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1603	src line: 2136
1604
1605	.
1606	```
1607	aaa
1608	aaa
1609	```
1610	.
1611	<pre><code>aaa
1612	aaa
1613	</code></pre>
1614	.
1615
1616	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1617	src line: 2148
1618
1619	.
1620	```
1621	aaa
1622	aaa
1623	aaa
1624	```
1625	.
1626	<pre><code>aaa
1627	aaa
1628	aaa
1629	</code></pre>
1630	.
1631
1632	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1633	src line: 2162
1634
1635	.
1636	```
1637	aaa
1638	aaa
1639	aaa
1640	```
1641	.
1642	<pre><code>aaa
1643	aaa
1644	aaa
1645	</code></pre>
1646	.
1647
1648	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1649	src line: 2178
1650
1651	.
1652	```
1653	aaa
1654	```
1655	.
1656	<pre><code>```
1657	aaa
1658	```
1659	</code></pre>
1660	.
1661
1662	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1663	src line: 2193
1664
1665	.
1666	```
1667	aaa
1668	```
1669	.
1670	<pre><code>aaa
1671	</code></pre>
1672	.
1673
1674	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1675	src line: 2203
1676
1677	.
1678	```
1679	aaa
1680	```
1681	.
1682	<pre><code>aaa
1683	</code></pre>
1684	.
1685
1686	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1687	src line: 2215
1688
1689	.
1690	```
1691	aaa
1692	```
1693	.
1694	<pre><code>aaa
1695	```
1696	</code></pre>
1697	.
1698
1699	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1700	src line: 2229
1701
1702	.
1703	``` ```
1704	aaa
1705	.
1706	<p><code> </code>
1707	aaa</p>
1708	.
1709
1710	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1711	src line: 2238
1712
1713	.
1714	~~~~~~
1715	aaa
1716	~~~ ~~
1717	.
1718	<pre><code>aaa
1719	~~~ ~~
1720	</code></pre>
1721	.
1722
1723	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1724	src line: 2252
1725
1726	.
1727	foo
1728	```
1729	bar
1730	```
1731	baz
1732	.
1733	<p>foo</p>
1734	<pre><code>bar
1735	</code></pre>
1736	<p>baz</p>
1737	.
1738
1739	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1740	src line: 2269
1741
1742	.
1743	foo
1744	---
1745	~~~
1746	bar
1747	~~~
1748	# baz
1749	.
1750	<h2>foo</h2>
1751	<pre><code>bar
1752	</code></pre>
1753	<h1>baz</h1>
1754	.
1755
1756	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1757	src line: 2291
1758
1759	.
1760	```ruby
1761	def foo(x)
1762	return 3
1763	end
1764	```
1765	.
1766	<pre><code class="language-ruby">def foo(x)
1767	return 3
1768	end
1769	</code></pre>
1770	.
1771
1772	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1773	src line: 2305
1774
1775	.
1776	~~~~ ruby startline=3 $%@#$
1777	def foo(x)
1778	return 3
1779	end
1780	~~~~~~~
1781	.
1782	<pre><code class="language-ruby">def foo(x)
1783	return 3
1784	end
1785	</code></pre>
1786	.
1787
1788	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1789	src line: 2319
1790
1791	.
1792	````;
1793	````
1794	.
1795	<pre><code class="language-;"></code></pre>
1796	.
1797
1798	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1799	src line: 2329
1800
1801	.
1802	``` aa ```
1803	foo
1804	.
1805	<p><code>aa</code>
1806	foo</p>
1807	.
1808
1809	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1810	src line: 2340
1811
1812	.
1813	~~~ aa ``` ~~~
1814	foo
1815	~~~
1816	.
1817	<pre><code class="language-aa">foo
1818	</code></pre>
1819	.
1820
1821	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1822	src line: 2352
1823
1824	.
1825	```
1826	``` aaa
1827	```
1828	.
1829	<pre><code>``` aaa
1830	</code></pre>
1831	.
1832
1833	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1834	src line: 2431
1835
1836	.
1837	<table><tr><td>
1838	<pre>
1839	Hello,
1840
1841	_world_.
1842	</pre>
1843	</td></tr></table>
1844	.
1845	<table><tr><td>
1846	<pre>
1847	Hello,
1848	<p><em>world</em>.
1849	</pre></p>
1850	</td></tr></table>
1851	.
1852
1853	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1854	src line: 2460
1855
1856	.
1857	<table>
1858	<tr>
1859	<td>
1860	hi
1861	</td>
1862	</tr>
1863	</table>
1864
1865	okay.
1866	.
1867	<table>
1868	<tr>
1869	<td>
1870	hi
1871	</td>
1872	</tr>
1873	</table>
1874	<p>okay.</p>
1875	.
1876
1877	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1878	src line: 2482
1879
1880	.
1881	<div>
1882	hello
1883	<foo><a>
1884	.
1885	<div>
1886	hello
1887	<foo><a>
1888	.
1889
1890	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1891	src line: 2495
1892
1893	.
1894	</div>
1895	foo
1896	.
1897	</div>
1898	foo
1899	.
1900
1901	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1902	src line: 2506
1903
1904	.
1905	<DIV CLASS="foo">
1906
1907	Markdown
1908
1909	</DIV>
1910	.
1911	<DIV CLASS="foo">
1912	<p><em>Markdown</em></p>
1913	</DIV>
1914	.
1915
1916	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1917	src line: 2522
1918
1919	.
1920	<div id="foo"
1921	class="bar">
1922	</div>
1923	.
1924	<div id="foo"
1925	class="bar">
1926	</div>
1927	.
1928
1929	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1930	src line: 2533
1931
1932	.
1933	<div id="foo" class="bar
1934	baz">
1935	</div>
1936	.
1937	<div id="foo" class="bar
1938	baz">
1939	</div>
1940	.
1941
1942	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1943	src line: 2545
1944
1945	.
1946	<div>
1947	foo
1948
1949	bar
1950	.
1951	<div>
1952	foo
1953	<p><em>bar</em></p>
1954	.
1955
1956	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1957	src line: 2561
1958
1959	.
1960	<div id="foo"
1961	hi
1962	.
1963	<div id="foo"
1964	hi
1965	.
1966
1967	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1968	src line: 2570
1969
1970	.
1971	<div class
1972	foo
1973	.
1974	<div class
1975	foo
1976	.
1977
1978	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1979	src line: 2582
1980
1981	.
1982	<div *???-&&&-<---
1983	foo
1984	.
1985	<div *???-&&&-<---
1986	foo
1987	.
1988
1989	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1990	src line: 2594
1991
1992	.
1993	<div><a href="bar">foo</a></div>
1994	.
1995	<div><a href="bar">foo</a></div>
1996	.
1997
1998	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1999	src line: 2601
2000
2001	.
2002	<table><tr><td>
2003	foo
2004	</td></tr></table>
2005	.
2006	<table><tr><td>
2007	foo
2008	</td></tr></table>
2009	.
2010
2011	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2012	src line: 2618
2013
2014	.
2015	<div></div>
2016	``` c
2017	int x = 33;
2018	```
2019	.
2020	<div></div>
2021	``` c
2022	int x = 33;
2023	```
2024	.
2025
2026	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2027	src line: 2635
2028
2029	.
2030	<a href="foo">
2031	bar
2032	</a>
2033	.
2034	<a href="foo">
2035	bar
2036	</a>
2037	.
2038
2039	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2040	src line: 2648
2041
2042	.
2043	<Warning>
2044	bar
2045	</Warning>
2046	.
2047	<Warning>
2048	bar
2049	</Warning>
2050	.
2051
2052	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2053	src line: 2659
2054
2055	.
2056	<i class="foo">
2057	bar
2058	</i>
2059	.
2060	<i class="foo">
2061	bar
2062	</i>
2063	.
2064
2065	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2066	src line: 2670
2067
2068	.
2069	</ins>
2070	bar
2071	.
2072	</ins>
2073	bar
2074	.
2075
2076	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2077	src line: 2685
2078
2079	.
2080	<del>
2081	foo
2082	</del>
2083	.
2084	<del>
2085	foo
2086	</del>
2087	.
2088
2089	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2090	src line: 2700
2091
2092	.
2093	<del>
2094
2095	foo
2096
2097	</del>
2098	.
2099	<del>
2100	<p><em>foo</em></p>
2101	</del>
2102	.
2103
2104	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2105	src line: 2718
2106
2107	.
2108	<del>foo</del>
2109	.
2110	<p><del><em>foo</em></del></p>
2111	.
2112
2113	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2114	src line: 2734
2115
2116	.
2117	<pre language="haskell"><code>
2118	import Text.HTML.TagSoup
2119
2120	main :: IO ()
2121	main = print $ parseTags tags
2122	</code></pre>
2123	okay
2124	.
2125	<pre language="haskell"><code>
2126	import Text.HTML.TagSoup
2127
2128	main :: IO ()
2129	main = print $ parseTags tags
2130	</code></pre>
2131	<p>okay</p>
2132	.
2133
2134	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2135	src line: 2755
2136
2137	.
2138	<script type="text/javascript">
2139	// JavaScript example
2140
2141	document.getElementById("demo").innerHTML = "Hello JavaScript!";
2142	</script>
2143	okay
2144	.
2145	<script type="text/javascript">
2146	// JavaScript example
2147
2148	document.getElementById("demo").innerHTML = "Hello JavaScript!";
2149	</script>
2150	<p>okay</p>
2151	.
2152
2153	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2154	src line: 2774
2155
2156	.
2157	<textarea>
2158
2159	foo
2160
2161	_bar_
2162
2163	</textarea>
2164	.
2165	<textarea>
2166
2167	foo
2168
2169	_bar_
2170
2171	</textarea>
2172	.
2173
2174	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2175	src line: 2794
2176
2177	.
2178	<style
2179	type="text/css">
2180	h1 {color:red;}
2181
2182	p {color:blue;}
2183	</style>
2184	okay
2185	.
2186	<style
2187	type="text/css">
2188	h1 {color:red;}
2189
2190	p {color:blue;}
2191	</style>
2192	<p>okay</p>
2193	.
2194
2195	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2196	src line: 2817
2197
2198	.
2199	<style
2200	type="text/css">
2201
2202	foo
2203	.
2204	<style
2205	type="text/css">
2206
2207	foo
2208	.
2209
2210	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2211	src line: 2830
2212
2213	.
2214	> <div>
2215	> foo
2216
2217	bar
2218	.
2219	<blockquote>
2220	<div>
2221	foo
2222	</blockquote>
2223	<p>bar</p>
2224	.
2225
2226	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2227	src line: 2844
2228
2229	.
2230	- <div>
2231	- foo
2232	.
2233	<ul>
2234	<li>
2235	<div>
2236	</li>
2237	<li>foo</li>
2238	</ul>
2239	.
2240
2241	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2242	src line: 2859
2243
2244	.
2245	<style>p{color:red;}</style>
2246	foo
2247	.
2248	<style>p{color:red;}</style>
2249	<p><em>foo</em></p>
2250	.
2251
2252	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2253	src line: 2868
2254
2255	.
2256	<!-- foo -->bar
2257	baz
2258	.
2259	<!-- foo -->bar
2260	<p><em>baz</em></p>
2261	.
2262
2263	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2264	src line: 2880
2265
2266	.
2267	<script>
2268	foo
2269	</script>1. bar
2270	.
2271	<script>
2272	foo
2273	</script>1. bar
2274	.
2275
2276	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2277	src line: 2893
2278
2279	.
2280	<!-- Foo
2281
2282	bar
2283	baz -->
2284	okay
2285	.
2286	<!-- Foo
2287
2288	bar
2289	baz -->
2290	<p>okay</p>
2291	.
2292
2293	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2294	src line: 2911
2295
2296	.
2297	<?php
2298
2299	echo '>';
2300
2301	?>
2302	okay
2303	.
2304	<?php
2305
2306	echo '>';
2307
2308	?>
2309	<p>okay</p>
2310	.
2311
2312	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2313	src line: 2930
2314
2315	.
2316	<!DOCTYPE html>
2317	.
2318	<!DOCTYPE html>
2319	.
2320
2321	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2322	src line: 2939
2323
2324	.
2325	<![CDATA[
2326	function matchwo(a,b)
2327	{
2328	if (a < b && a < 0) then {
2329	return 1;
2330
2331	} else {
2332
2333	return 0;
2334	}
2335	}
2336	]]>
2337	okay
2338	.
2339	<![CDATA[
2340	function matchwo(a,b)
2341	{
2342	if (a < b && a < 0) then {
2343	return 1;
2344
2345	} else {
2346
2347	return 0;
2348	}
2349	}
2350	]]>
2351	<p>okay</p>
2352	.
2353
2354	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2355	src line: 2973
2356
2357	.
2358	<!-- foo -->
2359
2360	<!-- foo -->
2361	.
2362	<!-- foo -->
2363	<pre><code><!-- foo -->
2364	</code></pre>
2365	.
2366
2367	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2368	src line: 2984
2369
2370	.
2371	<div>
2372
2373	<div>
2374	.
2375	<div>
2376	<pre><code><div>
2377	</code></pre>
2378	.
2379
2380	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2381	src line: 2998
2382
2383	.
2384	Foo
2385	<div>
2386	bar
2387	</div>
2388	.
2389	<p>Foo</p>
2390	<div>
2391	bar
2392	</div>
2393	.
2394
2395	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2396	src line: 3015
2397
2398	.
2399	<div>
2400	bar
2401	</div>
2402	foo
2403	.
2404	<div>
2405	bar
2406	</div>
2407	foo
2408	.
2409
2410	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2411	src line: 3030
2412
2413	.
2414	Foo
2415	<a href="bar">
2416	baz
2417	.
2418	<p>Foo
2419	<a href="bar">
2420	baz</p>
2421	.
2422
2423	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2424	src line: 3071
2425
2426	.
2427	<div>
2428
2429	Emphasized text.
2430
2431	</div>
2432	.
2433	<div>
2434	<p><em>Emphasized</em> text.</p>
2435	</div>
2436	.
2437
2438	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2439	src line: 3084
2440
2441	.
2442	<div>
2443	Emphasized text.
2444	</div>
2445	.
2446	<div>
2447	Emphasized text.
2448	</div>
2449	.
2450
2451	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2452	src line: 3106
2453
2454	.
2455	<table>
2456
2457	<tr>
2458
2459	<td>
2460	Hi
2461	</td>
2462
2463	</tr>
2464
2465	</table>
2466	.
2467	<table>
2468	<tr>
2469	<td>
2470	Hi
2471	</td>
2472	</tr>
2473	</table>
2474	.
2475
2476	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2477	src line: 3133
2478
2479	.
2480	<table>
2481
2482	<tr>
2483
2484	<td>
2485	Hi
2486	</td>
2487
2488	</tr>
2489
2490	</table>
2491	.
2492	<table>
2493	<tr>
2494	<pre><code><td>
2495	Hi
2496	</td>
2497	</code></pre>
2498	</tr>
2499	</table>
2500	.
2501
2502	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2503	src line: 3182
2504
2505	.
2506	[foo]: /url "title"
2507
2508	[foo]
2509	.
2510	<p><a href="/url" title="title">foo</a></p>
2511	.
2512
2513	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2514	src line: 3191
2515
2516	.
2517	[foo]:
2518	/url
2519	'the title'
2520
2521	[foo]
2522	.
2523	<p><a href="/url" title="the title">foo</a></p>
2524	.
2525
2526	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2527	src line: 3202
2528
2529	.
2530	[Foo*bar\]]:my_(url) 'title (with parens)'
2531
2532	[Foo*bar\]]
2533	.
2534	<p><a href="my_(url)" title="title (with parens)">Foo*bar]</a></p>
2535	.
2536
2537	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2538	src line: 3211
2539
2540	.
2541	[Foo bar]:
2542	<my url>
2543	'title'
2544
2545	[Foo bar]
2546	.
2547	<p><a href="my%20url" title="title">Foo bar</a></p>
2548	.
2549
2550	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2551	src line: 3224
2552
2553	.
2554	[foo]: /url '
2555	title
2556	line1
2557	line2
2558	'
2559
2560	[foo]
2561	.
2562	<p><a href="/url" title="
2563	title
2564	line1
2565	line2
2566	">foo</a></p>
2567	.
2568
2569	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2570	src line: 3243
2571
2572	.
2573	[foo]: /url 'title
2574
2575	with blank line'
2576
2577	[foo]
2578	.
2579	<p>[foo]: /url 'title</p>
2580	<p>with blank line'</p>
2581	<p>[foo]</p>
2582	.
2583
2584	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2585	src line: 3258
2586
2587	.
2588	[foo]:
2589	/url
2590
2591	[foo]
2592	.
2593	<p><a href="/url">foo</a></p>
2594	.
2595
2596	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2597	src line: 3270
2598
2599	.
2600	[foo]:
2601
2602	[foo]
2603	.
2604	<p>[foo]:</p>
2605	<p>[foo]</p>
2606	.
2607
2608	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2609	src line: 3282
2610
2611	.
2612	[foo]: <>
2613
2614	[foo]
2615	.
2616	<p><a href="">foo</a></p>
2617	.
2618
2619	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2620	src line: 3293
2621
2622	.
2623	[foo]: <bar>(baz)
2624
2625	[foo]
2626	.
2627	<p>[foo]: <bar>(baz)</p>
2628	<p>[foo]</p>
2629	.
2630
2631	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2632	src line: 3306
2633
2634	.
2635	[foo]: /url\bar\*baz "foo\"bar\baz"
2636
2637	[foo]
2638	.
2639	<p><a href="/url%5Cbar*baz" title="foo"bar\baz">foo</a></p>
2640	.
2641
2642	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2643	src line: 3317
2644
2645	.
2646	[foo]
2647
2648	[foo]: url
2649	.
2650	<p><a href="url">foo</a></p>
2651	.
2652
2653	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2654	src line: 3329
2655
2656	.
2657	[foo]
2658
2659	[foo]: first
2660	[foo]: second
2661	.
2662	<p><a href="first">foo</a></p>
2663	.
2664
2665	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2666	src line: 3342
2667
2668	.
2669	[FOO]: /url
2670
2671	[Foo]
2672	.
2673	<p><a href="/url">Foo</a></p>
2674	.
2675
2676	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2677	src line: 3351
2678
2679	.
2680	[ΑΓΩ]: /φου
2681
2682	[αγω]
2683	.
2684	<p><a href="/%CF%86%CE%BF%CF%85">αγω</a></p>
2685	.
2686
2687	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2688	src line: 3366
2689
2690	.
2691	[foo]: /url
2692	.
2693	.
2694
2695	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2696	src line: 3374
2697
2698	.
2699	[
2700	foo
2701	]: /url
2702	bar
2703	.
2704	<p>bar</p>
2705	.
2706
2707	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2708	src line: 3387
2709
2710	.
2711	[foo]: /url "title" ok
2712	.
2713	<p>[foo]: /url "title" ok</p>
2714	.
2715
2716	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2717	src line: 3396
2718
2719	.
2720	[foo]: /url
2721	"title" ok
2722	.
2723	<p>"title" ok</p>
2724	.
2725
2726	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2727	src line: 3407
2728
2729	.
2730	[foo]: /url "title"
2731
2732	[foo]
2733	.
2734	<pre><code>[foo]: /url "title"
2735	</code></pre>
2736	<p>[foo]</p>
2737	.
2738
2739	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2740	src line: 3421
2741
2742	.
2743	```
2744	[foo]: /url
2745	```
2746
2747	[foo]
2748	.
2749	<pre><code>[foo]: /url
2750	</code></pre>
2751	<p>[foo]</p>
2752	.
2753
2754	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2755	src line: 3436
2756
2757	.
2758	Foo
2759	[bar]: /baz
2760
2761	[bar]
2762	.
2763	<p>Foo
2764	[bar]: /baz</p>
2765	<p>[bar]</p>
2766	.
2767
2768	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2769	src line: 3451
2770
2771	.
2772	# [Foo]
2773	[foo]: /url
2774	> bar
2775	.
2776	<h1><a href="/url">Foo</a></h1>
2777	<blockquote>
2778	<p>bar</p>
2779	</blockquote>
2780	.
2781
2782	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2783	src line: 3462
2784
2785	.
2786	[foo]: /url
2787	bar
2788	===
2789	[foo]
2790	.
2791	<h1>bar</h1>
2792	<p><a href="/url">foo</a></p>
2793	.
2794
2795	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2796	src line: 3472
2797
2798	.
2799	[foo]: /url
2800	===
2801	[foo]
2802	.
2803	<p>===
2804	<a href="/url">foo</a></p>
2805	.
2806
2807	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2808	src line: 3485
2809
2810	.
2811	[foo]: /foo-url "foo"
2812	[bar]: /bar-url
2813	"bar"
2814	[baz]: /baz-url
2815
2816	[foo],
2817	[bar],
2818	[baz]
2819	.
2820	<p><a href="/foo-url" title="foo">foo</a>,
2821	<a href="/bar-url" title="bar">bar</a>,
2822	<a href="/baz-url">baz</a></p>
2823	.
2824
2825	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2826	src line: 3506
2827
2828	.
2829	[foo]
2830
2831	> [foo]: /url
2832	.
2833	<p><a href="/url">foo</a></p>
2834	<blockquote>
2835	</blockquote>
2836	.
2837
2838	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2839	src line: 3528
2840
2841	.
2842	aaa
2843
2844	bbb
2845	.
2846	<p>aaa</p>
2847	<p>bbb</p>
2848	.
2849
2850	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2851	src line: 3540
2852
2853	.
2854	aaa
2855	bbb
2856
2857	ccc
2858	ddd
2859	.
2860	<p>aaa
2861	bbb</p>
2862	<p>ccc
2863	ddd</p>
2864	.
2865
2866	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2867	src line: 3556
2868
2869	.
2870	aaa
2871
2872
2873	bbb
2874	.
2875	<p>aaa</p>
2876	<p>bbb</p>
2877	.
2878
2879	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2880	src line: 3569
2881
2882	.
2883	aaa
2884	bbb
2885	.
2886	<p>aaa
2887	bbb</p>
2888	.
2889
2890	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2891	src line: 3581
2892
2893	.
2894	aaa
2895	bbb
2896	ccc
2897	.
2898	<p>aaa
2899	bbb
2900	ccc</p>
2901	.
2902
2903	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2904	src line: 3595
2905
2906	.
2907	aaa
2908	bbb
2909	.
2910	<p>aaa
2911	bbb</p>
2912	.
2913
2914	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2915	src line: 3604
2916
2917	.
2918	aaa
2919	bbb
2920	.
2921	<pre><code>aaa
2922	</code></pre>
2923	<p>bbb</p>
2924	.
2925
2926	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2927	src line: 3618
2928
2929	.
2930	aaa
2931	bbb
2932	.
2933	<p>aaa<br />
2934	bbb</p>
2935	.
2936
2937	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2938	src line: 3635
2939
2940	.
2941
2942
2943	aaa
2944
2945
2946	# aaa
2947
2948
2949	.
2950	<p>aaa</p>
2951	<h1>aaa</h1>
2952	.
2953
2954	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2955	src line: 3703
2956
2957	.
2958	> # Foo
2959	> bar
2960	> baz
2961	.
2962	<blockquote>
2963	<h1>Foo</h1>
2964	<p>bar
2965	baz</p>
2966	</blockquote>
2967	.
2968
2969	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2970	src line: 3718
2971
2972	.
2973	># Foo
2974	>bar
2975	> baz
2976	.
2977	<blockquote>
2978	<h1>Foo</h1>
2979	<p>bar
2980	baz</p>
2981	</blockquote>
2982	.
2983
2984	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2985	src line: 3733
2986
2987	.
2988	> # Foo
2989	> bar
2990	> baz
2991	.
2992	<blockquote>
2993	<h1>Foo</h1>
2994	<p>bar
2995	baz</p>
2996	</blockquote>
2997	.
2998
2999	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3000	src line: 3748
3001
3002	.
3003	> # Foo
3004	> bar
3005	> baz
3006	.
3007	<pre><code>> # Foo
3008	> bar
3009	> baz
3010	</code></pre>
3011	.
3012
3013	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3014	src line: 3763
3015
3016	.
3017	> # Foo
3018	> bar
3019	baz
3020	.
3021	<blockquote>
3022	<h1>Foo</h1>
3023	<p>bar
3024	baz</p>
3025	</blockquote>
3026	.
3027
3028	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3029	src line: 3779
3030
3031	.
3032	> bar
3033	baz
3034	> foo
3035	.
3036	<blockquote>
3037	<p>bar
3038	baz
3039	foo</p>
3040	</blockquote>
3041	.
3042
3043	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3044	src line: 3803
3045
3046	.
3047	> foo
3048	---
3049	.
3050	<blockquote>
3051	<p>foo</p>
3052	</blockquote>
3053	<hr />
3054	.
3055
3056	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3057	src line: 3823
3058
3059	.
3060	> - foo
3061	- bar
3062	.
3063	<blockquote>
3064	<ul>
3065	<li>foo</li>
3066	</ul>
3067	</blockquote>
3068	<ul>
3069	<li>bar</li>
3070	</ul>
3071	.
3072
3073	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3074	src line: 3841
3075
3076	.
3077	> foo
3078	bar
3079	.
3080	<blockquote>
3081	<pre><code>foo
3082	</code></pre>
3083	</blockquote>
3084	<pre><code>bar
3085	</code></pre>
3086	.
3087
3088	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3089	src line: 3854
3090
3091	.
3092	> ```
3093	foo
3094	```
3095	.
3096	<blockquote>
3097	<pre><code></code></pre>
3098	</blockquote>
3099	<p>foo</p>
3100	<pre><code></code></pre>
3101	.
3102
3103	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3104	src line: 3870
3105
3106	.
3107	> foo
3108	- bar
3109	.
3110	<blockquote>
3111	<p>foo
3112	- bar</p>
3113	</blockquote>
3114	.
3115
3116	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3117	src line: 3894
3118
3119	.
3120	>
3121	.
3122	<blockquote>
3123	</blockquote>
3124	.
3125
3126	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3127	src line: 3902
3128
3129	.
3130	>
3131	>
3132	>
3133	.
3134	<blockquote>
3135	</blockquote>
3136	.
3137
3138	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3139	src line: 3914
3140
3141	.
3142	>
3143	> foo
3144	>
3145	.
3146	<blockquote>
3147	<p>foo</p>
3148	</blockquote>
3149	.
3150
3151	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3152	src line: 3927
3153
3154	.
3155	> foo
3156
3157	> bar
3158	.
3159	<blockquote>
3160	<p>foo</p>
3161	</blockquote>
3162	<blockquote>
3163	<p>bar</p>
3164	</blockquote>
3165	.
3166
3167	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3168	src line: 3949
3169
3170	.
3171	> foo
3172	> bar
3173	.
3174	<blockquote>
3175	<p>foo
3176	bar</p>
3177	</blockquote>
3178	.
3179
3180	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3181	src line: 3962
3182
3183	.
3184	> foo
3185	>
3186	> bar
3187	.
3188	<blockquote>
3189	<p>foo</p>
3190	<p>bar</p>
3191	</blockquote>
3192	.
3193
3194	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3195	src line: 3976
3196
3197	.
3198	foo
3199	> bar
3200	.
3201	<p>foo</p>
3202	<blockquote>
3203	<p>bar</p>
3204	</blockquote>
3205	.
3206
3207	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3208	src line: 3990
3209
3210	.
3211	> aaa
3212	***
3213	> bbb
3214	.
3215	<blockquote>
3216	<p>aaa</p>
3217	</blockquote>
3218	<hr />
3219	<blockquote>
3220	<p>bbb</p>
3221	</blockquote>
3222	.
3223
3224	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3225	src line: 4008
3226
3227	.
3228	> bar
3229	baz
3230	.
3231	<blockquote>
3232	<p>bar
3233	baz</p>
3234	</blockquote>
3235	.
3236
3237	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3238	src line: 4019
3239
3240	.
3241	> bar
3242
3243	baz
3244	.
3245	<blockquote>
3246	<p>bar</p>
3247	</blockquote>
3248	<p>baz</p>
3249	.
3250
3251	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3252	src line: 4031
3253
3254	.
3255	> bar
3256	>
3257	baz
3258	.
3259	<blockquote>
3260	<p>bar</p>
3261	</blockquote>
3262	<p>baz</p>
3263	.
3264
3265	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3266	src line: 4047
3267
3268	.
3269	> > > foo
3270	bar
3271	.
3272	<blockquote>
3273	<blockquote>
3274	<blockquote>
3275	<p>foo
3276	bar</p>
3277	</blockquote>
3278	</blockquote>
3279	</blockquote>
3280	.
3281
3282	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3283	src line: 4062
3284
3285	.
3286	>>> foo
3287	> bar
3288	>>baz
3289	.
3290	<blockquote>
3291	<blockquote>
3292	<blockquote>
3293	<p>foo
3294	bar
3295	baz</p>
3296	</blockquote>
3297	</blockquote>
3298	</blockquote>
3299	.
3300
3301	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3302	src line: 4084
3303
3304	.
3305	> code
3306
3307	> not code
3308	.
3309	<blockquote>
3310	<pre><code>code
3311	</code></pre>
3312	</blockquote>
3313	<blockquote>
3314	<p>not code</p>
3315	</blockquote>
3316	.
3317
3318	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3319	src line: 4138
3320
3321	.
3322	A paragraph
3323	with two lines.
3324
3325	indented code
3326
3327	> A block quote.
3328	.
3329	<p>A paragraph
3330	with two lines.</p>
3331	<pre><code>indented code
3332	</code></pre>
3333	<blockquote>
3334	<p>A block quote.</p>
3335	</blockquote>
3336	.
3337
3338	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3339	src line: 4160
3340
3341	.
3342	1. A paragraph
3343	with two lines.
3344
3345	indented code
3346
3347	> A block quote.
3348	.
3349	<ol>
3350	<li>
3351	<p>A paragraph
3352	with two lines.</p>
3353	<pre><code>indented code
3354	</code></pre>
3355	<blockquote>
3356	<p>A block quote.</p>
3357	</blockquote>
3358	</li>
3359	</ol>
3360	.
3361
3362	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3363	src line: 4193
3364
3365	.
3366	- one
3367
3368	two
3369	.
3370	<ul>
3371	<li>one</li>
3372	</ul>
3373	<p>two</p>
3374	.
3375
3376	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3377	src line: 4205
3378
3379	.
3380	- one
3381
3382	two
3383	.
3384	<ul>
3385	<li>
3386	<p>one</p>
3387	<p>two</p>
3388	</li>
3389	</ul>
3390	.
3391
3392	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3393	src line: 4219
3394
3395	.
3396	- one
3397
3398	two
3399	.
3400	<ul>
3401	<li>one</li>
3402	</ul>
3403	<pre><code> two
3404	</code></pre>
3405	.
3406
3407	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3408	src line: 4232
3409
3410	.
3411	- one
3412
3413	two
3414	.
3415	<ul>
3416	<li>
3417	<p>one</p>
3418	<p>two</p>
3419	</li>
3420	</ul>
3421	.
3422
3423	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3424	src line: 4254
3425
3426	.
3427	> > 1. one
3428	>>
3429	>> two
3430	.
3431	<blockquote>
3432	<blockquote>
3433	<ol>
3434	<li>
3435	<p>one</p>
3436	<p>two</p>
3437	</li>
3438	</ol>
3439	</blockquote>
3440	</blockquote>
3441	.
3442
3443	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3444	src line: 4281
3445
3446	.
3447	>>- one
3448	>>
3449	> > two
3450	.
3451	<blockquote>
3452	<blockquote>
3453	<ul>
3454	<li>one</li>
3455	</ul>
3456	<p>two</p>
3457	</blockquote>
3458	</blockquote>
3459	.
3460
3461	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3462	src line: 4300
3463
3464	.
3465	-one
3466
3467	2.two
3468	.
3469	<p>-one</p>
3470	<p>2.two</p>
3471	.
3472
3473	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3474	src line: 4313
3475
3476	.
3477	- foo
3478
3479
3480	bar
3481	.
3482	<ul>
3483	<li>
3484	<p>foo</p>
3485	<p>bar</p>
3486	</li>
3487	</ul>
3488	.
3489
3490	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3491	src line: 4330
3492
3493	.
3494	1. foo
3495
3496	```
3497	bar
3498	```
3499
3500	baz
3501
3502	> bam
3503	.
3504	<ol>
3505	<li>
3506	<p>foo</p>
3507	<pre><code>bar
3508	</code></pre>
3509	<p>baz</p>
3510	<blockquote>
3511	<p>bam</p>
3512	</blockquote>
3513	</li>
3514	</ol>
3515	.
3516
3517	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3518	src line: 4358
3519
3520	.
3521	- Foo
3522
3523	bar
3524
3525
3526	baz
3527	.
3528	<ul>
3529	<li>
3530	<p>Foo</p>
3531	<pre><code>bar
3532
3533
3534	baz
3535	</code></pre>
3536	</li>
3537	</ul>
3538	.
3539
3540	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3541	src line: 4380
3542
3543	.
3544	123456789. ok
3545	.
3546	<ol start="123456789">
3547	<li>ok</li>
3548	</ol>
3549	.
3550
3551	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3552	src line: 4389
3553
3554	.
3555	1234567890. not ok
3556	.
3557	<p>1234567890. not ok</p>
3558	.
3559
3560	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3561	src line: 4398
3562
3563	.
3564	0. ok
3565	.
3566	<ol start="0">
3567	<li>ok</li>
3568	</ol>
3569	.
3570
3571	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3572	src line: 4407
3573
3574	.
3575	003. ok
3576	.
3577	<ol start="3">
3578	<li>ok</li>
3579	</ol>
3580	.
3581
3582	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3583	src line: 4418
3584
3585	.
3586	-1. not ok
3587	.
3588	<p>-1. not ok</p>
3589	.
3590
3591	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3592	src line: 4441
3593
3594	.
3595	- foo
3596
3597	bar
3598	.
3599	<ul>
3600	<li>
3601	<p>foo</p>
3602	<pre><code>bar
3603	</code></pre>
3604	</li>
3605	</ul>
3606	.
3607
3608	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3609	src line: 4458
3610
3611	.
3612	10. foo
3613
3614	bar
3615	.
3616	<ol start="10">
3617	<li>
3618	<p>foo</p>
3619	<pre><code>bar
3620	</code></pre>
3621	</li>
3622	</ol>
3623	.
3624
3625	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3626	src line: 4477
3627
3628	.
3629	indented code
3630
3631	paragraph
3632
3633	more code
3634	.
3635	<pre><code>indented code
3636	</code></pre>
3637	<p>paragraph</p>
3638	<pre><code>more code
3639	</code></pre>
3640	.
3641
3642	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3643	src line: 4492
3644
3645	.
3646	1. indented code
3647
3648	paragraph
3649
3650	more code
3651	.
3652	<ol>
3653	<li>
3654	<pre><code>indented code
3655	</code></pre>
3656	<p>paragraph</p>
3657	<pre><code>more code
3658	</code></pre>
3659	</li>
3660	</ol>
3661	.
3662
3663	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3664	src line: 4514
3665
3666	.
3667	1. indented code
3668
3669	paragraph
3670
3671	more code
3672	.
3673	<ol>
3674	<li>
3675	<pre><code> indented code
3676	</code></pre>
3677	<p>paragraph</p>
3678	<pre><code>more code
3679	</code></pre>
3680	</li>
3681	</ol>
3682	.
3683
3684	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3685	src line: 4541
3686
3687	.
3688	foo
3689
3690	bar
3691	.
3692	<p>foo</p>
3693	<p>bar</p>
3694	.
3695
3696	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3697	src line: 4551
3698
3699	.
3700	- foo
3701
3702	bar
3703	.
3704	<ul>
3705	<li>foo</li>
3706	</ul>
3707	<p>bar</p>
3708	.
3709
3710	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3711	src line: 4568
3712
3713	.
3714	- foo
3715
3716	bar
3717	.
3718	<ul>
3719	<li>
3720	<p>foo</p>
3721	<p>bar</p>
3722	</li>
3723	</ul>
3724	.
3725
3726	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3727	src line: 4595
3728
3729	.
3730	-
3731	foo
3732	-
3733	```
3734	bar
3735	```
3736	-
3737	baz
3738	.
3739	<ul>
3740	<li>foo</li>
3741	<li>
3742	<pre><code>bar
3743	</code></pre>
3744	</li>
3745	<li>
3746	<pre><code>baz
3747	</code></pre>
3748	</li>
3749	</ul>
3750	.
3751
3752	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3753	src line: 4621
3754
3755	.
3756	-
3757	foo
3758	.
3759	<ul>
3760	<li>foo</li>
3761	</ul>
3762	.
3763
3764	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3765	src line: 4635
3766
3767	.
3768	-
3769
3770	foo
3771	.
3772	<ul>
3773	<li></li>
3774	</ul>
3775	<p>foo</p>
3776	.
3777
3778	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3779	src line: 4649
3780
3781	.
3782	- foo
3783	-
3784	- bar
3785	.
3786	<ul>
3787	<li>foo</li>
3788	<li></li>
3789	<li>bar</li>
3790	</ul>
3791	.
3792
3793	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3794	src line: 4664
3795
3796	.
3797	- foo
3798	-
3799	- bar
3800	.
3801	<ul>
3802	<li>foo</li>
3803	<li></li>
3804	<li>bar</li>
3805	</ul>
3806	.
3807
3808	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3809	src line: 4679
3810
3811	.
3812	1. foo
3813	2.
3814	3. bar
3815	.
3816	<ol>
3817	<li>foo</li>
3818	<li></li>
3819	<li>bar</li>
3820	</ol>
3821	.
3822
3823	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3824	src line: 4694
3825
3826	.
3827	*
3828	.
3829	<ul>
3830	<li></li>
3831	</ul>
3832	.
3833
3834	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3835	src line: 4704
3836
3837	.
3838	foo
3839	*
3840
3841	foo
3842	1.
3843	.
3844	<p>foo
3845	*</p>
3846	<p>foo
3847	1.</p>
3848	.
3849
3850	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3851	src line: 4726
3852
3853	.
3854	1. A paragraph
3855	with two lines.
3856
3857	indented code
3858
3859	> A block quote.
3860	.
3861	<ol>
3862	<li>
3863	<p>A paragraph
3864	with two lines.</p>
3865	<pre><code>indented code
3866	</code></pre>
3867	<blockquote>
3868	<p>A block quote.</p>
3869	</blockquote>
3870	</li>
3871	</ol>
3872	.
3873
3874	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3875	src line: 4750
3876
3877	.
3878	1. A paragraph
3879	with two lines.
3880
3881	indented code
3882
3883	> A block quote.
3884	.
3885	<ol>
3886	<li>
3887	<p>A paragraph
3888	with two lines.</p>
3889	<pre><code>indented code
3890	</code></pre>
3891	<blockquote>
3892	<p>A block quote.</p>
3893	</blockquote>
3894	</li>
3895	</ol>
3896	.
3897
3898	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3899	src line: 4774
3900
3901	.
3902	1. A paragraph
3903	with two lines.
3904
3905	indented code
3906
3907	> A block quote.
3908	.
3909	<ol>
3910	<li>
3911	<p>A paragraph
3912	with two lines.</p>
3913	<pre><code>indented code
3914	</code></pre>
3915	<blockquote>
3916	<p>A block quote.</p>
3917	</blockquote>
3918	</li>
3919	</ol>
3920	.
3921
3922	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3923	src line: 4798
3924
3925	.
3926	1. A paragraph
3927	with two lines.
3928
3929	indented code
3930
3931	> A block quote.
3932	.
3933	<pre><code>1. A paragraph
3934	with two lines.
3935
3936	indented code
3937
3938	> A block quote.
3939	</code></pre>
3940	.
3941
3942	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3943	src line: 4828
3944
3945	.
3946	1. A paragraph
3947	with two lines.
3948
3949	indented code
3950
3951	> A block quote.
3952	.
3953	<ol>
3954	<li>
3955	<p>A paragraph
3956	with two lines.</p>
3957	<pre><code>indented code
3958	</code></pre>
3959	<blockquote>
3960	<p>A block quote.</p>
3961	</blockquote>
3962	</li>
3963	</ol>
3964	.
3965
3966	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3967	src line: 4852
3968
3969	.
3970	1. A paragraph
3971	with two lines.
3972	.
3973	<ol>
3974	<li>A paragraph
3975	with two lines.</li>
3976	</ol>
3977	.
3978
3979	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3980	src line: 4865
3981
3982	.
3983	> 1. > Blockquote
3984	continued here.
3985	.
3986	<blockquote>
3987	<ol>
3988	<li>
3989	<blockquote>
3990	<p>Blockquote
3991	continued here.</p>
3992	</blockquote>
3993	</li>
3994	</ol>
3995	</blockquote>
3996	.
3997
3998	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3999	src line: 4882
4000
4001	.
4002	> 1. > Blockquote
4003	> continued here.
4004	.
4005	<blockquote>
4006	<ol>
4007	<li>
4008	<blockquote>
4009	<p>Blockquote
4010	continued here.</p>
4011	</blockquote>
4012	</li>
4013	</ol>
4014	</blockquote>
4015	.
4016
4017	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4018	src line: 4910
4019
4020	.
4021	- foo
4022	- bar
4023	- baz
4024	- boo
4025	.
4026	<ul>
4027	<li>foo
4028	<ul>
4029	<li>bar
4030	<ul>
4031	<li>baz
4032	<ul>
4033	<li>boo</li>
4034	</ul>
4035	</li>
4036	</ul>
4037	</li>
4038	</ul>
4039	</li>
4040	</ul>
4041	.
4042
4043	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4044	src line: 4936
4045
4046	.
4047	- foo
4048	- bar
4049	- baz
4050	- boo
4051	.
4052	<ul>
4053	<li>foo</li>
4054	<li>bar</li>
4055	<li>baz</li>
4056	<li>boo</li>
4057	</ul>
4058	.
4059
4060	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4061	src line: 4953
4062
4063	.
4064	10) foo
4065	- bar
4066	.
4067	<ol start="10">
4068	<li>foo
4069	<ul>
4070	<li>bar</li>
4071	</ul>
4072	</li>
4073	</ol>
4074	.
4075
4076	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4077	src line: 4969
4078
4079	.
4080	10) foo
4081	- bar
4082	.
4083	<ol start="10">
4084	<li>foo</li>
4085	</ol>
4086	<ul>
4087	<li>bar</li>
4088	</ul>
4089	.
4090
4091	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4092	src line: 4984
4093
4094	.
4095	- - foo
4096	.
4097	<ul>
4098	<li>
4099	<ul>
4100	<li>foo</li>
4101	</ul>
4102	</li>
4103	</ul>
4104	.
4105
4106	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4107	src line: 4997
4108
4109	.
4110	1. - 2. foo
4111	.
4112	<ol>
4113	<li>
4114	<ul>
4115	<li>
4116	<ol start="2">
4117	<li>foo</li>
4118	</ol>
4119	</li>
4120	</ul>
4121	</li>
4122	</ol>
4123	.
4124
4125	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4126	src line: 5016
4127
4128	.
4129	- # Foo
4130	- Bar
4131	---
4132	baz
4133	.
4134	<ul>
4135	<li>
4136	<h1>Foo</h1>
4137	</li>
4138	<li>
4139	<h2>Bar</h2>
4140	baz</li>
4141	</ul>
4142	.
4143
4144	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4145	src line: 5252
4146
4147	.
4148	- foo
4149	- bar
4150	+ baz
4151	.
4152	<ul>
4153	<li>foo</li>
4154	<li>bar</li>
4155	</ul>
4156	<ul>
4157	<li>baz</li>
4158	</ul>
4159	.
4160
4161	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4162	src line: 5267
4163
4164	.
4165	1. foo
4166	2. bar
4167	3) baz
4168	.
4169	<ol>
4170	<li>foo</li>
4171	<li>bar</li>
4172	</ol>
4173	<ol start="3">
4174	<li>baz</li>
4175	</ol>
4176	.
4177
4178	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4179	src line: 5286
4180
4181	.
4182	Foo
4183	- bar
4184	- baz
4185	.
4186	<p>Foo</p>
4187	<ul>
4188	<li>bar</li>
4189	<li>baz</li>
4190	</ul>
4191	.
4192
4193	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4194	src line: 5363
4195
4196	.
4197	The number of windows in my house is
4198	14. The number of doors is 6.
4199	.
4200	<p>The number of windows in my house is
4201	14. The number of doors is 6.</p>
4202	.
4203
4204	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4205	src line: 5373
4206
4207	.
4208	The number of windows in my house is
4209	1. The number of doors is 6.
4210	.
4211	<p>The number of windows in my house is</p>
4212	<ol>
4213	<li>The number of doors is 6.</li>
4214	</ol>
4215	.
4216
4217	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4218	src line: 5387
4219
4220	.
4221	- foo
4222
4223	- bar
4224
4225
4226	- baz
4227	.
4228	<ul>
4229	<li>
4230	<p>foo</p>
4231	</li>
4232	<li>
4233	<p>bar</p>
4234	</li>
4235	<li>
4236	<p>baz</p>
4237	</li>
4238	</ul>
4239	.
4240
4241	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4242	src line: 5408
4243
4244	.
4245	- foo
4246	- bar
4247	- baz
4248
4249
4250	bim
4251	.
4252	<ul>
4253	<li>foo
4254	<ul>
4255	<li>bar
4256	<ul>
4257	<li>
4258	<p>baz</p>
4259	<p>bim</p>
4260	</li>
4261	</ul>
4262	</li>
4263	</ul>
4264	</li>
4265	</ul>
4266	.
4267
4268	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4269	src line: 5438
4270
4271	.
4272	- foo
4273	- bar
4274
4275	<!-- -->
4276
4277	- baz
4278	- bim
4279	.
4280	<ul>
4281	<li>foo</li>
4282	<li>bar</li>
4283	</ul>
4284	<!-- -->
4285	<ul>
4286	<li>baz</li>
4287	<li>bim</li>
4288	</ul>
4289	.
4290
4291	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4292	src line: 5459
4293
4294	.
4295	- foo
4296
4297	notcode
4298
4299	- foo
4300
4301	<!-- -->
4302
4303	code
4304	.
4305	<ul>
4306	<li>
4307	<p>foo</p>
4308	<p>notcode</p>
4309	</li>
4310	<li>
4311	<p>foo</p>
4312	</li>
4313	</ul>
4314	<!-- -->
4315	<pre><code>code
4316	</code></pre>
4317	.
4318
4319	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4320	src line: 5490
4321
4322	.
4323	- a
4324	- b
4325	- c
4326	- d
4327	- e
4328	- f
4329	- g
4330	.
4331	<ul>
4332	<li>a</li>
4333	<li>b</li>
4334	<li>c</li>
4335	<li>d</li>
4336	<li>e</li>
4337	<li>f</li>
4338	<li>g</li>
4339	</ul>
4340	.
4341
4342	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4343	src line: 5511
4344
4345	.
4346	1. a
4347
4348	2. b
4349
4350	3. c
4351	.
4352	<ol>
4353	<li>
4354	<p>a</p>
4355	</li>
4356	<li>
4357	<p>b</p>
4358	</li>
4359	<li>
4360	<p>c</p>
4361	</li>
4362	</ol>
4363	.
4364
4365	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4366	src line: 5535
4367
4368	.
4369	- a
4370	- b
4371	- c
4372	- d
4373	- e
4374	.
4375	<ul>
4376	<li>a</li>
4377	<li>b</li>
4378	<li>c</li>
4379	<li>d
4380	- e</li>
4381	</ul>
4382	.
4383
4384	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4385	src line: 5555
4386
4387	.
4388	1. a
4389
4390	2. b
4391
4392	3. c
4393	.
4394	<ol>
4395	<li>
4396	<p>a</p>
4397	</li>
4398	<li>
4399	<p>b</p>
4400	</li>
4401	</ol>
4402	<pre><code>3. c
4403	</code></pre>
4404	.
4405
4406	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4407	src line: 5578
4408
4409	.
4410	- a
4411	- b
4412
4413	- c
4414	.
4415	<ul>
4416	<li>
4417	<p>a</p>
4418	</li>
4419	<li>
4420	<p>b</p>
4421	</li>
4422	<li>
4423	<p>c</p>
4424	</li>
4425	</ul>
4426	.
4427
4428	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4429	src line: 5600
4430
4431	.
4432	* a
4433	*
4434
4435	* c
4436	.
4437	<ul>
4438	<li>
4439	<p>a</p>
4440	</li>
4441	<li></li>
4442	<li>
4443	<p>c</p>
4444	</li>
4445	</ul>
4446	.
4447
4448	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4449	src line: 5622
4450
4451	.
4452	- a
4453	- b
4454
4455	c
4456	- d
4457	.
4458	<ul>
4459	<li>
4460	<p>a</p>
4461	</li>
4462	<li>
4463	<p>b</p>
4464	<p>c</p>
4465	</li>
4466	<li>
4467	<p>d</p>
4468	</li>
4469	</ul>
4470	.
4471
4472	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4473	src line: 5644
4474
4475	.
4476	- a
4477	- b
4478
4479	[ref]: /url
4480	- d
4481	.
4482	<ul>
4483	<li>
4484	<p>a</p>
4485	</li>
4486	<li>
4487	<p>b</p>
4488	</li>
4489	<li>
4490	<p>d</p>
4491	</li>
4492	</ul>
4493	.
4494
4495	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4496	src line: 5667
4497
4498	.
4499	- a
4500	- ```
4501	b
4502
4503
4504	```
4505	- c
4506	.
4507	<ul>
4508	<li>a</li>
4509	<li>
4510	<pre><code>b
4511
4512
4513	</code></pre>
4514	</li>
4515	<li>c</li>
4516	</ul>
4517	.
4518
4519	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4520	src line: 5693
4521
4522	.
4523	- a
4524	- b
4525
4526	c
4527	- d
4528	.
4529	<ul>
4530	<li>a
4531	<ul>
4532	<li>
4533	<p>b</p>
4534	<p>c</p>
4535	</li>
4536	</ul>
4537	</li>
4538	<li>d</li>
4539	</ul>
4540	.
4541
4542	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4543	src line: 5717
4544
4545	.
4546	* a
4547	> b
4548	>
4549	* c
4550	.
4551	<ul>
4552	<li>a
4553	<blockquote>
4554	<p>b</p>
4555	</blockquote>
4556	</li>
4557	<li>c</li>
4558	</ul>
4559	.
4560
4561	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4562	src line: 5737
4563
4564	.
4565	- a
4566	> b
4567	```
4568	c
4569	```
4570	- d
4571	.
4572	<ul>
4573	<li>a
4574	<blockquote>
4575	<p>b</p>
4576	</blockquote>
4577	<pre><code>c
4578	</code></pre>
4579	</li>
4580	<li>d</li>
4581	</ul>
4582	.
4583
4584	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4585	src line: 5760
4586
4587	.
4588	- a
4589	.
4590	<ul>
4591	<li>a</li>
4592	</ul>
4593	.
4594
4595	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4596	src line: 5769
4597
4598	.
4599	- a
4600	- b
4601	.
4602	<ul>
4603	<li>a
4604	<ul>
4605	<li>b</li>
4606	</ul>
4607	</li>
4608	</ul>
4609	.
4610
4611	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4612	src line: 5786
4613
4614	.
4615	1. ```
4616	foo
4617	```
4618
4619	bar
4620	.
4621	<ol>
4622	<li>
4623	<pre><code>foo
4624	</code></pre>
4625	<p>bar</p>
4626	</li>
4627	</ol>
4628	.
4629
4630	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4631	src line: 5805
4632
4633	.
4634	* foo
4635	* bar
4636
4637	baz
4638	.
4639	<ul>
4640	<li>
4641	<p>foo</p>
4642	<ul>
4643	<li>bar</li>
4644	</ul>
4645	<p>baz</p>
4646	</li>
4647	</ul>
4648	.
4649
4650	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4651	src line: 5823
4652
4653	.
4654	- a
4655	- b
4656	- c
4657
4658	- d
4659	- e
4660	- f
4661	.
4662	<ul>
4663	<li>
4664	<p>a</p>
4665	<ul>
4666	<li>b</li>
4667	<li>c</li>
4668	</ul>
4669	</li>
4670	<li>
4671	<p>d</p>
4672	<ul>
4673	<li>e</li>
4674	<li>f</li>
4675	</ul>
4676	</li>
4677	</ul>
4678	.
4679
4680	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4681	src line: 5857
4682
4683	.
4684	`hi`lo`
4685	.
4686	<p><code>hi</code>lo`</p>
4687	.
4688
4689	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4690	src line: 5889
4691
4692	.
4693	`foo`
4694	.
4695	<p><code>foo</code></p>
4696	.
4697
4698	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4699	src line: 5900
4700
4701	.
4702	`` foo ` bar ``
4703	.
4704	<p><code>foo ` bar</code></p>
4705	.
4706
4707	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4708	src line: 5910
4709
4710	.
4711	` `` `
4712	.
4713	<p><code>``</code></p>
4714	.
4715
4716	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4717	src line: 5918
4718
4719	.
4720	` `` `
4721	.
4722	<p><code> `` </code></p>
4723	.
4724
4725	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4726	src line: 5927
4727
4728	.
4729	` a`
4730	.
4731	<p><code> a</code></p>
4732	.
4733
4734	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4735	src line: 5936
4736
4737	.
4738	` b `
4739	.
4740	<p><code> b </code></p>
4741	.
4742
4743	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4744	src line: 5944
4745
4746	.
4747	` `
4748	` `
4749	.
4750	<p><code> </code>
4751	<code> </code></p>
4752	.
4753
4754	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4755	src line: 5955
4756
4757	.
4758	``
4759	foo
4760	bar
4761	baz
4762	``
4763	.
4764	<p><code>foo bar baz</code></p>
4765	.
4766
4767	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4768	src line: 5965
4769
4770	.
4771	``
4772	foo
4773	``
4774	.
4775	<p><code>foo </code></p>
4776	.
4777
4778	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4779	src line: 5976
4780
4781	.
4782	`foo bar
4783	baz`
4784	.
4785	<p><code>foo bar baz</code></p>
4786	.
4787
4788	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4789	src line: 5993
4790
4791	.
4792	`foo\`bar`
4793	.
4794	<p><code>foo\</code>bar`</p>
4795	.
4796
4797	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4798	src line: 6004
4799
4800	.
4801	``foo`bar``
4802	.
4803	<p><code>foo`bar</code></p>
4804	.
4805
4806	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4807	src line: 6010
4808
4809	.
4810	` foo `` bar `
4811	.
4812	<p><code>foo `` bar</code></p>
4813	.
4814
4815	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4816	src line: 6022
4817
4818	.
4819	foo``
4820	.
4821	<p>foo<code></code></p>
4822	.
4823
4824	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4825	src line: 6031
4826
4827	.
4828	[not a `link](/foo`)
4829	.
4830	<p>[not a <code>link](/foo</code>)</p>
4831	.
4832
4833	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4834	src line: 6041
4835
4836	.
4837	`<a href="`">`
4838	.
4839	<p><code><a href="</code>">`</p>
4840	.
4841
4842	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4843	src line: 6050
4844
4845	.
4846	<a href="`">`
4847	.
4848	<p><a href="`">`</p>
4849	.
4850
4851	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4852	src line: 6059
4853
4854	.
4855	`<http://foo.bar.`baz>`
4856	.
4857	<p><code><http://foo.bar.</code>baz>`</p>
4858	.
4859
4860	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4861	src line: 6068
4862
4863	.
4864	<http://foo.bar.`baz>`
4865	.
4866	<p><a href="http://foo.bar.%60baz">http://foo.bar.`baz</a>`</p>
4867	.
4868
4869	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4870	src line: 6078
4871
4872	.
4873	```foo``
4874	.
4875	<p>```foo``</p>
4876	.
4877
4878	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4879	src line: 6085
4880
4881	.
4882	`foo
4883	.
4884	<p>`foo</p>
4885	.
4886
4887	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4888	src line: 6094
4889
4890	.
4891	`foo``bar``
4892	.
4893	<p>`foo<code>bar</code></p>
4894	.
4895
4896	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4897	src line: 6311
4898
4899	.
4900	foo bar
4901	.
4902	<p><em>foo bar</em></p>
4903	.
4904
4905	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4906	src line: 6321
4907
4908	.
4909	a * foo bar*
4910	.
4911	<p>a * foo bar*</p>
4912	.
4913
4914	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4915	src line: 6332
4916
4917	.
4918	a"foo"
4919	.
4920	<p>a"foo"</p>
4921	.
4922
4923	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4924	src line: 6341
4925
4926	.
4927	* a *
4928	.
4929	<p>* a *</p>
4930	.
4931
4932	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4933	src line: 6350
4934
4935	.
4936	foobar
4937	.
4938	<p>foo<em>bar</em></p>
4939	.
4940
4941	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4942	src line: 6357
4943
4944	.
4945	5678
4946	.
4947	<p>5<em>6</em>78</p>
4948	.
4949
4950	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4951	src line: 6366
4952
4953	.
4954	_foo bar_
4955	.
4956	<p><em>foo bar</em></p>
4957	.
4958
4959	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4960	src line: 6376
4961
4962	.
4963	_ foo bar_
4964	.
4965	<p>_ foo bar_</p>
4966	.
4967
4968	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4969	src line: 6386
4970
4971	.
4972	a_"foo"_
4973	.
4974	<p>a_"foo"_</p>
4975	.
4976
4977	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4978	src line: 6395
4979
4980	.
4981	foo_bar_
4982	.
4983	<p>foo_bar_</p>
4984	.
4985
4986	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4987	src line: 6402
4988
4989	.
4990	5_6_78
4991	.
4992	<p>5_6_78</p>
4993	.
4994
4995	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4996	src line: 6409
4997
4998	.
4999	пристаням_стремятся_
5000	.
5001	<p>пристаням_стремятся_</p>
5002	.
5003
5004	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5005	src line: 6419
5006
5007	.
5008	aa_"bb"_cc
5009	.
5010	<p>aa_"bb"_cc</p>
5011	.
5012
5013	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5014	src line: 6430
5015
5016	.
5017	foo-_(bar)_
5018	.
5019	<p>foo-<em>(bar)</em></p>
5020	.
5021
5022	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5023	src line: 6442
5024
5025	.
5026	_foo*
5027	.
5028	<p>_foo*</p>
5029	.
5030
5031	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5032	src line: 6452
5033
5034	.
5035	foo bar
5036	.
5037	<p>foo bar </p>
5038	.
5039
5040	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5041	src line: 6461
5042
5043	.
5044	*foo bar
5045	*
5046	.
5047	<p>*foo bar
5048	*</p>
5049	.
5050
5051	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5052	src line: 6474
5053
5054	.
5055	(foo)
5056	.
5057	<p>(foo)</p>
5058	.
5059
5060	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5061	src line: 6484
5062
5063	.
5064	(foo)
5065	.
5066	<p><em>(<em>foo</em>)</em></p>
5067	.
5068
5069	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5070	src line: 6493
5071
5072	.
5073	foobar
5074	.
5075	<p><em>foo</em>bar</p>
5076	.
5077
5078	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5079	src line: 6506
5080
5081	.
5082	_foo bar _
5083	.
5084	<p>_foo bar _</p>
5085	.
5086
5087	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5088	src line: 6516
5089
5090	.
5091	_(_foo)
5092	.
5093	<p>_(_foo)</p>
5094	.
5095
5096	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5097	src line: 6525
5098
5099	.
5100	_(_foo_)_
5101	.
5102	<p><em>(<em>foo</em>)</em></p>
5103	.
5104
5105	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5106	src line: 6534
5107
5108	.
5109	_foo_bar
5110	.
5111	<p>_foo_bar</p>
5112	.
5113
5114	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5115	src line: 6541
5116
5117	.
5118	_пристаням_стремятся
5119	.
5120	<p>_пристаням_стремятся</p>
5121	.
5122
5123	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5124	src line: 6548
5125
5126	.
5127	_foo_bar_baz_
5128	.
5129	<p><em>foo_bar_baz</em></p>
5130	.
5131
5132	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5133	src line: 6559
5134
5135	.
5136	_(bar)_.
5137	.
5138	<p><em>(bar)</em>.</p>
5139	.
5140
5141	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5142	src line: 6568
5143
5144	.
5145	foo bar
5146	.
5147	<p><strong>foo bar</strong></p>
5148	.
5149
5150	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5151	src line: 6578
5152
5153	.
5154	foo bar
5155	.
5156	<p> foo bar</p>
5157	.
5158
5159	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5160	src line: 6589
5161
5162	.
5163	a"foo"
5164	.
5165	<p>a"foo"</p>
5166	.
5167
5168	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5169	src line: 6598
5170
5171	.
5172	foobar
5173	.
5174	<p>foo<strong>bar</strong></p>
5175	.
5176
5177	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5178	src line: 6607
5179
5180	.
5181	__foo bar__
5182	.
5183	<p><strong>foo bar</strong></p>
5184	.
5185
5186	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5187	src line: 6617
5188
5189	.
5190	__ foo bar__
5191	.
5192	<p>__ foo bar__</p>
5193	.
5194
5195	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5196	src line: 6625
5197
5198	.
5199	__
5200	foo bar__
5201	.
5202	<p>__
5203	foo bar__</p>
5204	.
5205
5206	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5207	src line: 6637
5208
5209	.
5210	a__"foo"__
5211	.
5212	<p>a__"foo"__</p>
5213	.
5214
5215	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5216	src line: 6646
5217
5218	.
5219	foo__bar__
5220	.
5221	<p>foo__bar__</p>
5222	.
5223
5224	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5225	src line: 6653
5226
5227	.
5228	5__6__78
5229	.
5230	<p>5__6__78</p>
5231	.
5232
5233	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5234	src line: 6660
5235
5236	.
5237	пристаням__стремятся__
5238	.
5239	<p>пристаням__стремятся__</p>
5240	.
5241
5242	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5243	src line: 6667
5244
5245	.
5246	__foo, __bar__, baz__
5247	.
5248	<p><strong>foo, <strong>bar</strong>, baz</strong></p>
5249	.
5250
5251	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5252	src line: 6678
5253
5254	.
5255	foo-__(bar)__
5256	.
5257	<p>foo-<strong>(bar)</strong></p>
5258	.
5259
5260	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5261	src line: 6691
5262
5263	.
5264	foo bar
5265	.
5266	<p>foo bar </p>
5267	.
5268
5269	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5270	src line: 6704
5271
5272	.
5273	(foo)
5274	.
5275	<p>(foo)</p>
5276	.
5277
5278	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5279	src line: 6714
5280
5281	.
5282	(foo)
5283	.
5284	<p><em>(<strong>foo</strong>)</em></p>
5285	.
5286
5287	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5288	src line: 6721
5289
5290	.
5291	*Gomphocarpus (Gomphocarpus physocarpus*, syn.
5292	Asclepias physocarpa)**
5293	.
5294	<p><strong>Gomphocarpus (<em>Gomphocarpus physocarpus</em>, syn.
5295	<em>Asclepias physocarpa</em>)</strong></p>
5296	.
5297
5298	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5299	src line: 6730
5300
5301	.
5302	*foo "bar" foo*
5303	.
5304	<p><strong>foo "<em>bar</em>" foo</strong></p>
5305	.
5306
5307	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5308	src line: 6739
5309
5310	.
5311	foobar
5312	.
5313	<p><strong>foo</strong>bar</p>
5314	.
5315
5316	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5317	src line: 6751
5318
5319	.
5320	__foo bar __
5321	.
5322	<p>__foo bar __</p>
5323	.
5324
5325	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5326	src line: 6761
5327
5328	.
5329	__(__foo)
5330	.
5331	<p>__(__foo)</p>
5332	.
5333
5334	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5335	src line: 6771
5336
5337	.
5338	_(__foo__)_
5339	.
5340	<p><em>(<strong>foo</strong>)</em></p>
5341	.
5342
5343	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5344	src line: 6780
5345
5346	.
5347	__foo__bar
5348	.
5349	<p>__foo__bar</p>
5350	.
5351
5352	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5353	src line: 6787
5354
5355	.
5356	__пристаням__стремятся
5357	.
5358	<p>__пристаням__стремятся</p>
5359	.
5360
5361	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5362	src line: 6794
5363
5364	.
5365	__foo__bar__baz__
5366	.
5367	<p><strong>foo__bar__baz</strong></p>
5368	.
5369
5370	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5371	src line: 6805
5372
5373	.
5374	__(bar)__.
5375	.
5376	<p><strong>(bar)</strong>.</p>
5377	.
5378
5379	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5380	src line: 6817
5381
5382	.
5383	foo [bar](/url)
5384	.
5385	<p><em>foo <a href="/url">bar</a></em></p>
5386	.
5387
5388	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5389	src line: 6824
5390
5391	.
5392	*foo
5393	bar*
5394	.
5395	<p><em>foo
5396	bar</em></p>
5397	.
5398
5399	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5400	src line: 6836
5401
5402	.
5403	_foo __bar__ baz_
5404	.
5405	<p><em>foo <strong>bar</strong> baz</em></p>
5406	.
5407
5408	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5409	src line: 6843
5410
5411	.
5412	_foo _bar_ baz_
5413	.
5414	<p><em>foo <em>bar</em> baz</em></p>
5415	.
5416
5417	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5418	src line: 6850
5419
5420	.
5421	__foo_ bar_
5422	.
5423	<p><em><em>foo</em> bar</em></p>
5424	.
5425
5426	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5427	src line: 6857
5428
5429	.
5430	foo bar**
5431	.
5432	<p><em>foo <em>bar</em></em></p>
5433	.
5434
5435	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5436	src line: 6864
5437
5438	.
5439	foo bar* baz*
5440	.
5441	<p><em>foo <strong>bar</strong> baz</em></p>
5442	.
5443
5444	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5445	src line: 6870
5446
5447	.
5448	foobarbaz
5449	.
5450	<p><em>foo<strong>bar</strong>baz</em></p>
5451	.
5452
5453	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5454	src line: 6894
5455
5456	.
5457	foobar
5458	.
5459	<p><em>foo**bar</em></p>
5460	.
5461
5462	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5463	src line: 6907
5464
5465	.
5466	*foo bar*
5467	.
5468	<p><em><strong>foo</strong> bar</em></p>
5469	.
5470
5471	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5472	src line: 6914
5473
5474	.
5475	foo bar**
5476	.
5477	<p><em>foo <strong>bar</strong></em></p>
5478	.
5479
5480	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5481	src line: 6921
5482
5483	.
5484	foobar**
5485	.
5486	<p><em>foo<strong>bar</strong></em></p>
5487	.
5488
5489	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5490	src line: 6932
5491
5492	.
5493	foo*bar*baz
5494	.
5495	<p>foo<em><strong>bar</strong></em>baz</p>
5496	.
5497
5498	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5499	src line: 6938
5500
5501	.
5502	foo****bar*******baz
5503	.
5504	<p>foo<strong><strong><strong>bar</strong></strong></strong>***baz</p>
5505	.
5506
5507	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5508	src line: 6947
5509
5510	.
5511	foo bar baz* bim** bop*
5512	.
5513	<p><em>foo <strong>bar <em>baz</em> bim</strong> bop</em></p>
5514	.
5515
5516	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5517	src line: 6954
5518
5519	.
5520	foo [bar](/url)
5521	.
5522	<p><em>foo <a href="/url"><em>bar</em></a></em></p>
5523	.
5524
5525	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5526	src line: 6963
5527
5528	.
5529	** is not an empty emphasis
5530	.
5531	<p>** is not an empty emphasis</p>
5532	.
5533
5534	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5535	src line: 6970
5536
5537	.
5538	**** is not an empty strong emphasis
5539	.
5540	<p>**** is not an empty strong emphasis</p>
5541	.
5542
5543	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5544	src line: 6983
5545
5546	.
5547	foo [bar](/url)
5548	.
5549	<p><strong>foo <a href="/url">bar</a></strong></p>
5550	.
5551
5552	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5553	src line: 6990
5554
5555	.
5556	**foo
5557	bar**
5558	.
5559	<p><strong>foo
5560	bar</strong></p>
5561	.
5562
5563	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5564	src line: 7002
5565
5566	.
5567	__foo _bar_ baz__
5568	.
5569	<p><strong>foo <em>bar</em> baz</strong></p>
5570	.
5571
5572	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5573	src line: 7009
5574
5575	.
5576	__foo __bar__ baz__
5577	.
5578	<p><strong>foo <strong>bar</strong> baz</strong></p>
5579	.
5580
5581	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5582	src line: 7016
5583
5584	.
5585	____foo__ bar__
5586	.
5587	<p><strong><strong>foo</strong> bar</strong></p>
5588	.
5589
5590	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5591	src line: 7023
5592
5593	.
5594	foo bar****
5595	.
5596	<p><strong>foo <strong>bar</strong></strong></p>
5597	.
5598
5599	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5600	src line: 7030
5601
5602	.
5603	*foo bar* baz**
5604	.
5605	<p><strong>foo <em>bar</em> baz</strong></p>
5606	.
5607
5608	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5609	src line: 7037
5610
5611	.
5612	*foobarbaz*
5613	.
5614	<p><strong>foo<em>bar</em>baz</strong></p>
5615	.
5616
5617	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5618	src line: 7044
5619
5620	.
5621	**foo bar**
5622	.
5623	<p><strong><em>foo</em> bar</strong></p>
5624	.
5625
5626	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5627	src line: 7051
5628
5629	.
5630	*foo bar***
5631	.
5632	<p><strong>foo <em>bar</em></strong></p>
5633	.
5634
5635	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5636	src line: 7060
5637
5638	.
5639	*foo bar baz
5640	bim* bop**
5641	.
5642	<p><strong>foo <em>bar <strong>baz</strong>
5643	bim</em> bop</strong></p>
5644	.
5645
5646	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5647	src line: 7069
5648
5649	.
5650	*foo [bar](/url)*
5651	.
5652	<p><strong>foo <a href="/url"><em>bar</em></a></strong></p>
5653	.
5654
5655	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5656	src line: 7078
5657
5658	.
5659	__ is not an empty emphasis
5660	.
5661	<p>__ is not an empty emphasis</p>
5662	.
5663
5664	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5665	src line: 7085
5666
5667	.
5668	____ is not an empty strong emphasis
5669	.
5670	<p>____ is not an empty strong emphasis</p>
5671	.
5672
5673	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5674	src line: 7095
5675
5676	.
5677	foo ***
5678	.
5679	<p>foo ***</p>
5680	.
5681
5682	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5683	src line: 7102
5684
5685	.
5686	foo \*
5687	.
5688	<p>foo <em>*</em></p>
5689	.
5690
5691	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5692	src line: 7109
5693
5694	.
5695	foo _
5696	.
5697	<p>foo <em>_</em></p>
5698	.
5699
5700	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5701	src line: 7116
5702
5703	.
5704	foo *****
5705	.
5706	<p>foo *****</p>
5707	.
5708
5709	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5710	src line: 7123
5711
5712	.
5713	foo \*
5714	.
5715	<p>foo <strong>*</strong></p>
5716	.
5717
5718	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5719	src line: 7130
5720
5721	.
5722	foo _
5723	.
5724	<p>foo <strong>_</strong></p>
5725	.
5726
5727	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5728	src line: 7141
5729
5730	.
5731	*foo
5732	.
5733	<p>*<em>foo</em></p>
5734	.
5735
5736	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5737	src line: 7148
5738
5739	.
5740	foo*
5741	.
5742	<p><em>foo</em>*</p>
5743	.
5744
5745	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5746	src line: 7155
5747
5748	.
5749	*foo
5750	.
5751	<p>*<strong>foo</strong></p>
5752	.
5753
5754	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5755	src line: 7162
5756
5757	.
5758	***foo
5759	.
5760	<p>***<em>foo</em></p>
5761	.
5762
5763	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5764	src line: 7169
5765
5766	.
5767	foo*
5768	.
5769	<p><strong>foo</strong>*</p>
5770	.
5771
5772	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5773	src line: 7176
5774
5775	.
5776	foo***
5777	.
5778	<p><em>foo</em>***</p>
5779	.
5780
5781	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5782	src line: 7186
5783
5784	.
5785	foo ___
5786	.
5787	<p>foo ___</p>
5788	.
5789
5790	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5791	src line: 7193
5792
5793	.
5794	foo _\__
5795	.
5796	<p>foo <em>_</em></p>
5797	.
5798
5799	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5800	src line: 7200
5801
5802	.
5803	foo _*_
5804	.
5805	<p>foo <em>*</em></p>
5806	.
5807
5808	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5809	src line: 7207
5810
5811	.
5812	foo _____
5813	.
5814	<p>foo _____</p>
5815	.
5816
5817	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5818	src line: 7214
5819
5820	.
5821	foo __\___
5822	.
5823	<p>foo <strong>_</strong></p>
5824	.
5825
5826	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5827	src line: 7221
5828
5829	.
5830	foo __*__
5831	.
5832	<p>foo <strong>*</strong></p>
5833	.
5834
5835	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5836	src line: 7228
5837
5838	.
5839	__foo_
5840	.
5841	<p>_<em>foo</em></p>
5842	.
5843
5844	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5845	src line: 7239
5846
5847	.
5848	_foo__
5849	.
5850	<p><em>foo</em>_</p>
5851	.
5852
5853	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5854	src line: 7246
5855
5856	.
5857	___foo__
5858	.
5859	<p>_<strong>foo</strong></p>
5860	.
5861
5862	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5863	src line: 7253
5864
5865	.
5866	____foo_
5867	.
5868	<p>___<em>foo</em></p>
5869	.
5870
5871	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5872	src line: 7260
5873
5874	.
5875	__foo___
5876	.
5877	<p><strong>foo</strong>_</p>
5878	.
5879
5880	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5881	src line: 7267
5882
5883	.
5884	_foo____
5885	.
5886	<p><em>foo</em>___</p>
5887	.
5888
5889	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5890	src line: 7277
5891
5892	.
5893	foo
5894	.
5895	<p><strong>foo</strong></p>
5896	.
5897
5898	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5899	src line: 7284
5900
5901	.
5902	_foo_
5903	.
5904	<p><em><em>foo</em></em></p>
5905	.
5906
5907	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5908	src line: 7291
5909
5910	.
5911	__foo__
5912	.
5913	<p><strong>foo</strong></p>
5914	.
5915
5916	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5917	src line: 7298
5918
5919	.
5920	_foo_
5921	.
5922	<p><em><em>foo</em></em></p>
5923	.
5924
5925	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5926	src line: 7308
5927
5928	.
5929	**foo**
5930	.
5931	<p><strong><strong>foo</strong></strong></p>
5932	.
5933
5934	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5935	src line: 7315
5936
5937	.
5938	____foo____
5939	.
5940	<p><strong><strong>foo</strong></strong></p>
5941	.
5942
5943	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5944	src line: 7326
5945
5946	.
5947	****foo****
5948	.
5949	<p><strong><strong><strong>foo</strong></strong></strong></p>
5950	.
5951
5952	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5953	src line: 7335
5954
5955	.
5956	*foo*
5957	.
5958	<p><em><strong>foo</strong></em></p>
5959	.
5960
5961	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5962	src line: 7342
5963
5964	.
5965	_____foo_____
5966	.
5967	<p><em><strong><strong>foo</strong></strong></em></p>
5968	.
5969
5970	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5971	src line: 7351
5972
5973	.
5974	foo _bar baz_
5975	.
5976	<p><em>foo _bar</em> baz_</p>
5977	.
5978
5979	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5980	src line: 7358
5981
5982	.
5983	foo __bar baz bim__ bam*
5984	.
5985	<p><em>foo <strong>bar *baz bim</strong> bam</em></p>
5986	.
5987
5988	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5989	src line: 7367
5990
5991	.
5992	foo bar baz**
5993	.
5994	<p>**foo <strong>bar baz</strong></p>
5995	.
5996
5997	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5998	src line: 7374
5999
6000	.
6001	foo bar baz*
6002	.
6003	<p>*foo <em>bar baz</em></p>
6004	.
6005
6006	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6007	src line: 7383
6008
6009	.
6010	[bar](/url)
6011	.
6012	<p><a href="/url">bar</a></p>
6013	.
6014
6015	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6016	src line: 7390
6017
6018	.
6019	_foo [bar_](/url)
6020	.
6021	<p>_foo <a href="/url">bar_</a></p>
6022	.
6023
6024	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6025	src line: 7397
6026
6027	.
6028	<img src="foo" title=""/>
6029	.
6030	<p><img src="foo" title=""/></p>
6031	.
6032
6033	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6034	src line: 7404
6035
6036	.
6037	<a href="">
6038	.
6039	<p><a href=""></p>
6040	.
6041
6042	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6043	src line: 7411
6044
6045	.
6046	__<a href="__">
6047	.
6048	<p>__<a href="__"></p>
6049	.
6050
6051	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6052	src line: 7418
6053
6054	.
6055	a ``*
6056	.
6057	<p><em>a <code>*</code></em></p>
6058	.
6059
6060	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6061	src line: 7425
6062
6063	.
6064	_a `_`_
6065	.
6066	<p><em>a <code>_</code></em></p>
6067	.
6068
6069	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6070	src line: 7432
6071
6072	.
6073	a<http://foo.bar/?q=>
6074	.
6075	<p>a<a href="http://foo.bar/?q=">http://foo.bar/?q=**</a></p>
6076	.
6077
6078	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6079	src line: 7439
6080
6081	.
6082	__a<http://foo.bar/?q=__>
6083	.
6084	<p>__a<a href="http://foo.bar/?q=__">http://foo.bar/?q=__</a></p>
6085	.
6086
6087	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6088	src line: 7527
6089
6090	.
6091	[link](/uri "title")
6092	.
6093	<p><a href="/uri" title="title">link</a></p>
6094	.
6095
6096	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6097	src line: 7537
6098
6099	.
6100	[link](/uri)
6101	.
6102	<p><a href="/uri">link</a></p>
6103	.
6104
6105	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6106	src line: 7543
6107
6108	.
6109	[](./target.md)
6110	.
6111	<p><a href="./target.md"></a></p>
6112	.
6113
6114	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6115	src line: 7550
6116
6117	.
6118	[link]()
6119	.
6120	<p><a href="">link</a></p>
6121	.
6122
6123	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6124	src line: 7557
6125
6126	.
6127	[link](<>)
6128	.
6129	<p><a href="">link</a></p>
6130	.
6131
6132	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6133	src line: 7564
6134
6135	.
6136	[]()
6137	.
6138	<p><a href=""></a></p>
6139	.
6140
6141	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6142	src line: 7573
6143
6144	.
6145	[link](/my uri)
6146	.
6147	<p>[link](/my uri)</p>
6148	.
6149
6150	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6151	src line: 7579
6152
6153	.
6154	[link](</my uri>)
6155	.
6156	<p><a href="/my%20uri">link</a></p>
6157	.
6158
6159	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6160	src line: 7588
6161
6162	.
6163	[link](foo
6164	bar)
6165	.
6166	<p>[link](foo
6167	bar)</p>
6168	.
6169
6170	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6171	src line: 7596
6172
6173	.
6174	[link](<foo
6175	bar>)
6176	.
6177	<p>[link](<foo
6178	bar>)</p>
6179	.
6180
6181	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6182	src line: 7607
6183
6184	.
6185	[a](<b)c>)
6186	.
6187	<p><a href="b)c">a</a></p>
6188	.
6189
6190	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6191	src line: 7615
6192
6193	.
6194	[link](<foo\>)
6195	.
6196	<p>[link](<foo>)</p>
6197	.
6198
6199	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6200	src line: 7624
6201
6202	.
6203	[a](<b)c
6204	[a](<b)c>
6205	[a](<b>c)
6206	.
6207	<p>[a](<b)c
6208	[a](<b)c>
6209	[a](<b>c)</p>
6210	.
6211
6212	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6213	src line: 7636
6214
6215	.
6216	[link]($foo$)
6217	.
6218	<p><a href="(foo)">link</a></p>
6219	.
6220
6221	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6222	src line: 7645
6223
6224	.
6225	[link](foo(and(bar)))
6226	.
6227	<p><a href="foo(and(bar))">link</a></p>
6228	.
6229
6230	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6231	src line: 7654
6232
6233	.
6234	[link](foo(and(bar))
6235	.
6236	<p>[link](foo(and(bar))</p>
6237	.
6238
6239	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6240	src line: 7661
6241
6242	.
6243	[link](foo$and\(bar$)
6244	.
6245	<p><a href="foo(and(bar)">link</a></p>
6246	.
6247
6248	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6249	src line: 7668
6250
6251	.
6252	[link](<foo(and(bar)>)
6253	.
6254	<p><a href="foo(and(bar)">link</a></p>
6255	.
6256
6257	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6258	src line: 7678
6259
6260	.
6261	[link](foo\)\:)
6262	.
6263	<p><a href="foo):">link</a></p>
6264	.
6265
6266	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6267	src line: 7687
6268
6269	.
6270	[link](#fragment)
6271
6272	[link](http://example.com#fragment)
6273
6274	[link](http://example.com?foo=3#frag)
6275	.
6276	<p><a href="#fragment">link</a></p>
6277	<p><a href="http://example.com#fragment">link</a></p>
6278	<p><a href="http://example.com?foo=3#frag">link</a></p>
6279	.
6280
6281	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6282	src line: 7703
6283
6284	.
6285	[link](foo\bar)
6286	.
6287	<p><a href="foo%5Cbar">link</a></p>
6288	.
6289
6290	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6291	src line: 7719
6292
6293	.
6294	[link](foo%20bä)
6295	.
6296	<p><a href="foo%20b%C3%A4">link</a></p>
6297	.
6298
6299	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6300	src line: 7730
6301
6302	.
6303	[link]("title")
6304	.
6305	<p><a href="%22title%22">link</a></p>
6306	.
6307
6308	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6309	src line: 7739
6310
6311	.
6312	[link](/url "title")
6313	[link](/url 'title')
6314	[link](/url (title))
6315	.
6316	<p><a href="/url" title="title">link</a>
6317	<a href="/url" title="title">link</a>
6318	<a href="/url" title="title">link</a></p>
6319	.
6320
6321	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6322	src line: 7753
6323
6324	.
6325	[link](/url "title \""")
6326	.
6327	<p><a href="/url" title="title """>link</a></p>
6328	.
6329
6330	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6331	src line: 7764
6332
6333	.
6334	[link](/url "title")
6335	.
6336	<p><a href="/url%C2%A0%22title%22">link</a></p>
6337	.
6338
6339	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6340	src line: 7773
6341
6342	.
6343	[link](/url "title "and" title")
6344	.
6345	<p>[link](/url "title "and" title")</p>
6346	.
6347
6348	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6349	src line: 7782
6350
6351	.
6352	[link](/url 'title "and" title')
6353	.
6354	<p><a href="/url" title="title "and" title">link</a></p>
6355	.
6356
6357	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6358	src line: 7807
6359
6360	.
6361	[link]( /uri
6362	"title" )
6363	.
6364	<p><a href="/uri" title="title">link</a></p>
6365	.
6366
6367	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6368	src line: 7818
6369
6370	.
6371	[link] (/uri)
6372	.
6373	<p>[link] (/uri)</p>
6374	.
6375
6376	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6377	src line: 7828
6378
6379	.
6380	[link [foo [bar]]](/uri)
6381	.
6382	<p><a href="/uri">link [foo [bar]]</a></p>
6383	.
6384
6385	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6386	src line: 7835
6387
6388	.
6389	[link] bar](/uri)
6390	.
6391	<p>[link] bar](/uri)</p>
6392	.
6393
6394	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6395	src line: 7842
6396
6397	.
6398	[link [bar](/uri)
6399	.
6400	<p>[link <a href="/uri">bar</a></p>
6401	.
6402
6403	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6404	src line: 7849
6405
6406	.
6407	[link \[bar](/uri)
6408	.
6409	<p><a href="/uri">link [bar</a></p>
6410	.
6411
6412	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6413	src line: 7858
6414
6415	.
6416	[link foo bar* `#`*](/uri)
6417	.
6418	<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
6419	.
6420
6421	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6422	src line: 7865
6423
6424	.
6425	[![moon](moon.jpg)](/uri)
6426	.
6427	<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
6428	.
6429
6430	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6431	src line: 7874
6432
6433	.
6434	[foo [bar](/uri)](/uri)
6435	.
6436	<p>[foo <a href="/uri">bar</a>](/uri)</p>
6437	.
6438
6439	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6440	src line: 7881
6441
6442	.
6443	[foo [bar [baz](/uri)](/uri)](/uri)
6444	.
6445	<p>[foo <em>[bar <a href="/uri">baz</a>](/uri)</em>](/uri)</p>
6446	.
6447
6448	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6449	src line: 7888
6450
6451	.
6452	![[[foo](uri1)](uri2)](uri3)
6453	.
6454	<p><img src="uri3" alt="[foo](uri2)" /></p>
6455	.
6456
6457	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6458	src line: 7898
6459
6460	.
6461	[foo](/uri)
6462	.
6463	<p><a href="/uri">foo</a></p>
6464	.
6465
6466	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6467	src line: 7905
6468
6469	.
6470	[foo bar](baz)
6471	.
6472	<p><a href="baz">foo bar</a></p>
6473	.
6474
6475	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6476	src line: 7915
6477
6478	.
6479	foo [bar baz]
6480	.
6481	<p><em>foo [bar</em> baz]</p>
6482	.
6483
6484	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6485	src line: 7925
6486
6487	.
6488	[foo <bar attr="](baz)">
6489	.
6490	<p>[foo <bar attr="](baz)"></p>
6491	.
6492
6493	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6494	src line: 7932
6495
6496	.
6497	[foo`](/uri)`
6498	.
6499	<p>[foo<code>](/uri)</code></p>
6500	.
6501
6502	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6503	src line: 7939
6504
6505	.
6506	[foo<http://example.com/?search=](uri)>
6507	.
6508	<p>[foo<a href="http://example.com/?search=%5D(uri)">http://example.com/?search=](uri)</a></p>
6509	.
6510
6511	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6512	src line: 7977
6513
6514	.
6515	[foo][bar]
6516
6517	[bar]: /url "title"
6518	.
6519	<p><a href="/url" title="title">foo</a></p>
6520	.
6521
6522	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6523	src line: 7992
6524
6525	.
6526	[link [foo [bar]]][ref]
6527
6528	[ref]: /uri
6529	.
6530	<p><a href="/uri">link [foo [bar]]</a></p>
6531	.
6532
6533	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6534	src line: 8001
6535
6536	.
6537	[link \[bar][ref]
6538
6539	[ref]: /uri
6540	.
6541	<p><a href="/uri">link [bar</a></p>
6542	.
6543
6544	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6545	src line: 8012
6546
6547	.
6548	[link foo bar* `#`*][ref]
6549
6550	[ref]: /uri
6551	.
6552	<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
6553	.
6554
6555	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6556	src line: 8021
6557
6558	.
6559	[![moon](moon.jpg)][ref]
6560
6561	[ref]: /uri
6562	.
6563	<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
6564	.
6565
6566	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6567	src line: 8032
6568
6569	.
6570	[foo [bar](/uri)][ref]
6571
6572	[ref]: /uri
6573	.
6574	<p>[foo <a href="/uri">bar</a>]<a href="/uri">ref</a></p>
6575	.
6576
6577	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6578	src line: 8041
6579
6580	.
6581	[foo bar [baz][ref]][ref]
6582
6583	[ref]: /uri
6584	.
6585	<p>[foo <em>bar <a href="/uri">baz</a></em>]<a href="/uri">ref</a></p>
6586	.
6587
6588	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6589	src line: 8056
6590
6591	.
6592	[foo][ref]
6593
6594	[ref]: /uri
6595	.
6596	<p><a href="/uri">foo</a></p>
6597	.
6598
6599	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6600	src line: 8065
6601
6602	.
6603	[foo bar][ref]
6604
6605	[ref]: /uri
6606	.
6607	<p><a href="/uri">foo bar</a></p>
6608	.
6609
6610	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6611	src line: 8077
6612
6613	.
6614	[foo <bar attr="][ref]">
6615
6616	[ref]: /uri
6617	.
6618	<p>[foo <bar attr="][ref]"></p>
6619	.
6620
6621	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6622	src line: 8086
6623
6624	.
6625	[foo`][ref]`
6626
6627	[ref]: /uri
6628	.
6629	<p>[foo<code>][ref]</code></p>
6630	.
6631
6632	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6633	src line: 8095
6634
6635	.
6636	[foo<http://example.com/?search=][ref]>
6637
6638	[ref]: /uri
6639	.
6640	<p>[foo<a href="http://example.com/?search=%5D%5Bref%5D">http://example.com/?search=][ref]</a></p>
6641	.
6642
6643	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6644	src line: 8106
6645
6646	.
6647	[foo][BaR]
6648
6649	[bar]: /url "title"
6650	.
6651	<p><a href="/url" title="title">foo</a></p>
6652	.
6653
6654	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6655	src line: 8117
6656
6657	.
6658	[ẞ]
6659
6660	[SS]: /url
6661	.
6662	<p><a href="/url">ẞ</a></p>
6663	.
6664
6665	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6666	src line: 8129
6667
6668	.
6669	[Foo
6670	bar]: /url
6671
6672	[Baz][Foo bar]
6673	.
6674	<p><a href="/url">Baz</a></p>
6675	.
6676
6677	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6678	src line: 8142
6679
6680	.
6681	[foo] [bar]
6682
6683	[bar]: /url "title"
6684	.
6685	<p>[foo] <a href="/url" title="title">bar</a></p>
6686	.
6687
6688	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6689	src line: 8151
6690
6691	.
6692	[foo]
6693	[bar]
6694
6695	[bar]: /url "title"
6696	.
6697	<p>[foo]
6698	<a href="/url" title="title">bar</a></p>
6699	.
6700
6701	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6702	src line: 8192
6703
6704	.
6705	[foo]: /url1
6706
6707	[foo]: /url2
6708
6709	[bar][foo]
6710	.
6711	<p><a href="/url1">bar</a></p>
6712	.
6713
6714	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6715	src line: 8207
6716
6717	.
6718	[bar][foo\!]
6719
6720	[foo!]: /url
6721	.
6722	<p>[bar][foo!]</p>
6723	.
6724
6725	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6726	src line: 8219
6727
6728	.
6729	[foo][ref[]
6730
6731	[ref[]: /uri
6732	.
6733	<p>[foo][ref[]</p>
6734	<p>[ref[]: /uri</p>
6735	.
6736
6737	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6738	src line: 8229
6739
6740	.
6741	[foo][ref[bar]]
6742
6743	[ref[bar]]: /uri
6744	.
6745	<p>[foo][ref[bar]]</p>
6746	<p>[ref[bar]]: /uri</p>
6747	.
6748
6749	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6750	src line: 8239
6751
6752	.
6753	[[[foo]]]
6754
6755	[[[foo]]]: /url
6756	.
6757	<p>[[[foo]]]</p>
6758	<p>[[[foo]]]: /url</p>
6759	.
6760
6761	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6762	src line: 8249
6763
6764	.
6765	[foo][ref\[]
6766
6767	[ref\[]: /uri
6768	.
6769	<p><a href="/uri">foo</a></p>
6770	.
6771
6772	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6773	src line: 8260
6774
6775	.
6776	[bar\\]: /uri
6777
6778	[bar\\]
6779	.
6780	<p><a href="/uri">bar\</a></p>
6781	.
6782
6783	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6784	src line: 8272
6785
6786	.
6787	[]
6788
6789	[]: /uri
6790	.
6791	<p>[]</p>
6792	<p>[]: /uri</p>
6793	.
6794
6795	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6796	src line: 8282
6797
6798	.
6799	[
6800	]
6801
6802	[
6803	]: /uri
6804	.
6805	<p>[
6806	]</p>
6807	<p>[
6808	]: /uri</p>
6809	.
6810
6811	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6812	src line: 8305
6813
6814	.
6815	[foo][]
6816
6817	[foo]: /url "title"
6818	.
6819	<p><a href="/url" title="title">foo</a></p>
6820	.
6821
6822	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6823	src line: 8314
6824
6825	.
6826	[foo bar][]
6827
6828	[foo bar]: /url "title"
6829	.
6830	<p><a href="/url" title="title"><em>foo</em> bar</a></p>
6831	.
6832
6833	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6834	src line: 8325
6835
6836	.
6837	[Foo][]
6838
6839	[foo]: /url "title"
6840	.
6841	<p><a href="/url" title="title">Foo</a></p>
6842	.
6843
6844	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6845	src line: 8338
6846
6847	.
6848	[foo]
6849	[]
6850
6851	[foo]: /url "title"
6852	.
6853	<p><a href="/url" title="title">foo</a>
6854	[]</p>
6855	.
6856
6857	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6858	src line: 8358
6859
6860	.
6861	[foo]
6862
6863	[foo]: /url "title"
6864	.
6865	<p><a href="/url" title="title">foo</a></p>
6866	.
6867
6868	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6869	src line: 8367
6870
6871	.
6872	[foo bar]
6873
6874	[foo bar]: /url "title"
6875	.
6876	<p><a href="/url" title="title"><em>foo</em> bar</a></p>
6877	.
6878
6879	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6880	src line: 8376
6881
6882	.
6883	[[foo bar]]
6884
6885	[foo bar]: /url "title"
6886	.
6887	<p>[<a href="/url" title="title"><em>foo</em> bar</a>]</p>
6888	.
6889
6890	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6891	src line: 8385
6892
6893	.
6894	[[bar [foo]
6895
6896	[foo]: /url
6897	.
6898	<p>[[bar <a href="/url">foo</a></p>
6899	.
6900
6901	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6902	src line: 8396
6903
6904	.
6905	[Foo]
6906
6907	[foo]: /url "title"
6908	.
6909	<p><a href="/url" title="title">Foo</a></p>
6910	.
6911
6912	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6913	src line: 8407
6914
6915	.
6916	[foo] bar
6917
6918	[foo]: /url
6919	.
6920	<p><a href="/url">foo</a> bar</p>
6921	.
6922
6923	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6924	src line: 8419
6925
6926	.
6927	\[foo]
6928
6929	[foo]: /url "title"
6930	.
6931	<p>[foo]</p>
6932	.
6933
6934	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6935	src line: 8431
6936
6937	.
6938	[foo*]: /url
6939
6940	[foo]
6941	.
6942	<p><a href="/url">foo</a></p>
6943	.
6944
6945	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6946	src line: 8443
6947
6948	.
6949	[foo][bar]
6950
6951	[foo]: /url1
6952	[bar]: /url2
6953	.
6954	<p><a href="/url2">foo</a></p>
6955	.
6956
6957	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6958	src line: 8452
6959
6960	.
6961	[foo][]
6962
6963	[foo]: /url1
6964	.
6965	<p><a href="/url1">foo</a></p>
6966	.
6967
6968	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6969	src line: 8462
6970
6971	.
6972	[foo]()
6973
6974	[foo]: /url1
6975	.
6976	<p><a href="">foo</a></p>
6977	.
6978
6979	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6980	src line: 8470
6981
6982	.
6983	[foo](not a link)
6984
6985	[foo]: /url1
6986	.
6987	<p><a href="/url1">foo</a>(not a link)</p>
6988	.
6989
6990	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6991	src line: 8481
6992
6993	.
6994	[foo][bar][baz]
6995
6996	[baz]: /url
6997	.
6998	<p>[foo]<a href="/url">bar</a></p>
6999	.
7000
7001	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7002	src line: 8493
7003
7004	.
7005	[foo][bar][baz]
7006
7007	[baz]: /url1
7008	[bar]: /url2
7009	.
7010	<p><a href="/url2">foo</a><a href="/url1">baz</a></p>
7011	.
7012
7013	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7014	src line: 8506
7015
7016	.
7017	[foo][bar][baz]
7018
7019	[baz]: /url1
7020	[foo]: /url2
7021	.
7022	<p>[foo]<a href="/url1">bar</a></p>
7023	.
7024
7025	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7026	src line: 8529
7027
7028	.
7029	![foo](/url "title")
7030	.
7031	<p><img src="/url" alt="foo" title="title" /></p>
7032	.
7033
7034	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7035	src line: 8536
7036
7037	.
7038	![foo bar]
7039
7040	[foo bar]: train.jpg "train & tracks"
7041	.
7042	<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>
7043	.
7044
7045	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7046	src line: 8545
7047
7048	.
7049	![foo ![bar](/url)](/url2)
7050	.
7051	<p><img src="/url2" alt="foo bar" /></p>
7052	.
7053
7054	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7055	src line: 8552
7056
7057	.
7058	![foo [bar](/url)](/url2)
7059	.
7060	<p><img src="/url2" alt="foo bar" /></p>
7061	.
7062
7063	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7064	src line: 8566
7065
7066	.
7067	![foo bar][]
7068
7069	[foo bar]: train.jpg "train & tracks"
7070	.
7071	<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>
7072	.
7073
7074	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7075	src line: 8575
7076
7077	.
7078	![foo bar][foobar]
7079
7080	[FOOBAR]: train.jpg "train & tracks"
7081	.
7082	<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>
7083	.
7084
7085	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7086	src line: 8584
7087
7088	.
7089	![foo](train.jpg)
7090	.
7091	<p><img src="train.jpg" alt="foo" /></p>
7092	.
7093
7094	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7095	src line: 8591
7096
7097	.
7098	My ![foo bar](/path/to/train.jpg "title" )
7099	.
7100	<p>My <img src="/path/to/train.jpg" alt="foo bar" title="title" /></p>
7101	.
7102
7103	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7104	src line: 8598
7105
7106	.
7107	![foo](<url>)
7108	.
7109	<p><img src="url" alt="foo" /></p>
7110	.
7111
7112	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7113	src line: 8605
7114
7115	.
7116	![](/url)
7117	.
7118	<p><img src="/url" alt="" /></p>
7119	.
7120
7121	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7122	src line: 8614
7123
7124	.
7125	![foo][bar]
7126
7127	[bar]: /url
7128	.
7129	<p><img src="/url" alt="foo" /></p>
7130	.
7131
7132	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7133	src line: 8623
7134
7135	.
7136	![foo][bar]
7137
7138	[BAR]: /url
7139	.
7140	<p><img src="/url" alt="foo" /></p>
7141	.
7142
7143	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7144	src line: 8634
7145
7146	.
7147	![foo][]
7148
7149	[foo]: /url "title"
7150	.
7151	<p><img src="/url" alt="foo" title="title" /></p>
7152	.
7153
7154	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7155	src line: 8643
7156
7157	.
7158	![foo bar][]
7159
7160	[foo bar]: /url "title"
7161	.
7162	<p><img src="/url" alt="foo bar" title="title" /></p>
7163	.
7164
7165	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7166	src line: 8654
7167
7168	.
7169	![Foo][]
7170
7171	[foo]: /url "title"
7172	.
7173	<p><img src="/url" alt="Foo" title="title" /></p>
7174	.
7175
7176	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7177	src line: 8666
7178
7179	.
7180	![foo]
7181	[]
7182
7183	[foo]: /url "title"
7184	.
7185	<p><img src="/url" alt="foo" title="title" />
7186	[]</p>
7187	.
7188
7189	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7190	src line: 8679
7191
7192	.
7193	![foo]
7194
7195	[foo]: /url "title"
7196	.
7197	<p><img src="/url" alt="foo" title="title" /></p>
7198	.
7199
7200	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7201	src line: 8688
7202
7203	.
7204	![foo bar]
7205
7206	[foo bar]: /url "title"
7207	.
7208	<p><img src="/url" alt="foo bar" title="title" /></p>
7209	.
7210
7211	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7212	src line: 8699
7213
7214	.
7215	![[foo]]
7216
7217	[[foo]]: /url "title"
7218	.
7219	<p>![[foo]]</p>
7220	<p>[[foo]]: /url "title"</p>
7221	.
7222
7223	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7224	src line: 8711
7225
7226	.
7227	![Foo]
7228
7229	[foo]: /url "title"
7230	.
7231	<p><img src="/url" alt="Foo" title="title" /></p>
7232	.
7233
7234	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7235	src line: 8723
7236
7237	.
7238	!\[foo]
7239
7240	[foo]: /url "title"
7241	.
7242	<p>![foo]</p>
7243	.
7244
7245	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7246	src line: 8735
7247
7248	.
7249	\![foo]
7250
7251	[foo]: /url "title"
7252	.
7253	<p>!<a href="/url" title="title">foo</a></p>
7254	.
7255
7256	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7257	src line: 8768
7258
7259	.
7260	<http://foo.bar.baz>
7261	.
7262	<p><a href="http://foo.bar.baz">http://foo.bar.baz</a></p>
7263	.
7264
7265	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7266	src line: 8775
7267
7268	.
7269	<http://foo.bar.baz/test?q=hello&id=22&boolean>
7270	.
7271	<p><a href="http://foo.bar.baz/test?q=hello&id=22&boolean">http://foo.bar.baz/test?q=hello&id=22&boolean</a></p>
7272	.
7273
7274	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7275	src line: 8782
7276
7277	.
7278	<irc://foo.bar:2233/baz>
7279	.
7280	<p><a href="irc://foo.bar:2233/baz">irc://foo.bar:2233/baz</a></p>
7281	.
7282
7283	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7284	src line: 8791
7285
7286	.
7287	<MAILTO:FOO@BAR.BAZ>
7288	.
7289	<p><a href="MAILTO:FOO@BAR.BAZ">MAILTO:FOO@BAR.BAZ</a></p>
7290	.
7291
7292	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7293	src line: 8803
7294
7295	.
7296	<a+b+c:d>
7297	.
7298	<p><a href="a+b+c:d">a+b+c:d</a></p>
7299	.
7300
7301	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7302	src line: 8810
7303
7304	.
7305	<made-up-scheme://foo,bar>
7306	.
7307	<p><a href="made-up-scheme://foo,bar">made-up-scheme://foo,bar</a></p>
7308	.
7309
7310	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7311	src line: 8817
7312
7313	.
7314	<http://../>
7315	.
7316	<p><a href="http://../">http://../</a></p>
7317	.
7318
7319	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7320	src line: 8824
7321
7322	.
7323	<localhost:5001/foo>
7324	.
7325	<p><a href="localhost:5001/foo">localhost:5001/foo</a></p>
7326	.
7327
7328	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7329	src line: 8833
7330
7331	.
7332	<http://foo.bar/baz bim>
7333	.
7334	<p><http://foo.bar/baz bim></p>
7335	.
7336
7337	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7338	src line: 8842
7339
7340	.
7341	<http://example.com/\[\>
7342	.
7343	<p><a href="http://example.com/%5C%5B%5C">http://example.com/\[\</a></p>
7344	.
7345
7346	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7347	src line: 8864
7348
7349	.
7350	<foo@bar.example.com>
7351	.
7352	<p><a href="mailto:foo@bar.example.com">foo@bar.example.com</a></p>
7353	.
7354
7355	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7356	src line: 8871
7357
7358	.
7359	<foo+special@Bar.baz-bar0.com>
7360	.
7361	<p><a href="mailto:foo+special@Bar.baz-bar0.com">foo+special@Bar.baz-bar0.com</a></p>
7362	.
7363
7364	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7365	src line: 8880
7366
7367	.
7368	<foo\+@bar.example.com>
7369	.
7370	<p><foo+@bar.example.com></p>
7371	.
7372
7373	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7374	src line: 8889
7375
7376	.
7377	<>
7378	.
7379	<p><></p>
7380	.
7381
7382	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7383	src line: 8896
7384
7385	.
7386	< http://foo.bar >
7387	.
7388	<p>< http://foo.bar ></p>
7389	.
7390
7391	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7392	src line: 8903
7393
7394	.
7395	<m:abc>
7396	.
7397	<p><m:abc></p>
7398	.
7399
7400	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7401	src line: 8910
7402
7403	.
7404	<foo.bar.baz>
7405	.
7406	<p><foo.bar.baz></p>
7407	.
7408
7409	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7410	src line: 8917
7411
7412	.
7413	http://example.com
7414	.
7415	<p>http://example.com</p>
7416	.
7417
7418	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7419	src line: 8924
7420
7421	.
7422	foo@bar.example.com
7423	.
7424	<p>foo@bar.example.com</p>
7425	.
7426
7427	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7428	src line: 9005
7429
7430	.
7431	<a><bab><c2c>
7432	.
7433	<p><a><bab><c2c></p>
7434	.
7435
7436	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7437	src line: 9014
7438
7439	.
7440	<a/><b2/>
7441	.
7442	<p><a/><b2/></p>
7443	.
7444
7445	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7446	src line: 9023
7447
7448	.
7449	<a /><b2
7450	data="foo" >
7451	.
7452	<p><a /><b2
7453	data="foo" ></p>
7454	.
7455
7456	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7457	src line: 9034
7458
7459	.
7460	<a foo="bar" bam = 'baz <em>"</em>'
7461	_boolean zoop:33=zoop:33 />
7462	.
7463	<p><a foo="bar" bam = 'baz <em>"</em>'
7464	_boolean zoop:33=zoop:33 /></p>
7465	.
7466
7467	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7468	src line: 9045
7469
7470	.
7471	Foo <responsive-image src="foo.jpg" />
7472	.
7473	<p>Foo <responsive-image src="foo.jpg" /></p>
7474	.
7475
7476	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7477	src line: 9054
7478
7479	.
7480	<33> <__>
7481	.
7482	<p><33> <__></p>
7483	.
7484
7485	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7486	src line: 9063
7487
7488	.
7489	<a h*#ref="hi">
7490	.
7491	<p><a h*#ref="hi"></p>
7492	.
7493
7494	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7495	src line: 9072
7496
7497	.
7498	<a href="hi'> <a href=hi'>
7499	.
7500	<p><a href="hi'> <a href=hi'></p>
7501	.
7502
7503	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7504	src line: 9081
7505
7506	.
7507	< a><
7508	foo><bar/ >
7509	<foo bar=baz
7510	bim!bop />
7511	.
7512	<p>< a><
7513	foo><bar/ >
7514	<foo bar=baz
7515	bim!bop /></p>
7516	.
7517
7518	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7519	src line: 9096
7520
7521	.
7522	<a href='bar'title=title>
7523	.
7524	<p><a href='bar'title=title></p>
7525	.
7526
7527	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7528	src line: 9105
7529
7530	.
7531	</a></foo >
7532	.
7533	<p></a></foo ></p>
7534	.
7535
7536	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7537	src line: 9114
7538
7539	.
7540	</a href="foo">
7541	.
7542	<p></a href="foo"></p>
7543	.
7544
7545	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7546	src line: 9123
7547
7548	.
7549	foo <!-- this is a
7550	comment - with hyphen -->
7551	.
7552	<p>foo <!-- this is a
7553	comment - with hyphen --></p>
7554	.
7555
7556	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7557	src line: 9132
7558
7559	.
7560	foo <!-- not a comment -- two hyphens -->
7561	.
7562	<p>foo <!-- not a comment -- two hyphens --></p>
7563	.
7564
7565	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7566	src line: 9141
7567
7568	.
7569	foo <!--> foo -->
7570
7571	foo <!-- foo--->
7572	.
7573	<p>foo <!--> foo --></p>
7574	<p>foo <!-- foo---></p>
7575	.
7576
7577	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7578	src line: 9153
7579
7580	.
7581	foo <?php echo $a; ?>
7582	.
7583	<p>foo <?php echo $a; ?></p>
7584	.
7585
7586	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7587	src line: 9162
7588
7589	.
7590	foo <!ELEMENT br EMPTY>
7591	.
7592	<p>foo <!ELEMENT br EMPTY></p>
7593	.
7594
7595	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7596	src line: 9171
7597
7598	.
7599	foo <![CDATA[>&<]]>
7600	.
7601	<p>foo <![CDATA[>&<]]></p>
7602	.
7603
7604	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7605	src line: 9181
7606
7607	.
7608	foo <a href="ö">
7609	.
7610	<p>foo <a href="ö"></p>
7611	.
7612
7613	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7614	src line: 9190
7615
7616	.
7617	foo <a href="\*">
7618	.
7619	<p>foo <a href="\*"></p>
7620	.
7621
7622	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7623	src line: 9197
7624
7625	.
7626	<a href="\"">
7627	.
7628	<p><a href="""></p>
7629	.
7630
7631	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7632	src line: 9211
7633
7634	.
7635	foo
7636	baz
7637	.
7638	<p>foo<br />
7639	baz</p>
7640	.
7641
7642	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7643	src line: 9223
7644
7645	.
7646	foo\
7647	baz
7648	.
7649	<p>foo<br />
7650	baz</p>
7651	.
7652
7653	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7654	src line: 9234
7655
7656	.
7657	foo
7658	baz
7659	.
7660	<p>foo<br />
7661	baz</p>
7662	.
7663
7664	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7665	src line: 9245
7666
7667	.
7668	foo
7669	bar
7670	.
7671	<p>foo<br />
7672	bar</p>
7673	.
7674
7675	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7676	src line: 9254
7677
7678	.
7679	foo\
7680	bar
7681	.
7682	<p>foo<br />
7683	bar</p>
7684	.
7685
7686	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7687	src line: 9266
7688
7689	.
7690	*foo
7691	bar*
7692	.
7693	<p><em>foo<br />
7694	bar</em></p>
7695	.
7696
7697	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7698	src line: 9275
7699
7700	.
7701	*foo\
7702	bar*
7703	.
7704	<p><em>foo<br />
7705	bar</em></p>
7706	.
7707
7708	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7709	src line: 9286
7710
7711	.
7712	`code
7713	span`
7714	.
7715	<p><code>code span</code></p>
7716	.
7717
7718	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7719	src line: 9294
7720
7721	.
7722	`code\
7723	span`
7724	.
7725	<p><code>code\ span</code></p>
7726	.
7727
7728	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7729	src line: 9304
7730
7731	.
7732	<a href="foo
7733	bar">
7734	.
7735	<p><a href="foo
7736	bar"></p>
7737	.
7738
7739	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7740	src line: 9313
7741
7742	.
7743	<a href="foo\
7744	bar">
7745	.
7746	<p><a href="foo\
7747	bar"></p>
7748	.
7749
7750	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7751	src line: 9326
7752
7753	.
7754	foo\
7755	.
7756	<p>foo\</p>
7757	.
7758
7759	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7760	src line: 9333
7761
7762	.
7763	foo
7764	.
7765	<p>foo</p>
7766	.
7767
7768	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7769	src line: 9340
7770
7771	.
7772	### foo\
7773	.
7774	<h3>foo\</h3>
7775	.
7776
7777	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7778	src line: 9347
7779
7780	.
7781	### foo
7782	.
7783	<h3>foo</h3>
7784	.
7785
7786	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7787	src line: 9362
7788
7789	.
7790	foo
7791	baz
7792	.
7793	<p>foo
7794	baz</p>
7795	.
7796
7797	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7798	src line: 9374
7799
7800	.
7801	foo
7802	baz
7803	.
7804	<p>foo
7805	baz</p>
7806	.
7807
7808	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7809	src line: 9394
7810
7811	.
7812	hello $.;'there
7813	.
7814	<p>hello $.;'there</p>
7815	.
7816
7817	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7818	src line: 9401
7819
7820	.
7821	Foo χρῆν
7822	.
7823	<p>Foo χρῆν</p>
7824	.
7825
7826	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7827	src line: 9410
7828
7829	.
7830	Multiple spaces
7831	.
7832	<p>Multiple spaces</p>
7833	.
7834

crates/markdown-it/tests/fixtures/commonmark/spec.txt created+9756

...	@@ -0,0 +1,9756 @@
1	---
2	title: CommonMark Spec
3	author: John MacFarlane
4	version: 0.30
5	date: '2021-06-19'
6	license: '[CC-BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/)'
7	...
8
9	# Introduction
10
11	## What is Markdown?
12
13	Markdown is a plain text format for writing structured documents,
14	based on conventions for indicating formatting in email
15	and usenet posts. It was developed by John Gruber (with
16	help from Aaron Swartz) and released in 2004 in the form of a
17	[syntax description](http://daringfireball.net/projects/markdown/syntax)
18	and a Perl script (`Markdown.pl`) for converting Markdown to
19	HTML. In the next decade, dozens of implementations were
20	developed in many languages. Some extended the original
21	Markdown syntax with conventions for footnotes, tables, and
22	other document elements. Some allowed Markdown documents to be
23	rendered in formats other than HTML. Websites like Reddit,
24	StackOverflow, and GitHub had millions of people using Markdown.
25	And Markdown started to be used beyond the web, to author books,
26	articles, slide shows, letters, and lecture notes.
27
28	What distinguishes Markdown from many other lightweight markup
29	syntaxes, which are often easier to write, is its readability.
30	As Gruber writes:
31
32	> The overriding design goal for Markdown's formatting syntax is
33	> to make it as readable as possible. The idea is that a
34	> Markdown-formatted document should be publishable as-is, as
35	> plain text, without looking like it's been marked up with tags
36	> or formatting instructions.
37	> (<http://daringfireball.net/projects/markdown/>)
38
39	The point can be illustrated by comparing a sample of
40	[AsciiDoc](http://www.methods.co.nz/asciidoc/) with
41	an equivalent sample of Markdown. Here is a sample of
42	AsciiDoc from the AsciiDoc manual:
43
44	```
45	1. List item one.
46	+
47	List item one continued with a second paragraph followed by an
48	Indented block.
49	+
50	.................
51	$ ls *.sh
52	$ mv *.sh ~/tmp
53	.................
54	+
55	List item continued with a third paragraph.
56
57	2. List item two continued with an open block.
58	+
59	--
60	This paragraph is part of the preceding list item.
61
62	a. This list is nested and does not require explicit item
63	continuation.
64	+
65	This paragraph is part of the preceding list item.
66
67	b. List item b.
68
69	This paragraph belongs to item two of the outer list.
70	--
71	```
72
73	And here is the equivalent in Markdown:
74	```
75	1. List item one.
76
77	List item one continued with a second paragraph followed by an
78	Indented block.
79
80	$ ls *.sh
81	$ mv *.sh ~/tmp
82
83	List item continued with a third paragraph.
84
85	2. List item two continued with an open block.
86
87	This paragraph is part of the preceding list item.
88
89	1. This list is nested and does not require explicit item continuation.
90
91	This paragraph is part of the preceding list item.
92
93	2. List item b.
94
95	This paragraph belongs to item two of the outer list.
96	```
97
98	The AsciiDoc version is, arguably, easier to write. You don't need
99	to worry about indentation. But the Markdown version is much easier
100	to read. The nesting of list items is apparent to the eye in the
101	source, not just in the processed document.
102
103	## Why is a spec needed?
104
105	John Gruber's [canonical description of Markdown's
106	syntax](http://daringfireball.net/projects/markdown/syntax)
107	does not specify the syntax unambiguously. Here are some examples of
108	questions it does not answer:
109
110	1. How much indentation is needed for a sublist? The spec says that
111	continuation paragraphs need to be indented four spaces, but is
112	not fully explicit about sublists. It is natural to think that
113	they, too, must be indented four spaces, but `Markdown.pl` does
114	not require that. This is hardly a "corner case," and divergences
115	between implementations on this issue often lead to surprises for
116	users in real documents. (See [this comment by John
117	Gruber](http://article.gmane.org/gmane.text.markdown.general/1997).)
118
119	2. Is a blank line needed before a block quote or heading?
120	Most implementations do not require the blank line. However,
121	this can lead to unexpected results in hard-wrapped text, and
122	also to ambiguities in parsing (note that some implementations
123	put the heading inside the blockquote, while others do not).
124	(John Gruber has also spoken [in favor of requiring the blank
125	lines](http://article.gmane.org/gmane.text.markdown.general/2146).)
126
127	3. Is a blank line needed before an indented code block?
128	(`Markdown.pl` requires it, but this is not mentioned in the
129	documentation, and some implementations do not require it.)
130
131	``` markdown
132	paragraph
133	code?
134	```
135
136	4. What is the exact rule for determining when list items get
137	wrapped in `<p>` tags? Can a list be partially "loose" and partially
138	"tight"? What should we do with a list like this?
139
140	``` markdown
141	1. one
142
143	2. two
144	3. three
145	```
146
147	Or this?
148
149	``` markdown
150	1. one
151	- a
152
153	- b
154	2. two
155	```
156
157	(There are some relevant comments by John Gruber
158	[here](http://article.gmane.org/gmane.text.markdown.general/2554).)
159
160	5. Can list markers be indented? Can ordered list markers be right-aligned?
161
162	``` markdown
163	8. item 1
164	9. item 2
165	10. item 2a
166	```
167
168	6. Is this one list with a thematic break in its second item,
169	or two lists separated by a thematic break?
170
171	``` markdown
172	* a
173	* * * * *
174	* b
175	```
176
177	7. When list markers change from numbers to bullets, do we have
178	two lists or one? (The Markdown syntax description suggests two,
179	but the perl scripts and many other implementations produce one.)
180
181	``` markdown
182	1. fee
183	2. fie
184	- foe
185	- fum
186	```
187
188	8. What are the precedence rules for the markers of inline structure?
189	For example, is the following a valid link, or does the code span
190	take precedence ?
191
192	``` markdown
193	[a backtick (`)](/url) and [another backtick (`)](/url).
194	```
195
196	9. What are the precedence rules for markers of emphasis and strong
197	emphasis? For example, how should the following be parsed?
198
199	``` markdown
200	foo bar* baz*
201	```
202
203	10. What are the precedence rules between block-level and inline-level
204	structure? For example, how should the following be parsed?
205
206	``` markdown
207	- `a long code span can contain a hyphen like this
208	- and it can screw things up`
209	```
210
211	11. Can list items include section headings? (`Markdown.pl` does not
212	allow this, but does allow blockquotes to include headings.)
213
214	``` markdown
215	- # Heading
216	```
217
218	12. Can list items be empty?
219
220	``` markdown
221	* a
222	*
223	* b
224	```
225
226	13. Can link references be defined inside block quotes or list items?
227
228	``` markdown
229	> Blockquote [foo].
230	>
231	> [foo]: /url
232	```
233
234	14. If there are multiple definitions for the same reference, which takes
235	precedence?
236
237	``` markdown
238	[foo]: /url1
239	[foo]: /url2
240
241	[foo][]
242	```
243
244	In the absence of a spec, early implementers consulted `Markdown.pl`
245	to resolve these ambiguities. But `Markdown.pl` was quite buggy, and
246	gave manifestly bad results in many cases, so it was not a
247	satisfactory replacement for a spec.
248
249	Because there is no unambiguous spec, implementations have diverged
250	considerably. As a result, users are often surprised to find that
251	a document that renders one way on one system (say, a GitHub wiki)
252	renders differently on another (say, converting to docbook using
253	pandoc). To make matters worse, because nothing in Markdown counts
254	as a "syntax error," the divergence often isn't discovered right away.
255
256	## About this document
257
258	This document attempts to specify Markdown syntax unambiguously.
259	It contains many examples with side-by-side Markdown and
260	HTML. These are intended to double as conformance tests. An
261	accompanying script `spec_tests.py` can be used to run the tests
262	against any Markdown program:
263
264	python test/spec_tests.py --spec spec.txt --program PROGRAM
265
266	Since this document describes how Markdown is to be parsed into
267	an abstract syntax tree, it would have made sense to use an abstract
268	representation of the syntax tree instead of HTML. But HTML is capable
269	of representing the structural distinctions we need to make, and the
270	choice of HTML for the tests makes it possible to run the tests against
271	an implementation without writing an abstract syntax tree renderer.
272
273	Note that not every feature of the HTML samples is mandated by
274	the spec. For example, the spec says what counts as a link
275	destination, but it doesn't mandate that non-ASCII characters in
276	the URL be percent-encoded. To use the automatic tests,
277	implementers will need to provide a renderer that conforms to
278	the expectations of the spec examples (percent-encoding
279	non-ASCII characters in URLs). But a conforming implementation
280	can use a different renderer and may choose not to
281	percent-encode non-ASCII characters in URLs.
282
283	This document is generated from a text file, `spec.txt`, written
284	in Markdown with a small extension for the side-by-side tests.
285	The script `tools/makespec.py` can be used to convert `spec.txt` into
286	HTML or CommonMark (which can then be converted into other formats).
287
288	In the examples, the `→` character is used to represent tabs.
289
290	# Preliminaries
291
292	## Characters and lines
293
294	Any sequence of [characters] is a valid CommonMark
295	document.
296
297	A [character](@) is a Unicode code point. Although some
298	code points (for example, combining accents) do not correspond to
299	characters in an intuitive sense, all code points count as characters
300	for purposes of this spec.
301
302	This spec does not specify an encoding; it thinks of lines as composed
303	of [characters] rather than bytes. A conforming parser may be limited
304	to a certain encoding.
305
306	A [line](@) is a sequence of zero or more [characters]
307	other than line feed (`U+000A`) or carriage return (`U+000D`),
308	followed by a [line ending] or by the end of file.
309
310	A [line ending](@) is a line feed (`U+000A`), a carriage return
311	(`U+000D`) not followed by a line feed, or a carriage return and a
312	following line feed.
313
314	A line containing no characters, or a line containing only spaces
315	(`U+0020`) or tabs (`U+0009`), is called a [blank line](@).
316
317	The following definitions of character classes will be used in this spec:
318
319	A [Unicode whitespace character](@) is
320	any code point in the Unicode `Zs` general category, or a tab (`U+0009`),
321	line feed (`U+000A`), form feed (`U+000C`), or carriage return (`U+000D`).
322
323	[Unicode whitespace](@) is a sequence of one or more
324	[Unicode whitespace characters].
325
326	A [tab](@) is `U+0009`.
327
328	A [space](@) is `U+0020`.
329
330	An [ASCII control character](@) is a character between `U+0000–1F` (both
331	including) or `U+007F`.
332
333	An [ASCII punctuation character](@)
334	is `!`, `"`, `#`, `$`, `%`, `&`, `'`, `(`, `)`,
335	`*`, `+`, `,`, `-`, `.`, `/` (U+0021–2F),
336	`:`, `;`, `<`, `=`, `>`, `?`, `@` (U+003A–0040),
337	`[`, `\`, `]`, `^`, `_`, `` ` `` (U+005B–0060),
338	`{`, `\|`, `}`, or `~` (U+007B–007E).
339
340	A [Unicode punctuation character](@) is an [ASCII
341	punctuation character] or anything in
342	the general Unicode categories `Pc`, `Pd`, `Pe`, `Pf`, `Pi`, `Po`, or `Ps`.
343
344	## Tabs
345
346	Tabs in lines are not expanded to [spaces]. However,
347	in contexts where spaces help to define block structure,
348	tabs behave as if they were replaced by spaces with a tab stop
349	of 4 characters.
350
351	Thus, for example, a tab can be used instead of four spaces
352	in an indented code block. (Note, however, that internal
353	tabs are passed through as literal tabs, not expanded to
354	spaces.)
355
356	```````````````````````````````` example
357	→foo→baz→→bim
358	.
359	<pre><code>foo→baz→→bim
360	</code></pre>
361	````````````````````````````````
362
363	```````````````````````````````` example
364	→foo→baz→→bim
365	.
366	<pre><code>foo→baz→→bim
367	</code></pre>
368	````````````````````````````````
369
370	```````````````````````````````` example
371	a→a
372	ὐ→a
373	.
374	<pre><code>a→a
375	ὐ→a
376	</code></pre>
377	````````````````````````````````
378
379	In the following example, a continuation paragraph of a list
380	item is indented with a tab; this has exactly the same effect
381	as indentation with four spaces would:
382
383	```````````````````````````````` example
384	- foo
385
386	→bar
387	.
388	<ul>
389	<li>
390	<p>foo</p>
391	<p>bar</p>
392	</li>
393	</ul>
394	````````````````````````````````
395
396	```````````````````````````````` example
397	- foo
398
399	→→bar
400	.
401	<ul>
402	<li>
403	<p>foo</p>
404	<pre><code> bar
405	</code></pre>
406	</li>
407	</ul>
408	````````````````````````````````
409
410	Normally the `>` that begins a block quote may be followed
411	optionally by a space, which is not considered part of the
412	content. In the following case `>` is followed by a tab,
413	which is treated as if it were expanded into three spaces.
414	Since one of these spaces is considered part of the
415	delimiter, `foo` is considered to be indented six spaces
416	inside the block quote context, so we get an indented
417	code block starting with two spaces.
418
419	```````````````````````````````` example
420	>→→foo
421	.
422	<blockquote>
423	<pre><code> foo
424	</code></pre>
425	</blockquote>
426	````````````````````````````````
427
428	```````````````````````````````` example
429	-→→foo
430	.
431	<ul>
432	<li>
433	<pre><code> foo
434	</code></pre>
435	</li>
436	</ul>
437	````````````````````````````````
438
439
440	```````````````````````````````` example
441	foo
442	→bar
443	.
444	<pre><code>foo
445	bar
446	</code></pre>
447	````````````````````````````````
448
449	```````````````````````````````` example
450	- foo
451	- bar
452	→ - baz
453	.
454	<ul>
455	<li>foo
456	<ul>
457	<li>bar
458	<ul>
459	<li>baz</li>
460	</ul>
461	</li>
462	</ul>
463	</li>
464	</ul>
465	````````````````````````````````
466
467	```````````````````````````````` example
468	#→Foo
469	.
470	<h1>Foo</h1>
471	````````````````````````````````
472
473	```````````````````````````````` example
474	→→*→
475	.
476	<hr />
477	````````````````````````````````
478
479
480	## Insecure characters
481
482	For security reasons, the Unicode character `U+0000` must be replaced
483	with the REPLACEMENT CHARACTER (`U+FFFD`).
484
485
486	## Backslash escapes
487
488	Any ASCII punctuation character may be backslash-escaped:
489
490	```````````````````````````````` example
491	\!\"\#\$\%\&\'\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\\|\}\~
492	.
493	<p>!"#$%&'()*+,-./:;<=>?@[\]^_`{\|}~</p>
494	````````````````````````````````
495
496
497	Backslashes before other characters are treated as literal
498	backslashes:
499
500	```````````````````````````````` example
501	\→\A\a\ \3\φ\«
502	.
503	<p>\→\A\a\ \3\φ\«</p>
504	````````````````````````````````
505
506
507	Escaped characters are treated as regular characters and do
508	not have their usual Markdown meanings:
509
510	```````````````````````````````` example
511	\not emphasized
512	\<br/> not a tag
513	\[not a link](/foo)
514	\`not code`
515	1\. not a list
516	\* not a list
517	\# not a heading
518	\[foo]: /url "not a reference"
519	\ö not a character entity
520	.
521	<p>not emphasized
522	<br/> not a tag
523	[not a link](/foo)
524	`not code`
525	1. not a list
526	* not a list
527	# not a heading
528	[foo]: /url "not a reference"
529	&ouml; not a character entity</p>
530	````````````````````````````````
531
532
533	If a backslash is itself escaped, the following character is not:
534
535	```````````````````````````````` example
536	\\emphasis
537	.
538	<p>\<em>emphasis</em></p>
539	````````````````````````````````
540
541
542	A backslash at the end of the line is a [hard line break]:
543
544	```````````````````````````````` example
545	foo\
546	bar
547	.
548	<p>foo<br />
549	bar</p>
550	````````````````````````````````
551
552
553	Backslash escapes do not work in code blocks, code spans, autolinks, or
554	raw HTML:
555
556	```````````````````````````````` example
557	`` \[\` ``
558	.
559	<p><code>\[\`</code></p>
560	````````````````````````````````
561
562
563	```````````````````````````````` example
564	\[\]
565	.
566	<pre><code>\[\]
567	</code></pre>
568	````````````````````````````````
569
570
571	```````````````````````````````` example
572	~~~
573	\[\]
574	~~~
575	.
576	<pre><code>\[\]
577	</code></pre>
578	````````````````````````````````
579
580
581	```````````````````````````````` example
582	<http://example.com?find=\*>
583	.
584	<p><a href="http://example.com?find=%5C">http://example.com?find=\</a></p>
585	````````````````````````````````
586
587
588	```````````````````````````````` example
589	<a href="/bar\/)">
590	.
591	<a href="/bar\/)">
592	````````````````````````````````
593
594
595	But they work in all other contexts, including URLs and link titles,
596	link references, and [info strings] in [fenced code blocks]:
597
598	```````````````````````````````` example
599	[foo](/bar\* "ti\*tle")
600	.
601	<p><a href="/bar" title="title">foo</a></p>
602	````````````````````````````````
603
604
605	```````````````````````````````` example
606	[foo]
607
608	[foo]: /bar\* "ti\*tle"
609	.
610	<p><a href="/bar" title="title">foo</a></p>
611	````````````````````````````````
612
613
614	```````````````````````````````` example
615	``` foo\+bar
616	foo
617	```
618	.
619	<pre><code class="language-foo+bar">foo
620	</code></pre>
621	````````````````````````````````
622
623
624	## Entity and numeric character references
625
626	Valid HTML entity references and numeric character references
627	can be used in place of the corresponding Unicode character,
628	with the following exceptions:
629
630	- Entity and character references are not recognized in code
631	blocks and code spans.
632
633	- Entity and character references cannot stand in place of
634	special characters that define structural elements in
635	CommonMark. For example, although `*` can be used
636	in place of a literal `` character, `` cannot replace
637	`*` in emphasis delimiters, bullet list markers, or thematic
638	breaks.
639
640	Conforming CommonMark parsers need not store information about
641	whether a particular character was represented in the source
642	using a Unicode character or an entity reference.
643
644	[Entity references](@) consist of `&` + any of the valid
645	HTML5 entity names + `;`. The
646	document <https://html.spec.whatwg.org/entities.json>
647	is used as an authoritative source for the valid entity
648	references and their corresponding code points.
649
650	```````````````````````````````` example
651	& © Æ &Dcaron;
652	¾ &HilbertSpace; &DifferentialD;
653	&ClockwiseContourIntegral; &ngE;
654	.
655	<p> & © Æ Ď
656	¾ ℋ ⅆ
657	∲ ≧̸</p>
658	````````````````````````````````
659
660
661	[Decimal numeric character
662	references](@)
663	consist of `&#` + a string of 1--7 arabic digits + `;`. A
664	numeric character reference is parsed as the corresponding
665	Unicode character. Invalid Unicode code points will be replaced by
666	the REPLACEMENT CHARACTER (`U+FFFD`). For security reasons,
667	the code point `U+0000` will also be replaced by `U+FFFD`.
668
669	```````````````````````````````` example
670	# Ӓ Ϡ
671	.
672	<p># Ӓ Ϡ �</p>
673	````````````````````````````````
674
675
676	[Hexadecimal numeric character
677	references](@) consist of `&#` +
678	either `X` or `x` + a string of 1-6 hexadecimal digits + `;`.
679	They too are parsed as the corresponding Unicode character (this
680	time specified with a hexadecimal numeral instead of decimal).
681
682	```````````````````````````````` example
683	&#X22; &#XD06; ಫ
684	.
685	<p>" ആ ಫ</p>
686	````````````````````````````````
687
688
689	Here are some nonentities:
690
691	```````````````````````````````` example
692	&nbsp &x; &#; &#x;
693	&#87654321;
694	&#abcdef0;
695	&ThisIsNotDefined; &hi?;
696	.
697	<p>&nbsp &x; &#; &#x;
698	&#87654321;
699	&#abcdef0;
700	&ThisIsNotDefined; &hi?;</p>
701	````````````````````````````````
702
703
704	Although HTML5 does accept some entity references
705	without a trailing semicolon (such as `&copy`), these are not
706	recognized here, because it makes the grammar too ambiguous:
707
708	```````````````````````````````` example
709	&copy
710	.
711	<p>&copy</p>
712	````````````````````````````````
713
714
715	Strings that are not on the list of HTML5 named entities are not
716	recognized as entity references either:
717
718	```````````````````````````````` example
719	&MadeUpEntity;
720	.
721	<p>&MadeUpEntity;</p>
722	````````````````````````````````
723
724
725	Entity and numeric character references are recognized in any
726	context besides code spans or code blocks, including
727	URLs, [link titles], and [fenced code block][] [info strings]:
728
729	```````````````````````````````` example
730	<a href="öö.html">
731	.
732	<a href="öö.html">
733	````````````````````````````````
734
735
736	```````````````````````````````` example
737	[foo](/föö "föö")
738	.
739	<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
740	````````````````````````````````
741
742
743	```````````````````````````````` example
744	[foo]
745
746	[foo]: /föö "föö"
747	.
748	<p><a href="/f%C3%B6%C3%B6" title="föö">foo</a></p>
749	````````````````````````````````
750
751
752	```````````````````````````````` example
753	``` föö
754	foo
755	```
756	.
757	<pre><code class="language-föö">foo
758	</code></pre>
759	````````````````````````````````
760
761
762	Entity and numeric character references are treated as literal
763	text in code spans and code blocks:
764
765	```````````````````````````````` example
766	`föö`
767	.
768	<p><code>f&ouml;&ouml;</code></p>
769	````````````````````````````````
770
771
772	```````````````````````````````` example
773	föfö
774	.
775	<pre><code>f&ouml;f&ouml;
776	</code></pre>
777	````````````````````````````````
778
779
780	Entity and numeric character references cannot be used
781	in place of symbols indicating structure in CommonMark
782	documents.
783
784	```````````````````````````````` example
785	foo
786	foo
787	.
788	<p>foo
789	<em>foo</em></p>
790	````````````````````````````````
791
792	```````````````````````````````` example
793	* foo
794
795	* foo
796	.
797	<p>* foo</p>
798	<ul>
799	<li>foo</li>
800	</ul>
801	````````````````````````````````
802
803	```````````````````````````````` example
804	foo bar
805	.
806	<p>foo
807
808	bar</p>
809	````````````````````````````````
810
811	```````````````````````````````` example
812	foo
813	.
814	<p>→foo</p>
815	````````````````````````````````
816
817
818	```````````````````````````````` example
819	[a](url "tit")
820	.
821	<p>[a](url "tit")</p>
822	````````````````````````````````
823
824
825
826	# Blocks and inlines
827
828	We can think of a document as a sequence of
829	[blocks](@)---structural elements like paragraphs, block
830	quotations, lists, headings, rules, and code blocks. Some blocks (like
831	block quotes and list items) contain other blocks; others (like
832	headings and paragraphs) contain [inline](@) content---text,
833	links, emphasized text, images, code spans, and so on.
834
835	## Precedence
836
837	Indicators of block structure always take precedence over indicators
838	of inline structure. So, for example, the following is a list with
839	two items, not a list with one item containing a code span:
840
841	```````````````````````````````` example
842	- `one
843	- two`
844	.
845	<ul>
846	<li>`one</li>
847	<li>two`</li>
848	</ul>
849	````````````````````````````````
850
851
852	This means that parsing can proceed in two steps: first, the block
853	structure of the document can be discerned; second, text lines inside
854	paragraphs, headings, and other block constructs can be parsed for inline
855	structure. The second step requires information about link reference
856	definitions that will be available only at the end of the first
857	step. Note that the first step requires processing lines in sequence,
858	but the second can be parallelized, since the inline parsing of
859	one block element does not affect the inline parsing of any other.
860
861	## Container blocks and leaf blocks
862
863	We can divide blocks into two types:
864	[container blocks](#container-blocks),
865	which can contain other blocks, and [leaf blocks](#leaf-blocks),
866	which cannot.
867
868	# Leaf blocks
869
870	This section describes the different kinds of leaf block that make up a
871	Markdown document.
872
873	## Thematic breaks
874
875	A line consisting of optionally up to three spaces of indentation, followed by a
876	sequence of three or more matching `-`, `_`, or `*` characters, each followed
877	optionally by any number of spaces or tabs, forms a
878	[thematic break](@).
879
880	```````````````````````````````` example
881	***
882	---
883	___
884	.
885	<hr />
886	<hr />
887	<hr />
888	````````````````````````````````
889
890
891	Wrong characters:
892
893	```````````````````````````````` example
894	+++
895	.
896	<p>+++</p>
897	````````````````````````````````
898
899
900	```````````````````````````````` example
901	===
902	.
903	<p>===</p>
904	````````````````````````````````
905
906
907	Not enough characters:
908
909	```````````````````````````````` example
910	--
911	**
912	__
913	.
914	<p>--
915	**
916	__</p>
917	````````````````````````````````
918
919
920	Up to three spaces of indentation are allowed:
921
922	```````````````````````````````` example
923	***
924	***
925	***
926	.
927	<hr />
928	<hr />
929	<hr />
930	````````````````````````````````
931
932
933	Four spaces of indentation is too many:
934
935	```````````````````````````````` example
936	***
937	.
938	<pre><code>***
939	</code></pre>
940	````````````````````````````````
941
942
943	```````````````````````````````` example
944	Foo
945	***
946	.
947	<p>Foo
948	***</p>
949	````````````````````````````````
950
951
952	More than three characters may be used:
953
954	```````````````````````````````` example
955	_____________________________________
956	.
957	<hr />
958	````````````````````````````````
959
960
961	Spaces and tabs are allowed between the characters:
962
963	```````````````````````````````` example
964	- - -
965	.
966	<hr />
967	````````````````````````````````
968
969
970	```````````````````````````````` example
971	** * ** * ** * **
972	.
973	<hr />
974	````````````````````````````````
975
976
977	```````````````````````````````` example
978	- - - -
979	.
980	<hr />
981	````````````````````````````````
982
983
984	Spaces and tabs are allowed at the end:
985
986	```````````````````````````````` example
987	- - - -
988	.
989	<hr />
990	````````````````````````````````
991
992
993	However, no other characters may occur in the line:
994
995	```````````````````````````````` example
996	_ _ _ _ a
997
998	a------
999
1000	---a---
1001	.
1002	<p>_ _ _ _ a</p>
1003	<p>a------</p>
1004	<p>---a---</p>
1005	````````````````````````````````
1006
1007
1008	It is required that all of the characters other than spaces or tabs be the same.
1009	So, this is not a thematic break:
1010
1011	```````````````````````````````` example
1012	-
1013	.
1014	<p><em>-</em></p>
1015	````````````````````````````````
1016
1017
1018	Thematic breaks do not need blank lines before or after:
1019
1020	```````````````````````````````` example
1021	- foo
1022	***
1023	- bar
1024	.
1025	<ul>
1026	<li>foo</li>
1027	</ul>
1028	<hr />
1029	<ul>
1030	<li>bar</li>
1031	</ul>
1032	````````````````````````````````
1033
1034
1035	Thematic breaks can interrupt a paragraph:
1036
1037	```````````````````````````````` example
1038	Foo
1039	***
1040	bar
1041	.
1042	<p>Foo</p>
1043	<hr />
1044	<p>bar</p>
1045	````````````````````````````````
1046
1047
1048	If a line of dashes that meets the above conditions for being a
1049	thematic break could also be interpreted as the underline of a [setext
1050	heading], the interpretation as a
1051	[setext heading] takes precedence. Thus, for example,
1052	this is a setext heading, not a paragraph followed by a thematic break:
1053
1054	```````````````````````````````` example
1055	Foo
1056	---
1057	bar
1058	.
1059	<h2>Foo</h2>
1060	<p>bar</p>
1061	````````````````````````````````
1062
1063
1064	When both a thematic break and a list item are possible
1065	interpretations of a line, the thematic break takes precedence:
1066
1067	```````````````````````````````` example
1068	* Foo
1069	* * *
1070	* Bar
1071	.
1072	<ul>
1073	<li>Foo</li>
1074	</ul>
1075	<hr />
1076	<ul>
1077	<li>Bar</li>
1078	</ul>
1079	````````````````````````````````
1080
1081
1082	If you want a thematic break in a list item, use a different bullet:
1083
1084	```````````````````````````````` example
1085	- Foo
1086	- * * *
1087	.
1088	<ul>
1089	<li>Foo</li>
1090	<li>
1091	<hr />
1092	</li>
1093	</ul>
1094	````````````````````````````````
1095
1096
1097	## ATX headings
1098
1099	An [ATX heading](@)
1100	consists of a string of characters, parsed as inline content, between an
1101	opening sequence of 1--6 unescaped `#` characters and an optional
1102	closing sequence of any number of unescaped `#` characters.
1103	The opening sequence of `#` characters must be followed by spaces or tabs, or
1104	by the end of line. The optional closing sequence of `#`s must be preceded by
1105	spaces or tabs and may be followed by spaces or tabs only. The opening
1106	`#` character may be preceded by up to three spaces of indentation. The raw
1107	contents of the heading are stripped of leading and trailing space or tabs
1108	before being parsed as inline content. The heading level is equal to the number
1109	of `#` characters in the opening sequence.
1110
1111	Simple headings:
1112
1113	```````````````````````````````` example
1114	# foo
1115	## foo
1116	### foo
1117	#### foo
1118	##### foo
1119	###### foo
1120	.
1121	<h1>foo</h1>
1122	<h2>foo</h2>
1123	<h3>foo</h3>
1124	<h4>foo</h4>
1125	<h5>foo</h5>
1126	<h6>foo</h6>
1127	````````````````````````````````
1128
1129
1130	More than six `#` characters is not a heading:
1131
1132	```````````````````````````````` example
1133	####### foo
1134	.
1135	<p>####### foo</p>
1136	````````````````````````````````
1137
1138
1139	At least one space or tab is required between the `#` characters and the
1140	heading's contents, unless the heading is empty. Note that many
1141	implementations currently do not require the space. However, the
1142	space was required by the
1143	[original ATX implementation](http://www.aaronsw.com/2002/atx/atx.py),
1144	and it helps prevent things like the following from being parsed as
1145	headings:
1146
1147	```````````````````````````````` example
1148	#5 bolt
1149
1150	#hashtag
1151	.
1152	<p>#5 bolt</p>
1153	<p>#hashtag</p>
1154	````````````````````````````````
1155
1156
1157	This is not a heading, because the first `#` is escaped:
1158
1159	```````````````````````````````` example
1160	\## foo
1161	.
1162	<p>## foo</p>
1163	````````````````````````````````
1164
1165
1166	Contents are parsed as inlines:
1167
1168	```````````````````````````````` example
1169	# foo bar \baz\
1170	.
1171	<h1>foo <em>bar</em> baz</h1>
1172	````````````````````````````````
1173
1174
1175	Leading and trailing spaces or tabs are ignored in parsing inline content:
1176
1177	```````````````````````````````` example
1178	# foo
1179	.
1180	<h1>foo</h1>
1181	````````````````````````````````
1182
1183
1184	Up to three spaces of indentation are allowed:
1185
1186	```````````````````````````````` example
1187	### foo
1188	## foo
1189	# foo
1190	.
1191	<h3>foo</h3>
1192	<h2>foo</h2>
1193	<h1>foo</h1>
1194	````````````````````````````````
1195
1196
1197	Four spaces of indentation is too many:
1198
1199	```````````````````````````````` example
1200	# foo
1201	.
1202	<pre><code># foo
1203	</code></pre>
1204	````````````````````````````````
1205
1206
1207	```````````````````````````````` example
1208	foo
1209	# bar
1210	.
1211	<p>foo
1212	# bar</p>
1213	````````````````````````````````
1214
1215
1216	A closing sequence of `#` characters is optional:
1217
1218	```````````````````````````````` example
1219	## foo ##
1220	### bar ###
1221	.
1222	<h2>foo</h2>
1223	<h3>bar</h3>
1224	````````````````````````````````
1225
1226
1227	It need not be the same length as the opening sequence:
1228
1229	```````````````````````````````` example
1230	# foo ##################################
1231	##### foo ##
1232	.
1233	<h1>foo</h1>
1234	<h5>foo</h5>
1235	````````````````````````````````
1236
1237
1238	Spaces or tabs are allowed after the closing sequence:
1239
1240	```````````````````````````````` example
1241	### foo ###
1242	.
1243	<h3>foo</h3>
1244	````````````````````````````````
1245
1246
1247	A sequence of `#` characters with anything but spaces or tabs following it
1248	is not a closing sequence, but counts as part of the contents of the
1249	heading:
1250
1251	```````````````````````````````` example
1252	### foo ### b
1253	.
1254	<h3>foo ### b</h3>
1255	````````````````````````````````
1256
1257
1258	The closing sequence must be preceded by a space or tab:
1259
1260	```````````````````````````````` example
1261	# foo#
1262	.
1263	<h1>foo#</h1>
1264	````````````````````````````````
1265
1266
1267	Backslash-escaped `#` characters do not count as part
1268	of the closing sequence:
1269
1270	```````````````````````````````` example
1271	### foo \###
1272	## foo #\##
1273	# foo \#
1274	.
1275	<h3>foo ###</h3>
1276	<h2>foo ###</h2>
1277	<h1>foo #</h1>
1278	````````````````````````````````
1279
1280
1281	ATX headings need not be separated from surrounding content by blank
1282	lines, and they can interrupt paragraphs:
1283
1284	```````````````````````````````` example
1285	****
1286	## foo
1287	****
1288	.
1289	<hr />
1290	<h2>foo</h2>
1291	<hr />
1292	````````````````````````````````
1293
1294
1295	```````````````````````````````` example
1296	Foo bar
1297	# baz
1298	Bar foo
1299	.
1300	<p>Foo bar</p>
1301	<h1>baz</h1>
1302	<p>Bar foo</p>
1303	````````````````````````````````
1304
1305
1306	ATX headings can be empty:
1307
1308	```````````````````````````````` example
1309	##
1310	#
1311	### ###
1312	.
1313	<h2></h2>
1314	<h1></h1>
1315	<h3></h3>
1316	````````````````````````````````
1317
1318
1319	## Setext headings
1320
1321	A [setext heading](@) consists of one or more
1322	lines of text, not interrupted by a blank line, of which the first line does not
1323	have more than 3 spaces of indentation, followed by
1324	a [setext heading underline]. The lines of text must be such
1325	that, were they not followed by the setext heading underline,
1326	they would be interpreted as a paragraph: they cannot be
1327	interpretable as a [code fence], [ATX heading][ATX headings],
1328	[block quote][block quotes], [thematic break][thematic breaks],
1329	[list item][list items], or [HTML block][HTML blocks].
1330
1331	A [setext heading underline](@) is a sequence of
1332	`=` characters or a sequence of `-` characters, with no more than 3
1333	spaces of indentation and any number of trailing spaces or tabs. If a line
1334	containing a single `-` can be interpreted as an
1335	empty [list items], it should be interpreted this way
1336	and not as a [setext heading underline].
1337
1338	The heading is a level 1 heading if `=` characters are used in
1339	the [setext heading underline], and a level 2 heading if `-`
1340	characters are used. The contents of the heading are the result
1341	of parsing the preceding lines of text as CommonMark inline
1342	content.
1343
1344	In general, a setext heading need not be preceded or followed by a
1345	blank line. However, it cannot interrupt a paragraph, so when a
1346	setext heading comes after a paragraph, a blank line is needed between
1347	them.
1348
1349	Simple examples:
1350
1351	```````````````````````````````` example
1352	Foo bar
1353	=========
1354
1355	Foo bar
1356	---------
1357	.
1358	<h1>Foo <em>bar</em></h1>
1359	<h2>Foo <em>bar</em></h2>
1360	````````````````````````````````
1361
1362
1363	The content of the header may span more than one line:
1364
1365	```````````````````````````````` example
1366	Foo *bar
1367	baz*
1368	====
1369	.
1370	<h1>Foo <em>bar
1371	baz</em></h1>
1372	````````````````````````````````
1373
1374	The contents are the result of parsing the headings's raw
1375	content as inlines. The heading's raw content is formed by
1376	concatenating the lines and removing initial and final
1377	spaces or tabs.
1378
1379	```````````````````````````````` example
1380	Foo *bar
1381	baz*→
1382	====
1383	.
1384	<h1>Foo <em>bar
1385	baz</em></h1>
1386	````````````````````````````````
1387
1388
1389	The underlining can be any length:
1390
1391	```````````````````````````````` example
1392	Foo
1393	-------------------------
1394
1395	Foo
1396	=
1397	.
1398	<h2>Foo</h2>
1399	<h1>Foo</h1>
1400	````````````````````````````````
1401
1402
1403	The heading content can be preceded by up to three spaces of indentation, and
1404	need not line up with the underlining:
1405
1406	```````````````````````````````` example
1407	Foo
1408	---
1409
1410	Foo
1411	-----
1412
1413	Foo
1414	===
1415	.
1416	<h2>Foo</h2>
1417	<h2>Foo</h2>
1418	<h1>Foo</h1>
1419	````````````````````````````````
1420
1421
1422	Four spaces of indentation is too many:
1423
1424	```````````````````````````````` example
1425	Foo
1426	---
1427
1428	Foo
1429	---
1430	.
1431	<pre><code>Foo
1432	---
1433
1434	Foo
1435	</code></pre>
1436	<hr />
1437	````````````````````````````````
1438
1439
1440	The setext heading underline can be preceded by up to three spaces of
1441	indentation, and may have trailing spaces or tabs:
1442
1443	```````````````````````````````` example
1444	Foo
1445	----
1446	.
1447	<h2>Foo</h2>
1448	````````````````````````````````
1449
1450
1451	Four spaces of indentation is too many:
1452
1453	```````````````````````````````` example
1454	Foo
1455	---
1456	.
1457	<p>Foo
1458	---</p>
1459	````````````````````````````````
1460
1461
1462	The setext heading underline cannot contain internal spaces or tabs:
1463
1464	```````````````````````````````` example
1465	Foo
1466	= =
1467
1468	Foo
1469	--- -
1470	.
1471	<p>Foo
1472	= =</p>
1473	<p>Foo</p>
1474	<hr />
1475	````````````````````````````````
1476
1477
1478	Trailing spaces or tabs in the content line do not cause a hard line break:
1479
1480	```````````````````````````````` example
1481	Foo
1482	-----
1483	.
1484	<h2>Foo</h2>
1485	````````````````````````````````
1486
1487
1488	Nor does a backslash at the end:
1489
1490	```````````````````````````````` example
1491	Foo\
1492	----
1493	.
1494	<h2>Foo\</h2>
1495	````````````````````````````````
1496
1497
1498	Since indicators of block structure take precedence over
1499	indicators of inline structure, the following are setext headings:
1500
1501	```````````````````````````````` example
1502	`Foo
1503	----
1504	`
1505
1506	<a title="a lot
1507	---
1508	of dashes"/>
1509	.
1510	<h2>`Foo</h2>
1511	<p>`</p>
1512	<h2><a title="a lot</h2>
1513	<p>of dashes"/></p>
1514	````````````````````````````````
1515
1516
1517	The setext heading underline cannot be a [lazy continuation
1518	line] in a list item or block quote:
1519
1520	```````````````````````````````` example
1521	> Foo
1522	---
1523	.
1524	<blockquote>
1525	<p>Foo</p>
1526	</blockquote>
1527	<hr />
1528	````````````````````````````````
1529
1530
1531	```````````````````````````````` example
1532	> foo
1533	bar
1534	===
1535	.
1536	<blockquote>
1537	<p>foo
1538	bar
1539	===</p>
1540	</blockquote>
1541	````````````````````````````````
1542
1543
1544	```````````````````````````````` example
1545	- Foo
1546	---
1547	.
1548	<ul>
1549	<li>Foo</li>
1550	</ul>
1551	<hr />
1552	````````````````````````````````
1553
1554
1555	A blank line is needed between a paragraph and a following
1556	setext heading, since otherwise the paragraph becomes part
1557	of the heading's content:
1558
1559	```````````````````````````````` example
1560	Foo
1561	Bar
1562	---
1563	.
1564	<h2>Foo
1565	Bar</h2>
1566	````````````````````````````````
1567
1568
1569	But in general a blank line is not required before or after
1570	setext headings:
1571
1572	```````````````````````````````` example
1573	---
1574	Foo
1575	---
1576	Bar
1577	---
1578	Baz
1579	.
1580	<hr />
1581	<h2>Foo</h2>
1582	<h2>Bar</h2>
1583	<p>Baz</p>
1584	````````````````````````````````
1585
1586
1587	Setext headings cannot be empty:
1588
1589	```````````````````````````````` example
1590
1591	====
1592	.
1593	<p>====</p>
1594	````````````````````````````````
1595
1596
1597	Setext heading text lines must not be interpretable as block
1598	constructs other than paragraphs. So, the line of dashes
1599	in these examples gets interpreted as a thematic break:
1600
1601	```````````````````````````````` example
1602	---
1603	---
1604	.
1605	<hr />
1606	<hr />
1607	````````````````````````````````
1608
1609
1610	```````````````````````````````` example
1611	- foo
1612	-----
1613	.
1614	<ul>
1615	<li>foo</li>
1616	</ul>
1617	<hr />
1618	````````````````````````````````
1619
1620
1621	```````````````````````````````` example
1622	foo
1623	---
1624	.
1625	<pre><code>foo
1626	</code></pre>
1627	<hr />
1628	````````````````````````````````
1629
1630
1631	```````````````````````````````` example
1632	> foo
1633	-----
1634	.
1635	<blockquote>
1636	<p>foo</p>
1637	</blockquote>
1638	<hr />
1639	````````````````````````````````
1640
1641
1642	If you want a heading with `> foo` as its literal text, you can
1643	use backslash escapes:
1644
1645	```````````````````````````````` example
1646	\> foo
1647	------
1648	.
1649	<h2>> foo</h2>
1650	````````````````````````````````
1651
1652
1653	Compatibility note: Most existing Markdown implementations
1654	do not allow the text of setext headings to span multiple lines.
1655	But there is no consensus about how to interpret
1656
1657	``` markdown
1658	Foo
1659	bar
1660	---
1661	baz
1662	```
1663
1664	One can find four different interpretations:
1665
1666	1. paragraph "Foo", heading "bar", paragraph "baz"
1667	2. paragraph "Foo bar", thematic break, paragraph "baz"
1668	3. paragraph "Foo bar --- baz"
1669	4. heading "Foo bar", paragraph "baz"
1670
1671	We find interpretation 4 most natural, and interpretation 4
1672	increases the expressive power of CommonMark, by allowing
1673	multiline headings. Authors who want interpretation 1 can
1674	put a blank line after the first paragraph:
1675
1676	```````````````````````````````` example
1677	Foo
1678
1679	bar
1680	---
1681	baz
1682	.
1683	<p>Foo</p>
1684	<h2>bar</h2>
1685	<p>baz</p>
1686	````````````````````````````````
1687
1688
1689	Authors who want interpretation 2 can put blank lines around
1690	the thematic break,
1691
1692	```````````````````````````````` example
1693	Foo
1694	bar
1695
1696	---
1697
1698	baz
1699	.
1700	<p>Foo
1701	bar</p>
1702	<hr />
1703	<p>baz</p>
1704	````````````````````````````````
1705
1706
1707	or use a thematic break that cannot count as a [setext heading
1708	underline], such as
1709
1710	```````````````````````````````` example
1711	Foo
1712	bar
1713	* * *
1714	baz
1715	.
1716	<p>Foo
1717	bar</p>
1718	<hr />
1719	<p>baz</p>
1720	````````````````````````````````
1721
1722
1723	Authors who want interpretation 3 can use backslash escapes:
1724
1725	```````````````````````````````` example
1726	Foo
1727	bar
1728	\---
1729	baz
1730	.
1731	<p>Foo
1732	bar
1733	---
1734	baz</p>
1735	````````````````````````````````
1736
1737
1738	## Indented code blocks
1739
1740	An [indented code block](@) is composed of one or more
1741	[indented chunks] separated by blank lines.
1742	An [indented chunk](@) is a sequence of non-blank lines,
1743	each preceded by four or more spaces of indentation. The contents of the code
1744	block are the literal contents of the lines, including trailing
1745	[line endings], minus four spaces of indentation.
1746	An indented code block has no [info string].
1747
1748	An indented code block cannot interrupt a paragraph, so there must be
1749	a blank line between a paragraph and a following indented code block.
1750	(A blank line is not needed, however, between a code block and a following
1751	paragraph.)
1752
1753	```````````````````````````````` example
1754	a simple
1755	indented code block
1756	.
1757	<pre><code>a simple
1758	indented code block
1759	</code></pre>
1760	````````````````````````````````
1761
1762
1763	If there is any ambiguity between an interpretation of indentation
1764	as a code block and as indicating that material belongs to a [list
1765	item][list items], the list item interpretation takes precedence:
1766
1767	```````````````````````````````` example
1768	- foo
1769
1770	bar
1771	.
1772	<ul>
1773	<li>
1774	<p>foo</p>
1775	<p>bar</p>
1776	</li>
1777	</ul>
1778	````````````````````````````````
1779
1780
1781	```````````````````````````````` example
1782	1. foo
1783
1784	- bar
1785	.
1786	<ol>
1787	<li>
1788	<p>foo</p>
1789	<ul>
1790	<li>bar</li>
1791	</ul>
1792	</li>
1793	</ol>
1794	````````````````````````````````
1795
1796
1797
1798	The contents of a code block are literal text, and do not get parsed
1799	as Markdown:
1800
1801	```````````````````````````````` example
1802	<a/>
1803	hi
1804
1805	- one
1806	.
1807	<pre><code><a/>
1808	hi
1809
1810	- one
1811	</code></pre>
1812	````````````````````````````````
1813
1814
1815	Here we have three chunks separated by blank lines:
1816
1817	```````````````````````````````` example
1818	chunk1
1819
1820	chunk2
1821
1822
1823
1824	chunk3
1825	.
1826	<pre><code>chunk1
1827
1828	chunk2
1829
1830
1831
1832	chunk3
1833	</code></pre>
1834	````````````````````````````````
1835
1836
1837	Any initial spaces or tabs beyond four spaces of indentation will be included in
1838	the content, even in interior blank lines:
1839
1840	```````````````````````````````` example
1841	chunk1
1842
1843	chunk2
1844	.
1845	<pre><code>chunk1
1846
1847	chunk2
1848	</code></pre>
1849	````````````````````````````````
1850
1851
1852	An indented code block cannot interrupt a paragraph. (This
1853	allows hanging indents and the like.)
1854
1855	```````````````````````````````` example
1856	Foo
1857	bar
1858
1859	.
1860	<p>Foo
1861	bar</p>
1862	````````````````````````````````
1863
1864
1865	However, any non-blank line with fewer than four spaces of indentation ends
1866	the code block immediately. So a paragraph may occur immediately
1867	after indented code:
1868
1869	```````````````````````````````` example
1870	foo
1871	bar
1872	.
1873	<pre><code>foo
1874	</code></pre>
1875	<p>bar</p>
1876	````````````````````````````````
1877
1878
1879	And indented code can occur immediately before and after other kinds of
1880	blocks:
1881
1882	```````````````````````````````` example
1883	# Heading
1884	foo
1885	Heading
1886	------
1887	foo
1888	----
1889	.
1890	<h1>Heading</h1>
1891	<pre><code>foo
1892	</code></pre>
1893	<h2>Heading</h2>
1894	<pre><code>foo
1895	</code></pre>
1896	<hr />
1897	````````````````````````````````
1898
1899
1900	The first line can be preceded by more than four spaces of indentation:
1901
1902	```````````````````````````````` example
1903	foo
1904	bar
1905	.
1906	<pre><code> foo
1907	bar
1908	</code></pre>
1909	````````````````````````````````
1910
1911
1912	Blank lines preceding or following an indented code block
1913	are not included in it:
1914
1915	```````````````````````````````` example
1916
1917
1918	foo
1919
1920
1921	.
1922	<pre><code>foo
1923	</code></pre>
1924	````````````````````````````````
1925
1926
1927	Trailing spaces or tabs are included in the code block's content:
1928
1929	```````````````````````````````` example
1930	foo
1931	.
1932	<pre><code>foo
1933	</code></pre>
1934	````````````````````````````````
1935
1936
1937
1938	## Fenced code blocks
1939
1940	A [code fence](@) is a sequence
1941	of at least three consecutive backtick characters (`` ` ``) or
1942	tildes (`~`). (Tildes and backticks cannot be mixed.)
1943	A [fenced code block](@)
1944	begins with a code fence, preceded by up to three spaces of indentation.
1945
1946	The line with the opening code fence may optionally contain some text
1947	following the code fence; this is trimmed of leading and trailing
1948	spaces or tabs and called the [info string](@). If the [info string] comes
1949	after a backtick fence, it may not contain any backtick
1950	characters. (The reason for this restriction is that otherwise
1951	some inline code would be incorrectly interpreted as the
1952	beginning of a fenced code block.)
1953
1954	The content of the code block consists of all subsequent lines, until
1955	a closing [code fence] of the same type as the code block
1956	began with (backticks or tildes), and with at least as many backticks
1957	or tildes as the opening code fence. If the leading code fence is
1958	preceded by N spaces of indentation, then up to N spaces of indentation are
1959	removed from each line of the content (if present). (If a content line is not
1960	indented, it is preserved unchanged. If it is indented N spaces or less, all
1961	of the indentation is removed.)
1962
1963	The closing code fence may be preceded by up to three spaces of indentation, and
1964	may be followed only by spaces or tabs, which are ignored. If the end of the
1965	containing block (or document) is reached and no closing code fence
1966	has been found, the code block contains all of the lines after the
1967	opening code fence until the end of the containing block (or
1968	document). (An alternative spec would require backtracking in the
1969	event that a closing code fence is not found. But this makes parsing
1970	much less efficient, and there seems to be no real down side to the
1971	behavior described here.)
1972
1973	A fenced code block may interrupt a paragraph, and does not require
1974	a blank line either before or after.
1975
1976	The content of a code fence is treated as literal text, not parsed
1977	as inlines. The first word of the [info string] is typically used to
1978	specify the language of the code sample, and rendered in the `class`
1979	attribute of the `code` tag. However, this spec does not mandate any
1980	particular treatment of the [info string].
1981
1982	Here is a simple example with backticks:
1983
1984	```````````````````````````````` example
1985	```
1986	<
1987	>
1988	```
1989	.
1990	<pre><code><
1991	>
1992	</code></pre>
1993	````````````````````````````````
1994
1995
1996	With tildes:
1997
1998	```````````````````````````````` example
1999	~~~
2000	<
2001	>
2002	~~~
2003	.
2004	<pre><code><
2005	>
2006	</code></pre>
2007	````````````````````````````````
2008
2009	Fewer than three backticks is not enough:
2010
2011	```````````````````````````````` example
2012	``
2013	foo
2014	``
2015	.
2016	<p><code>foo</code></p>
2017	````````````````````````````````
2018
2019	The closing code fence must use the same character as the opening
2020	fence:
2021
2022	```````````````````````````````` example
2023	```
2024	aaa
2025	~~~
2026	```
2027	.
2028	<pre><code>aaa
2029	~~~
2030	</code></pre>
2031	````````````````````````````````
2032
2033
2034	```````````````````````````````` example
2035	~~~
2036	aaa
2037	```
2038	~~~
2039	.
2040	<pre><code>aaa
2041	```
2042	</code></pre>
2043	````````````````````````````````
2044
2045
2046	The closing code fence must be at least as long as the opening fence:
2047
2048	```````````````````````````````` example
2049	````
2050	aaa
2051	```
2052	``````
2053	.
2054	<pre><code>aaa
2055	```
2056	</code></pre>
2057	````````````````````````````````
2058
2059
2060	```````````````````````````````` example
2061	~~~~
2062	aaa
2063	~~~
2064	~~~~
2065	.
2066	<pre><code>aaa
2067	~~~
2068	</code></pre>
2069	````````````````````````````````
2070
2071
2072	Unclosed code blocks are closed by the end of the document
2073	(or the enclosing [block quote][block quotes] or [list item][list items]):
2074
2075	```````````````````````````````` example
2076	```
2077	.
2078	<pre><code></code></pre>
2079	````````````````````````````````
2080
2081
2082	```````````````````````````````` example
2083	`````
2084
2085	```
2086	aaa
2087	.
2088	<pre><code>
2089	```
2090	aaa
2091	</code></pre>
2092	````````````````````````````````
2093
2094
2095	```````````````````````````````` example
2096	> ```
2097	> aaa
2098
2099	bbb
2100	.
2101	<blockquote>
2102	<pre><code>aaa
2103	</code></pre>
2104	</blockquote>
2105	<p>bbb</p>
2106	````````````````````````````````
2107
2108
2109	A code block can have all empty lines as its content:
2110
2111	```````````````````````````````` example
2112	```
2113
2114
2115	```
2116	.
2117	<pre><code>
2118
2119	</code></pre>
2120	````````````````````````````````
2121
2122
2123	A code block can be empty:
2124
2125	```````````````````````````````` example
2126	```
2127	```
2128	.
2129	<pre><code></code></pre>
2130	````````````````````````````````
2131
2132
2133	Fences can be indented. If the opening fence is indented,
2134	content lines will have equivalent opening indentation removed,
2135	if present:
2136
2137	```````````````````````````````` example
2138	```
2139	aaa
2140	aaa
2141	```
2142	.
2143	<pre><code>aaa
2144	aaa
2145	</code></pre>
2146	````````````````````````````````
2147
2148
2149	```````````````````````````````` example
2150	```
2151	aaa
2152	aaa
2153	aaa
2154	```
2155	.
2156	<pre><code>aaa
2157	aaa
2158	aaa
2159	</code></pre>
2160	````````````````````````````````
2161
2162
2163	```````````````````````````````` example
2164	```
2165	aaa
2166	aaa
2167	aaa
2168	```
2169	.
2170	<pre><code>aaa
2171	aaa
2172	aaa
2173	</code></pre>
2174	````````````````````````````````
2175
2176
2177	Four spaces of indentation is too many:
2178
2179	```````````````````````````````` example
2180	```
2181	aaa
2182	```
2183	.
2184	<pre><code>```
2185	aaa
2186	```
2187	</code></pre>
2188	````````````````````````````````
2189
2190
2191	Closing fences may be preceded by up to three spaces of indentation, and their
2192	indentation need not match that of the opening fence:
2193
2194	```````````````````````````````` example
2195	```
2196	aaa
2197	```
2198	.
2199	<pre><code>aaa
2200	</code></pre>
2201	````````````````````````````````
2202
2203
2204	```````````````````````````````` example
2205	```
2206	aaa
2207	```
2208	.
2209	<pre><code>aaa
2210	</code></pre>
2211	````````````````````````````````
2212
2213
2214	This is not a closing fence, because it is indented 4 spaces:
2215
2216	```````````````````````````````` example
2217	```
2218	aaa
2219	```
2220	.
2221	<pre><code>aaa
2222	```
2223	</code></pre>
2224	````````````````````````````````
2225
2226
2227
2228	Code fences (opening and closing) cannot contain internal spaces or tabs:
2229
2230	```````````````````````````````` example
2231	``` ```
2232	aaa
2233	.
2234	<p><code> </code>
2235	aaa</p>
2236	````````````````````````````````
2237
2238
2239	```````````````````````````````` example
2240	~~~~~~
2241	aaa
2242	~~~ ~~
2243	.
2244	<pre><code>aaa
2245	~~~ ~~
2246	</code></pre>
2247	````````````````````````````````
2248
2249
2250	Fenced code blocks can interrupt paragraphs, and can be followed
2251	directly by paragraphs, without a blank line between:
2252
2253	```````````````````````````````` example
2254	foo
2255	```
2256	bar
2257	```
2258	baz
2259	.
2260	<p>foo</p>
2261	<pre><code>bar
2262	</code></pre>
2263	<p>baz</p>
2264	````````````````````````````````
2265
2266
2267	Other blocks can also occur before and after fenced code blocks
2268	without an intervening blank line:
2269
2270	```````````````````````````````` example
2271	foo
2272	---
2273	~~~
2274	bar
2275	~~~
2276	# baz
2277	.
2278	<h2>foo</h2>
2279	<pre><code>bar
2280	</code></pre>
2281	<h1>baz</h1>
2282	````````````````````````````````
2283
2284
2285	An [info string] can be provided after the opening code fence.
2286	Although this spec doesn't mandate any particular treatment of
2287	the info string, the first word is typically used to specify
2288	the language of the code block. In HTML output, the language is
2289	normally indicated by adding a class to the `code` element consisting
2290	of `language-` followed by the language name.
2291
2292	```````````````````````````````` example
2293	```ruby
2294	def foo(x)
2295	return 3
2296	end
2297	```
2298	.
2299	<pre><code class="language-ruby">def foo(x)
2300	return 3
2301	end
2302	</code></pre>
2303	````````````````````````````````
2304
2305
2306	```````````````````````````````` example
2307	~~~~ ruby startline=3 $%@#$
2308	def foo(x)
2309	return 3
2310	end
2311	~~~~~~~
2312	.
2313	<pre><code class="language-ruby">def foo(x)
2314	return 3
2315	end
2316	</code></pre>
2317	````````````````````````````````
2318
2319
2320	```````````````````````````````` example
2321	````;
2322	````
2323	.
2324	<pre><code class="language-;"></code></pre>
2325	````````````````````````````````
2326
2327
2328	[Info strings] for backtick code blocks cannot contain backticks:
2329
2330	```````````````````````````````` example
2331	``` aa ```
2332	foo
2333	.
2334	<p><code>aa</code>
2335	foo</p>
2336	````````````````````````````````
2337
2338
2339	[Info strings] for tilde code blocks can contain backticks and tildes:
2340
2341	```````````````````````````````` example
2342	~~~ aa ``` ~~~
2343	foo
2344	~~~
2345	.
2346	<pre><code class="language-aa">foo
2347	</code></pre>
2348	````````````````````````````````
2349
2350
2351	Closing code fences cannot have [info strings]:
2352
2353	```````````````````````````````` example
2354	```
2355	``` aaa
2356	```
2357	.
2358	<pre><code>``` aaa
2359	</code></pre>
2360	````````````````````````````````
2361
2362
2363
2364	## HTML blocks
2365
2366	An [HTML block](@) is a group of lines that is treated
2367	as raw HTML (and will not be escaped in HTML output).
2368
2369	There are seven kinds of [HTML block], which can be defined by their
2370	start and end conditions. The block begins with a line that meets a
2371	[start condition](@) (after up to three optional spaces of indentation).
2372	It ends with the first subsequent line that meets a matching
2373	[end condition](@), or the last line of the document, or the last line of
2374	the [container block](#container-blocks) containing the current HTML
2375	block, if no line is encountered that meets the [end condition]. If
2376	the first line meets both the [start condition] and the [end
2377	condition], the block will contain just that line.
2378
2379	1. Start condition: line begins with the string `<pre`,
2380	`<script`, `<style`, or `<textarea` (case-insensitive), followed by a space,
2381	a tab, the string `>`, or the end of the line.\
2382	End condition: line contains an end tag
2383	`</pre>`, `</script>`, `</style>`, or `</textarea>` (case-insensitive; it
2384	need not match the start tag).
2385
2386	2. Start condition: line begins with the string `<!--`.\
2387	End condition: line contains the string `-->`.
2388
2389	3. Start condition: line begins with the string `<?`.\
2390	End condition: line contains the string `?>`.
2391
2392	4. Start condition: line begins with the string `<!`
2393	followed by an ASCII letter.\
2394	End condition: line contains the character `>`.
2395
2396	5. Start condition: line begins with the string
2397	`<![CDATA[`.\
2398	End condition: line contains the string `]]>`.
2399
2400	6. Start condition: line begins the string `<` or `</`
2401	followed by one of the strings (case-insensitive) `address`,
2402	`article`, `aside`, `base`, `basefont`, `blockquote`, `body`,
2403	`caption`, `center`, `col`, `colgroup`, `dd`, `details`, `dialog`,
2404	`dir`, `div`, `dl`, `dt`, `fieldset`, `figcaption`, `figure`,
2405	`footer`, `form`, `frame`, `frameset`,
2406	`h1`, `h2`, `h3`, `h4`, `h5`, `h6`, `head`, `header`, `hr`,
2407	`html`, `iframe`, `legend`, `li`, `link`, `main`, `menu`, `menuitem`,
2408	`nav`, `noframes`, `ol`, `optgroup`, `option`, `p`, `param`,
2409	`section`, `source`, `summary`, `table`, `tbody`, `td`,
2410	`tfoot`, `th`, `thead`, `title`, `tr`, `track`, `ul`, followed
2411	by a space, a tab, the end of the line, the string `>`, or
2412	the string `/>`.\
2413	End condition: line is followed by a [blank line].
2414
2415	7. Start condition: line begins with a complete [open tag]
2416	(with any [tag name] other than `pre`, `script`,
2417	`style`, or `textarea`) or a complete [closing tag],
2418	followed by zero or more spaces and tabs, followed by the end of the line.\
2419	End condition: line is followed by a [blank line].
2420
2421	HTML blocks continue until they are closed by their appropriate
2422	[end condition], or the last line of the document or other [container
2423	block](#container-blocks). This means any HTML **within an HTML
2424	block** that might otherwise be recognised as a start condition will
2425	be ignored by the parser and passed through as-is, without changing
2426	the parser's state.
2427
2428	For instance, `<pre>` within an HTML block started by `<table>` will not affect
2429	the parser state; as the HTML block was started in by start condition 6, it
2430	will end at any blank line. This can be surprising:
2431
2432	```````````````````````````````` example
2433	<table><tr><td>
2434	<pre>
2435	Hello,
2436
2437	_world_.
2438	</pre>
2439	</td></tr></table>
2440	.
2441	<table><tr><td>
2442	<pre>
2443	Hello,
2444	<p><em>world</em>.
2445	</pre></p>
2446	</td></tr></table>
2447	````````````````````````````````
2448
2449	In this case, the HTML block is terminated by the blank line — the `Hello`
2450	text remains verbatim — and regular parsing resumes, with a paragraph,
2451	emphasised `world` and inline and block HTML following.
2452
2453	All types of [HTML blocks] except type 7 may interrupt
2454	a paragraph. Blocks of type 7 may not interrupt a paragraph.
2455	(This restriction is intended to prevent unwanted interpretation
2456	of long tags inside a wrapped paragraph as starting HTML blocks.)
2457
2458	Some simple examples follow. Here are some basic HTML blocks
2459	of type 6:
2460
2461	```````````````````````````````` example
2462	<table>
2463	<tr>
2464	<td>
2465	hi
2466	</td>
2467	</tr>
2468	</table>
2469
2470	okay.
2471	.
2472	<table>
2473	<tr>
2474	<td>
2475	hi
2476	</td>
2477	</tr>
2478	</table>
2479	<p>okay.</p>
2480	````````````````````````````````
2481
2482
2483	```````````````````````````````` example
2484	<div>
2485	hello
2486	<foo><a>
2487	.
2488	<div>
2489	hello
2490	<foo><a>
2491	````````````````````````````````
2492
2493
2494	A block can also start with a closing tag:
2495
2496	```````````````````````````````` example
2497	</div>
2498	foo
2499	.
2500	</div>
2501	foo
2502	````````````````````````````````
2503
2504
2505	Here we have two HTML blocks with a Markdown paragraph between them:
2506
2507	```````````````````````````````` example
2508	<DIV CLASS="foo">
2509
2510	Markdown
2511
2512	</DIV>
2513	.
2514	<DIV CLASS="foo">
2515	<p><em>Markdown</em></p>
2516	</DIV>
2517	````````````````````````````````
2518
2519
2520	The tag on the first line can be partial, as long
2521	as it is split where there would be whitespace:
2522
2523	```````````````````````````````` example
2524	<div id="foo"
2525	class="bar">
2526	</div>
2527	.
2528	<div id="foo"
2529	class="bar">
2530	</div>
2531	````````````````````````````````
2532
2533
2534	```````````````````````````````` example
2535	<div id="foo" class="bar
2536	baz">
2537	</div>
2538	.
2539	<div id="foo" class="bar
2540	baz">
2541	</div>
2542	````````````````````````````````
2543
2544
2545	An open tag need not be closed:
2546	```````````````````````````````` example
2547	<div>
2548	foo
2549
2550	bar
2551	.
2552	<div>
2553	foo
2554	<p><em>bar</em></p>
2555	````````````````````````````````
2556
2557
2558
2559	A partial tag need not even be completed (garbage
2560	in, garbage out):
2561
2562	```````````````````````````````` example
2563	<div id="foo"
2564	hi
2565	.
2566	<div id="foo"
2567	hi
2568	````````````````````````````````
2569
2570
2571	```````````````````````````````` example
2572	<div class
2573	foo
2574	.
2575	<div class
2576	foo
2577	````````````````````````````````
2578
2579
2580	The initial tag doesn't even need to be a valid
2581	tag, as long as it starts like one:
2582
2583	```````````````````````````````` example
2584	<div *???-&&&-<---
2585	foo
2586	.
2587	<div *???-&&&-<---
2588	foo
2589	````````````````````````````````
2590
2591
2592	In type 6 blocks, the initial tag need not be on a line by
2593	itself:
2594
2595	```````````````````````````````` example
2596	<div><a href="bar">foo</a></div>
2597	.
2598	<div><a href="bar">foo</a></div>
2599	````````````````````````````````
2600
2601
2602	```````````````````````````````` example
2603	<table><tr><td>
2604	foo
2605	</td></tr></table>
2606	.
2607	<table><tr><td>
2608	foo
2609	</td></tr></table>
2610	````````````````````````````````
2611
2612
2613	Everything until the next blank line or end of document
2614	gets included in the HTML block. So, in the following
2615	example, what looks like a Markdown code block
2616	is actually part of the HTML block, which continues until a blank
2617	line or the end of the document is reached:
2618
2619	```````````````````````````````` example
2620	<div></div>
2621	``` c
2622	int x = 33;
2623	```
2624	.
2625	<div></div>
2626	``` c
2627	int x = 33;
2628	```
2629	````````````````````````````````
2630
2631
2632	To start an [HTML block] with a tag that is not in the
2633	list of block-level tags in (6), you must put the tag by
2634	itself on the first line (and it must be complete):
2635
2636	```````````````````````````````` example
2637	<a href="foo">
2638	bar
2639	</a>
2640	.
2641	<a href="foo">
2642	bar
2643	</a>
2644	````````````````````````````````
2645
2646
2647	In type 7 blocks, the [tag name] can be anything:
2648
2649	```````````````````````````````` example
2650	<Warning>
2651	bar
2652	</Warning>
2653	.
2654	<Warning>
2655	bar
2656	</Warning>
2657	````````````````````````````````
2658
2659
2660	```````````````````````````````` example
2661	<i class="foo">
2662	bar
2663	</i>
2664	.
2665	<i class="foo">
2666	bar
2667	</i>
2668	````````````````````````````````
2669
2670
2671	```````````````````````````````` example
2672	</ins>
2673	bar
2674	.
2675	</ins>
2676	bar
2677	````````````````````````````````
2678
2679
2680	These rules are designed to allow us to work with tags that
2681	can function as either block-level or inline-level tags.
2682	The `<del>` tag is a nice example. We can surround content with
2683	`<del>` tags in three different ways. In this case, we get a raw
2684	HTML block, because the `<del>` tag is on a line by itself:
2685
2686	```````````````````````````````` example
2687	<del>
2688	foo
2689	</del>
2690	.
2691	<del>
2692	foo
2693	</del>
2694	````````````````````````````````
2695
2696
2697	In this case, we get a raw HTML block that just includes
2698	the `<del>` tag (because it ends with the following blank
2699	line). So the contents get interpreted as CommonMark:
2700
2701	```````````````````````````````` example
2702	<del>
2703
2704	foo
2705
2706	</del>
2707	.
2708	<del>
2709	<p><em>foo</em></p>
2710	</del>
2711	````````````````````````````````
2712
2713
2714	Finally, in this case, the `<del>` tags are interpreted
2715	as [raw HTML] inside the CommonMark paragraph. (Because
2716	the tag is not on a line by itself, we get inline HTML
2717	rather than an [HTML block].)
2718
2719	```````````````````````````````` example
2720	<del>foo</del>
2721	.
2722	<p><del><em>foo</em></del></p>
2723	````````````````````````````````
2724
2725
2726	HTML tags designed to contain literal content
2727	(`pre`, `script`, `style`, `textarea`), comments, processing instructions,
2728	and declarations are treated somewhat differently.
2729	Instead of ending at the first blank line, these blocks
2730	end at the first line containing a corresponding end tag.
2731	As a result, these blocks can contain blank lines:
2732
2733	A pre tag (type 1):
2734
2735	```````````````````````````````` example
2736	<pre language="haskell"><code>
2737	import Text.HTML.TagSoup
2738
2739	main :: IO ()
2740	main = print $ parseTags tags
2741	</code></pre>
2742	okay
2743	.
2744	<pre language="haskell"><code>
2745	import Text.HTML.TagSoup
2746
2747	main :: IO ()
2748	main = print $ parseTags tags
2749	</code></pre>
2750	<p>okay</p>
2751	````````````````````````````````
2752
2753
2754	A script tag (type 1):
2755
2756	```````````````````````````````` example
2757	<script type="text/javascript">
2758	// JavaScript example
2759
2760	document.getElementById("demo").innerHTML = "Hello JavaScript!";
2761	</script>
2762	okay
2763	.
2764	<script type="text/javascript">
2765	// JavaScript example
2766
2767	document.getElementById("demo").innerHTML = "Hello JavaScript!";
2768	</script>
2769	<p>okay</p>
2770	````````````````````````````````
2771
2772
2773	A textarea tag (type 1):
2774
2775	```````````````````````````````` example
2776	<textarea>
2777
2778	foo
2779
2780	_bar_
2781
2782	</textarea>
2783	.
2784	<textarea>
2785
2786	foo
2787
2788	_bar_
2789
2790	</textarea>
2791	````````````````````````````````
2792
2793	A style tag (type 1):
2794
2795	```````````````````````````````` example
2796	<style
2797	type="text/css">
2798	h1 {color:red;}
2799
2800	p {color:blue;}
2801	</style>
2802	okay
2803	.
2804	<style
2805	type="text/css">
2806	h1 {color:red;}
2807
2808	p {color:blue;}
2809	</style>
2810	<p>okay</p>
2811	````````````````````````````````
2812
2813
2814	If there is no matching end tag, the block will end at the
2815	end of the document (or the enclosing [block quote][block quotes]
2816	or [list item][list items]):
2817
2818	```````````````````````````````` example
2819	<style
2820	type="text/css">
2821
2822	foo
2823	.
2824	<style
2825	type="text/css">
2826
2827	foo
2828	````````````````````````````````
2829
2830
2831	```````````````````````````````` example
2832	> <div>
2833	> foo
2834
2835	bar
2836	.
2837	<blockquote>
2838	<div>
2839	foo
2840	</blockquote>
2841	<p>bar</p>
2842	````````````````````````````````
2843
2844
2845	```````````````````````````````` example
2846	- <div>
2847	- foo
2848	.
2849	<ul>
2850	<li>
2851	<div>
2852	</li>
2853	<li>foo</li>
2854	</ul>
2855	````````````````````````````````
2856
2857
2858	The end tag can occur on the same line as the start tag:
2859
2860	```````````````````````````````` example
2861	<style>p{color:red;}</style>
2862	foo
2863	.
2864	<style>p{color:red;}</style>
2865	<p><em>foo</em></p>
2866	````````````````````````````````
2867
2868
2869	```````````````````````````````` example
2870	<!-- foo -->bar
2871	baz
2872	.
2873	<!-- foo -->bar
2874	<p><em>baz</em></p>
2875	````````````````````````````````
2876
2877
2878	Note that anything on the last line after the
2879	end tag will be included in the [HTML block]:
2880
2881	```````````````````````````````` example
2882	<script>
2883	foo
2884	</script>1. bar
2885	.
2886	<script>
2887	foo
2888	</script>1. bar
2889	````````````````````````````````
2890
2891
2892	A comment (type 2):
2893
2894	```````````````````````````````` example
2895	<!-- Foo
2896
2897	bar
2898	baz -->
2899	okay
2900	.
2901	<!-- Foo
2902
2903	bar
2904	baz -->
2905	<p>okay</p>
2906	````````````````````````````````
2907
2908
2909
2910	A processing instruction (type 3):
2911
2912	```````````````````````````````` example
2913	<?php
2914
2915	echo '>';
2916
2917	?>
2918	okay
2919	.
2920	<?php
2921
2922	echo '>';
2923
2924	?>
2925	<p>okay</p>
2926	````````````````````````````````
2927
2928
2929	A declaration (type 4):
2930
2931	```````````````````````````````` example
2932	<!DOCTYPE html>
2933	.
2934	<!DOCTYPE html>
2935	````````````````````````````````
2936
2937
2938	CDATA (type 5):
2939
2940	```````````````````````````````` example
2941	<![CDATA[
2942	function matchwo(a,b)
2943	{
2944	if (a < b && a < 0) then {
2945	return 1;
2946
2947	} else {
2948
2949	return 0;
2950	}
2951	}
2952	]]>
2953	okay
2954	.
2955	<![CDATA[
2956	function matchwo(a,b)
2957	{
2958	if (a < b && a < 0) then {
2959	return 1;
2960
2961	} else {
2962
2963	return 0;
2964	}
2965	}
2966	]]>
2967	<p>okay</p>
2968	````````````````````````````````
2969
2970
2971	The opening tag can be preceded by up to three spaces of indentation, but not
2972	four:
2973
2974	```````````````````````````````` example
2975	<!-- foo -->
2976
2977	<!-- foo -->
2978	.
2979	<!-- foo -->
2980	<pre><code><!-- foo -->
2981	</code></pre>
2982	````````````````````````````````
2983
2984
2985	```````````````````````````````` example
2986	<div>
2987
2988	<div>
2989	.
2990	<div>
2991	<pre><code><div>
2992	</code></pre>
2993	````````````````````````````````
2994
2995
2996	An HTML block of types 1--6 can interrupt a paragraph, and need not be
2997	preceded by a blank line.
2998
2999	```````````````````````````````` example
3000	Foo
3001	<div>
3002	bar
3003	</div>
3004	.
3005	<p>Foo</p>
3006	<div>
3007	bar
3008	</div>
3009	````````````````````````````````
3010
3011
3012	However, a following blank line is needed, except at the end of
3013	a document, and except for blocks of types 1--5, [above][HTML
3014	block]:
3015
3016	```````````````````````````````` example
3017	<div>
3018	bar
3019	</div>
3020	foo
3021	.
3022	<div>
3023	bar
3024	</div>
3025	foo
3026	````````````````````````````````
3027
3028
3029	HTML blocks of type 7 cannot interrupt a paragraph:
3030
3031	```````````````````````````````` example
3032	Foo
3033	<a href="bar">
3034	baz
3035	.
3036	<p>Foo
3037	<a href="bar">
3038	baz</p>
3039	````````````````````````````````
3040
3041
3042	This rule differs from John Gruber's original Markdown syntax
3043	specification, which says:
3044
3045	> The only restrictions are that block-level HTML elements —
3046	> e.g. `<div>`, `<table>`, `<pre>`, `<p>`, etc. — must be separated from
3047	> surrounding content by blank lines, and the start and end tags of the
3048	> block should not be indented with spaces or tabs.
3049
3050	In some ways Gruber's rule is more restrictive than the one given
3051	here:
3052
3053	- It requires that an HTML block be preceded by a blank line.
3054	- It does not allow the start tag to be indented.
3055	- It requires a matching end tag, which it also does not allow to
3056	be indented.
3057
3058	Most Markdown implementations (including some of Gruber's own) do not
3059	respect all of these restrictions.
3060
3061	There is one respect, however, in which Gruber's rule is more liberal
3062	than the one given here, since it allows blank lines to occur inside
3063	an HTML block. There are two reasons for disallowing them here.
3064	First, it removes the need to parse balanced tags, which is
3065	expensive and can require backtracking from the end of the document
3066	if no matching end tag is found. Second, it provides a very simple
3067	and flexible way of including Markdown content inside HTML tags:
3068	simply separate the Markdown from the HTML using blank lines:
3069
3070	Compare:
3071
3072	```````````````````````````````` example
3073	<div>
3074
3075	Emphasized text.
3076
3077	</div>
3078	.
3079	<div>
3080	<p><em>Emphasized</em> text.</p>
3081	</div>
3082	````````````````````````````````
3083
3084
3085	```````````````````````````````` example
3086	<div>
3087	Emphasized text.
3088	</div>
3089	.
3090	<div>
3091	Emphasized text.
3092	</div>
3093	````````````````````````````````
3094
3095
3096	Some Markdown implementations have adopted a convention of
3097	interpreting content inside tags as text if the open tag has
3098	the attribute `markdown=1`. The rule given above seems a simpler and
3099	more elegant way of achieving the same expressive power, which is also
3100	much simpler to parse.
3101
3102	The main potential drawback is that one can no longer paste HTML
3103	blocks into Markdown documents with 100% reliability. However,
3104	in most cases this will work fine, because the blank lines in
3105	HTML are usually followed by HTML block tags. For example:
3106
3107	```````````````````````````````` example
3108	<table>
3109
3110	<tr>
3111
3112	<td>
3113	Hi
3114	</td>
3115
3116	</tr>
3117
3118	</table>
3119	.
3120	<table>
3121	<tr>
3122	<td>
3123	Hi
3124	</td>
3125	</tr>
3126	</table>
3127	````````````````````````````````
3128
3129
3130	There are problems, however, if the inner tags are indented
3131	and separated by spaces, as then they will be interpreted as
3132	an indented code block:
3133
3134	```````````````````````````````` example
3135	<table>
3136
3137	<tr>
3138
3139	<td>
3140	Hi
3141	</td>
3142
3143	</tr>
3144
3145	</table>
3146	.
3147	<table>
3148	<tr>
3149	<pre><code><td>
3150	Hi
3151	</td>
3152	</code></pre>
3153	</tr>
3154	</table>
3155	````````````````````````````````
3156
3157
3158	Fortunately, blank lines are usually not necessary and can be
3159	deleted. The exception is inside `<pre>` tags, but as described
3160	[above][HTML blocks], raw HTML blocks starting with `<pre>`
3161	can contain blank lines.
3162
3163	## Link reference definitions
3164
3165	A [link reference definition](@)
3166	consists of a [link label], optionally preceded by up to three spaces of
3167	indentation, followed
3168	by a colon (`:`), optional spaces or tabs (including up to one
3169	[line ending]), a [link destination],
3170	optional spaces or tabs (including up to one
3171	[line ending]), and an optional [link
3172	title], which if it is present must be separated
3173	from the [link destination] by spaces or tabs.
3174	No further character may occur.
3175
3176	A [link reference definition]
3177	does not correspond to a structural element of a document. Instead, it
3178	defines a label which can be used in [reference links]
3179	and reference-style [images] elsewhere in the document. [Link
3180	reference definitions] can come either before or after the links that use
3181	them.
3182
3183	```````````````````````````````` example
3184	[foo]: /url "title"
3185
3186	[foo]
3187	.
3188	<p><a href="/url" title="title">foo</a></p>
3189	````````````````````````````````
3190
3191
3192	```````````````````````````````` example
3193	[foo]:
3194	/url
3195	'the title'
3196
3197	[foo]
3198	.
3199	<p><a href="/url" title="the title">foo</a></p>
3200	````````````````````````````````
3201
3202
3203	```````````````````````````````` example
3204	[Foo*bar\]]:my_(url) 'title (with parens)'
3205
3206	[Foo*bar\]]
3207	.
3208	<p><a href="my_(url)" title="title (with parens)">Foo*bar]</a></p>
3209	````````````````````````````````
3210
3211
3212	```````````````````````````````` example
3213	[Foo bar]:
3214	<my url>
3215	'title'
3216
3217	[Foo bar]
3218	.
3219	<p><a href="my%20url" title="title">Foo bar</a></p>
3220	````````````````````````````````
3221
3222
3223	The title may extend over multiple lines:
3224
3225	```````````````````````````````` example
3226	[foo]: /url '
3227	title
3228	line1
3229	line2
3230	'
3231
3232	[foo]
3233	.
3234	<p><a href="/url" title="
3235	title
3236	line1
3237	line2
3238	">foo</a></p>
3239	````````````````````````````````
3240
3241
3242	However, it may not contain a [blank line]:
3243
3244	```````````````````````````````` example
3245	[foo]: /url 'title
3246
3247	with blank line'
3248
3249	[foo]
3250	.
3251	<p>[foo]: /url 'title</p>
3252	<p>with blank line'</p>
3253	<p>[foo]</p>
3254	````````````````````````````````
3255
3256
3257	The title may be omitted:
3258
3259	```````````````````````````````` example
3260	[foo]:
3261	/url
3262
3263	[foo]
3264	.
3265	<p><a href="/url">foo</a></p>
3266	````````````````````````````````
3267
3268
3269	The link destination may not be omitted:
3270
3271	```````````````````````````````` example
3272	[foo]:
3273
3274	[foo]
3275	.
3276	<p>[foo]:</p>
3277	<p>[foo]</p>
3278	````````````````````````````````
3279
3280	However, an empty link destination may be specified using
3281	angle brackets:
3282
3283	```````````````````````````````` example
3284	[foo]: <>
3285
3286	[foo]
3287	.
3288	<p><a href="">foo</a></p>
3289	````````````````````````````````
3290
3291	The title must be separated from the link destination by
3292	spaces or tabs:
3293
3294	```````````````````````````````` example
3295	[foo]: <bar>(baz)
3296
3297	[foo]
3298	.
3299	<p>[foo]: <bar>(baz)</p>
3300	<p>[foo]</p>
3301	````````````````````````````````
3302
3303
3304	Both title and destination can contain backslash escapes
3305	and literal backslashes:
3306
3307	```````````````````````````````` example
3308	[foo]: /url\bar\*baz "foo\"bar\baz"
3309
3310	[foo]
3311	.
3312	<p><a href="/url%5Cbar*baz" title="foo"bar\baz">foo</a></p>
3313	````````````````````````````````
3314
3315
3316	A link can come before its corresponding definition:
3317
3318	```````````````````````````````` example
3319	[foo]
3320
3321	[foo]: url
3322	.
3323	<p><a href="url">foo</a></p>
3324	````````````````````````````````
3325
3326
3327	If there are several matching definitions, the first one takes
3328	precedence:
3329
3330	```````````````````````````````` example
3331	[foo]
3332
3333	[foo]: first
3334	[foo]: second
3335	.
3336	<p><a href="first">foo</a></p>
3337	````````````````````````````````
3338
3339
3340	As noted in the section on [Links], matching of labels is
3341	case-insensitive (see [matches]).
3342
3343	```````````````````````````````` example
3344	[FOO]: /url
3345
3346	[Foo]
3347	.
3348	<p><a href="/url">Foo</a></p>
3349	````````````````````````````````
3350
3351
3352	```````````````````````````````` example
3353	[ΑΓΩ]: /φου
3354
3355	[αγω]
3356	.
3357	<p><a href="/%CF%86%CE%BF%CF%85">αγω</a></p>
3358	````````````````````````````````
3359
3360
3361	Whether something is a [link reference definition] is
3362	independent of whether the link reference it defines is
3363	used in the document. Thus, for example, the following
3364	document contains just a link reference definition, and
3365	no visible content:
3366
3367	```````````````````````````````` example
3368	[foo]: /url
3369	.
3370	````````````````````````````````
3371
3372
3373	Here is another one:
3374
3375	```````````````````````````````` example
3376	[
3377	foo
3378	]: /url
3379	bar
3380	.
3381	<p>bar</p>
3382	````````````````````````````````
3383
3384
3385	This is not a link reference definition, because there are
3386	characters other than spaces or tabs after the title:
3387
3388	```````````````````````````````` example
3389	[foo]: /url "title" ok
3390	.
3391	<p>[foo]: /url "title" ok</p>
3392	````````````````````````````````
3393
3394
3395	This is a link reference definition, but it has no title:
3396
3397	```````````````````````````````` example
3398	[foo]: /url
3399	"title" ok
3400	.
3401	<p>"title" ok</p>
3402	````````````````````````````````
3403
3404
3405	This is not a link reference definition, because it is indented
3406	four spaces:
3407
3408	```````````````````````````````` example
3409	[foo]: /url "title"
3410
3411	[foo]
3412	.
3413	<pre><code>[foo]: /url "title"
3414	</code></pre>
3415	<p>[foo]</p>
3416	````````````````````````````````
3417
3418
3419	This is not a link reference definition, because it occurs inside
3420	a code block:
3421
3422	```````````````````````````````` example
3423	```
3424	[foo]: /url
3425	```
3426
3427	[foo]
3428	.
3429	<pre><code>[foo]: /url
3430	</code></pre>
3431	<p>[foo]</p>
3432	````````````````````````````````
3433
3434
3435	A [link reference definition] cannot interrupt a paragraph.
3436
3437	```````````````````````````````` example
3438	Foo
3439	[bar]: /baz
3440
3441	[bar]
3442	.
3443	<p>Foo
3444	[bar]: /baz</p>
3445	<p>[bar]</p>
3446	````````````````````````````````
3447
3448
3449	However, it can directly follow other block elements, such as headings
3450	and thematic breaks, and it need not be followed by a blank line.
3451
3452	```````````````````````````````` example
3453	# [Foo]
3454	[foo]: /url
3455	> bar
3456	.
3457	<h1><a href="/url">Foo</a></h1>
3458	<blockquote>
3459	<p>bar</p>
3460	</blockquote>
3461	````````````````````````````````
3462
3463	```````````````````````````````` example
3464	[foo]: /url
3465	bar
3466	===
3467	[foo]
3468	.
3469	<h1>bar</h1>
3470	<p><a href="/url">foo</a></p>
3471	````````````````````````````````
3472
3473	```````````````````````````````` example
3474	[foo]: /url
3475	===
3476	[foo]
3477	.
3478	<p>===
3479	<a href="/url">foo</a></p>
3480	````````````````````````````````
3481
3482
3483	Several [link reference definitions]
3484	can occur one after another, without intervening blank lines.
3485
3486	```````````````````````````````` example
3487	[foo]: /foo-url "foo"
3488	[bar]: /bar-url
3489	"bar"
3490	[baz]: /baz-url
3491
3492	[foo],
3493	[bar],
3494	[baz]
3495	.
3496	<p><a href="/foo-url" title="foo">foo</a>,
3497	<a href="/bar-url" title="bar">bar</a>,
3498	<a href="/baz-url">baz</a></p>
3499	````````````````````````````````
3500
3501
3502	[Link reference definitions] can occur
3503	inside block containers, like lists and block quotations. They
3504	affect the entire document, not just the container in which they
3505	are defined:
3506
3507	```````````````````````````````` example
3508	[foo]
3509
3510	> [foo]: /url
3511	.
3512	<p><a href="/url">foo</a></p>
3513	<blockquote>
3514	</blockquote>
3515	````````````````````````````````
3516
3517
3518	## Paragraphs
3519
3520	A sequence of non-blank lines that cannot be interpreted as other
3521	kinds of blocks forms a [paragraph](@).
3522	The contents of the paragraph are the result of parsing the
3523	paragraph's raw content as inlines. The paragraph's raw content
3524	is formed by concatenating the lines and removing initial and final
3525	spaces or tabs.
3526
3527	A simple example with two paragraphs:
3528
3529	```````````````````````````````` example
3530	aaa
3531
3532	bbb
3533	.
3534	<p>aaa</p>
3535	<p>bbb</p>
3536	````````````````````````````````
3537
3538
3539	Paragraphs can contain multiple lines, but no blank lines:
3540
3541	```````````````````````````````` example
3542	aaa
3543	bbb
3544
3545	ccc
3546	ddd
3547	.
3548	<p>aaa
3549	bbb</p>
3550	<p>ccc
3551	ddd</p>
3552	````````````````````````````````
3553
3554
3555	Multiple blank lines between paragraphs have no effect:
3556
3557	```````````````````````````````` example
3558	aaa
3559
3560
3561	bbb
3562	.
3563	<p>aaa</p>
3564	<p>bbb</p>
3565	````````````````````````````````
3566
3567
3568	Leading spaces or tabs are skipped:
3569
3570	```````````````````````````````` example
3571	aaa
3572	bbb
3573	.
3574	<p>aaa
3575	bbb</p>
3576	````````````````````````````````
3577
3578
3579	Lines after the first may be indented any amount, since indented
3580	code blocks cannot interrupt paragraphs.
3581
3582	```````````````````````````````` example
3583	aaa
3584	bbb
3585	ccc
3586	.
3587	<p>aaa
3588	bbb
3589	ccc</p>
3590	````````````````````````````````
3591
3592
3593	However, the first line may be preceded by up to three spaces of indentation.
3594	Four spaces of indentation is too many:
3595
3596	```````````````````````````````` example
3597	aaa
3598	bbb
3599	.
3600	<p>aaa
3601	bbb</p>
3602	````````````````````````````````
3603
3604
3605	```````````````````````````````` example
3606	aaa
3607	bbb
3608	.
3609	<pre><code>aaa
3610	</code></pre>
3611	<p>bbb</p>
3612	````````````````````````````````
3613
3614
3615	Final spaces or tabs are stripped before inline parsing, so a paragraph
3616	that ends with two or more spaces will not end with a [hard line
3617	break]:
3618
3619	```````````````````````````````` example
3620	aaa
3621	bbb
3622	.
3623	<p>aaa<br />
3624	bbb</p>
3625	````````````````````````````````
3626
3627
3628	## Blank lines
3629
3630	[Blank lines] between block-level elements are ignored,
3631	except for the role they play in determining whether a [list]
3632	is [tight] or [loose].
3633
3634	Blank lines at the beginning and end of the document are also ignored.
3635
3636	```````````````````````````````` example
3637
3638
3639	aaa
3640
3641
3642	# aaa
3643
3644
3645	.
3646	<p>aaa</p>
3647	<h1>aaa</h1>
3648	````````````````````````````````
3649
3650
3651
3652	# Container blocks
3653
3654	A [container block](#container-blocks) is a block that has other
3655	blocks as its contents. There are two basic kinds of container blocks:
3656	[block quotes] and [list items].
3657	[Lists] are meta-containers for [list items].
3658
3659	We define the syntax for container blocks recursively. The general
3660	form of the definition is:
3661
3662	> If X is a sequence of blocks, then the result of
3663	> transforming X in such-and-such a way is a container of type Y
3664	> with these blocks as its content.
3665
3666	So, we explain what counts as a block quote or list item by explaining
3667	how these can be generated from their contents. This should suffice
3668	to define the syntax, although it does not give a recipe for parsing
3669	these constructions. (A recipe is provided below in the section entitled
3670	[A parsing strategy](#appendix-a-parsing-strategy).)
3671
3672	## Block quotes
3673
3674	A [block quote marker](@),
3675	optionally preceded by up to three spaces of indentation,
3676	consists of (a) the character `>` together with a following space of
3677	indentation, or (b) a single character `>` not followed by a space of
3678	indentation.
3679
3680	The following rules define [block quotes]:
3681
3682	1. Basic case. If a string of lines Ls constitute a sequence
3683	of blocks Bs, then the result of prepending a [block quote
3684	marker] to the beginning of each line in Ls
3685	is a [block quote](#block-quotes) containing Bs.
3686
3687	2. Laziness. If a string of lines Ls constitute a [block
3688	quote](#block-quotes) with contents Bs, then the result of deleting
3689	the initial [block quote marker] from one or
3690	more lines in which the next character other than a space or tab after the
3691	[block quote marker] is [paragraph continuation
3692	text] is a block quote with Bs as its content.
3693	[Paragraph continuation text](@) is text
3694	that will be parsed as part of the content of a paragraph, but does
3695	not occur at the beginning of the paragraph.
3696
3697	3. Consecutiveness. A document cannot contain two [block
3698	quotes] in a row unless there is a [blank line] between them.
3699
3700	Nothing else counts as a [block quote](#block-quotes).
3701
3702	Here is a simple example:
3703
3704	```````````````````````````````` example
3705	> # Foo
3706	> bar
3707	> baz
3708	.
3709	<blockquote>
3710	<h1>Foo</h1>
3711	<p>bar
3712	baz</p>
3713	</blockquote>
3714	````````````````````````````````
3715
3716
3717	The space or tab after the `>` characters can be omitted:
3718
3719	```````````````````````````````` example
3720	># Foo
3721	>bar
3722	> baz
3723	.
3724	<blockquote>
3725	<h1>Foo</h1>
3726	<p>bar
3727	baz</p>
3728	</blockquote>
3729	````````````````````````````````
3730
3731
3732	The `>` characters can be preceded by up to three spaces of indentation:
3733
3734	```````````````````````````````` example
3735	> # Foo
3736	> bar
3737	> baz
3738	.
3739	<blockquote>
3740	<h1>Foo</h1>
3741	<p>bar
3742	baz</p>
3743	</blockquote>
3744	````````````````````````````````
3745
3746
3747	Four spaces of indentation is too many:
3748
3749	```````````````````````````````` example
3750	> # Foo
3751	> bar
3752	> baz
3753	.
3754	<pre><code>> # Foo
3755	> bar
3756	> baz
3757	</code></pre>
3758	````````````````````````````````
3759
3760
3761	The Laziness clause allows us to omit the `>` before
3762	[paragraph continuation text]:
3763
3764	```````````````````````````````` example
3765	> # Foo
3766	> bar
3767	baz
3768	.
3769	<blockquote>
3770	<h1>Foo</h1>
3771	<p>bar
3772	baz</p>
3773	</blockquote>
3774	````````````````````````````````
3775
3776
3777	A block quote can contain some lazy and some non-lazy
3778	continuation lines:
3779
3780	```````````````````````````````` example
3781	> bar
3782	baz
3783	> foo
3784	.
3785	<blockquote>
3786	<p>bar
3787	baz
3788	foo</p>
3789	</blockquote>
3790	````````````````````````````````
3791
3792
3793	Laziness only applies to lines that would have been continuations of
3794	paragraphs had they been prepended with [block quote markers].
3795	For example, the `> ` cannot be omitted in the second line of
3796
3797	``` markdown
3798	> foo
3799	> ---
3800	```
3801
3802	without changing the meaning:
3803
3804	```````````````````````````````` example
3805	> foo
3806	---
3807	.
3808	<blockquote>
3809	<p>foo</p>
3810	</blockquote>
3811	<hr />
3812	````````````````````````````````
3813
3814
3815	Similarly, if we omit the `> ` in the second line of
3816
3817	``` markdown
3818	> - foo
3819	> - bar
3820	```
3821
3822	then the block quote ends after the first line:
3823
3824	```````````````````````````````` example
3825	> - foo
3826	- bar
3827	.
3828	<blockquote>
3829	<ul>
3830	<li>foo</li>
3831	</ul>
3832	</blockquote>
3833	<ul>
3834	<li>bar</li>
3835	</ul>
3836	````````````````````````````````
3837
3838
3839	For the same reason, we can't omit the `> ` in front of
3840	subsequent lines of an indented or fenced code block:
3841
3842	```````````````````````````````` example
3843	> foo
3844	bar
3845	.
3846	<blockquote>
3847	<pre><code>foo
3848	</code></pre>
3849	</blockquote>
3850	<pre><code>bar
3851	</code></pre>
3852	````````````````````````````````
3853
3854
3855	```````````````````````````````` example
3856	> ```
3857	foo
3858	```
3859	.
3860	<blockquote>
3861	<pre><code></code></pre>
3862	</blockquote>
3863	<p>foo</p>
3864	<pre><code></code></pre>
3865	````````````````````````````````
3866
3867
3868	Note that in the following case, we have a [lazy
3869	continuation line]:
3870
3871	```````````````````````````````` example
3872	> foo
3873	- bar
3874	.
3875	<blockquote>
3876	<p>foo
3877	- bar</p>
3878	</blockquote>
3879	````````````````````````````````
3880
3881
3882	To see why, note that in
3883
3884	```markdown
3885	> foo
3886	> - bar
3887	```
3888
3889	the `- bar` is indented too far to start a list, and can't
3890	be an indented code block because indented code blocks cannot
3891	interrupt paragraphs, so it is [paragraph continuation text].
3892
3893	A block quote can be empty:
3894
3895	```````````````````````````````` example
3896	>
3897	.
3898	<blockquote>
3899	</blockquote>
3900	````````````````````````````````
3901
3902
3903	```````````````````````````````` example
3904	>
3905	>
3906	>
3907	.
3908	<blockquote>
3909	</blockquote>
3910	````````````````````````````````
3911
3912
3913	A block quote can have initial or final blank lines:
3914
3915	```````````````````````````````` example
3916	>
3917	> foo
3918	>
3919	.
3920	<blockquote>
3921	<p>foo</p>
3922	</blockquote>
3923	````````````````````````````````
3924
3925
3926	A blank line always separates block quotes:
3927
3928	```````````````````````````````` example
3929	> foo
3930
3931	> bar
3932	.
3933	<blockquote>
3934	<p>foo</p>
3935	</blockquote>
3936	<blockquote>
3937	<p>bar</p>
3938	</blockquote>
3939	````````````````````````````````
3940
3941
3942	(Most current Markdown implementations, including John Gruber's
3943	original `Markdown.pl`, will parse this example as a single block quote
3944	with two paragraphs. But it seems better to allow the author to decide
3945	whether two block quotes or one are wanted.)
3946
3947	Consecutiveness means that if we put these block quotes together,
3948	we get a single block quote:
3949
3950	```````````````````````````````` example
3951	> foo
3952	> bar
3953	.
3954	<blockquote>
3955	<p>foo
3956	bar</p>
3957	</blockquote>
3958	````````````````````````````````
3959
3960
3961	To get a block quote with two paragraphs, use:
3962
3963	```````````````````````````````` example
3964	> foo
3965	>
3966	> bar
3967	.
3968	<blockquote>
3969	<p>foo</p>
3970	<p>bar</p>
3971	</blockquote>
3972	````````````````````````````````
3973
3974
3975	Block quotes can interrupt paragraphs:
3976
3977	```````````````````````````````` example
3978	foo
3979	> bar
3980	.
3981	<p>foo</p>
3982	<blockquote>
3983	<p>bar</p>
3984	</blockquote>
3985	````````````````````````````````
3986
3987
3988	In general, blank lines are not needed before or after block
3989	quotes:
3990
3991	```````````````````````````````` example
3992	> aaa
3993	***
3994	> bbb
3995	.
3996	<blockquote>
3997	<p>aaa</p>
3998	</blockquote>
3999	<hr />
4000	<blockquote>
4001	<p>bbb</p>
4002	</blockquote>
4003	````````````````````````````````
4004
4005
4006	However, because of laziness, a blank line is needed between
4007	a block quote and a following paragraph:
4008
4009	```````````````````````````````` example
4010	> bar
4011	baz
4012	.
4013	<blockquote>
4014	<p>bar
4015	baz</p>
4016	</blockquote>
4017	````````````````````````````````
4018
4019
4020	```````````````````````````````` example
4021	> bar
4022
4023	baz
4024	.
4025	<blockquote>
4026	<p>bar</p>
4027	</blockquote>
4028	<p>baz</p>
4029	````````````````````````````````
4030
4031
4032	```````````````````````````````` example
4033	> bar
4034	>
4035	baz
4036	.
4037	<blockquote>
4038	<p>bar</p>
4039	</blockquote>
4040	<p>baz</p>
4041	````````````````````````````````
4042
4043
4044	It is a consequence of the Laziness rule that any number
4045	of initial `>`s may be omitted on a continuation line of a
4046	nested block quote:
4047
4048	```````````````````````````````` example
4049	> > > foo
4050	bar
4051	.
4052	<blockquote>
4053	<blockquote>
4054	<blockquote>
4055	<p>foo
4056	bar</p>
4057	</blockquote>
4058	</blockquote>
4059	</blockquote>
4060	````````````````````````````````
4061
4062
4063	```````````````````````````````` example
4064	>>> foo
4065	> bar
4066	>>baz
4067	.
4068	<blockquote>
4069	<blockquote>
4070	<blockquote>
4071	<p>foo
4072	bar
4073	baz</p>
4074	</blockquote>
4075	</blockquote>
4076	</blockquote>
4077	````````````````````````````````
4078
4079
4080	When including an indented code block in a block quote,
4081	remember that the [block quote marker] includes
4082	both the `>` and a following space of indentation. So five spaces are needed
4083	after the `>`:
4084
4085	```````````````````````````````` example
4086	> code
4087
4088	> not code
4089	.
4090	<blockquote>
4091	<pre><code>code
4092	</code></pre>
4093	</blockquote>
4094	<blockquote>
4095	<p>not code</p>
4096	</blockquote>
4097	````````````````````````````````
4098
4099
4100
4101	## List items
4102
4103	A [list marker](@) is a
4104	[bullet list marker] or an [ordered list marker].
4105
4106	A [bullet list marker](@)
4107	is a `-`, `+`, or `*` character.
4108
4109	An [ordered list marker](@)
4110	is a sequence of 1--9 arabic digits (`0-9`), followed by either a
4111	`.` character or a `)` character. (The reason for the length
4112	limit is that with 10 digits we start seeing integer overflows
4113	in some browsers.)
4114
4115	The following rules define [list items]:
4116
4117	1. Basic case. If a sequence of lines Ls constitute a sequence of
4118	blocks Bs starting with a character other than a space or tab, and M is
4119	a list marker of width W followed by 1 ≤ N ≤ 4 spaces of indentation,
4120	then the result of prepending M and the following spaces to the first line
4121	of Ls, and indenting subsequent lines of Ls* by W + N spaces, is a
4122	list item with Bs as its contents. The type of the list item
4123	(bullet or ordered) is determined by the type of its list marker.
4124	If the list item is ordered, then it is also assigned a start
4125	number, based on the ordered list marker.
4126
4127	Exceptions:
4128
4129	1. When the first list item in a [list] interrupts
4130	a paragraph---that is, when it starts on a line that would
4131	otherwise count as [paragraph continuation text]---then (a)
4132	the lines Ls must not begin with a blank line, and (b) if
4133	the list item is ordered, the start number must be 1.
4134	2. If any line is a [thematic break][thematic breaks] then
4135	that line is not a list item.
4136
4137	For example, let Ls be the lines
4138
4139	```````````````````````````````` example
4140	A paragraph
4141	with two lines.
4142
4143	indented code
4144
4145	> A block quote.
4146	.
4147	<p>A paragraph
4148	with two lines.</p>
4149	<pre><code>indented code
4150	</code></pre>
4151	<blockquote>
4152	<p>A block quote.</p>
4153	</blockquote>
4154	````````````````````````````````
4155
4156
4157	And let M be the marker `1.`, and N = 2. Then rule #1 says
4158	that the following is an ordered list item with start number 1,
4159	and the same contents as Ls:
4160
4161	```````````````````````````````` example
4162	1. A paragraph
4163	with two lines.
4164
4165	indented code
4166
4167	> A block quote.
4168	.
4169	<ol>
4170	<li>
4171	<p>A paragraph
4172	with two lines.</p>
4173	<pre><code>indented code
4174	</code></pre>
4175	<blockquote>
4176	<p>A block quote.</p>
4177	</blockquote>
4178	</li>
4179	</ol>
4180	````````````````````````````````
4181
4182
4183	The most important thing to notice is that the position of
4184	the text after the list marker determines how much indentation
4185	is needed in subsequent blocks in the list item. If the list
4186	marker takes up two spaces of indentation, and there are three spaces between
4187	the list marker and the next character other than a space or tab, then blocks
4188	must be indented five spaces in order to fall under the list
4189	item.
4190
4191	Here are some examples showing how far content must be indented to be
4192	put under the list item:
4193
4194	```````````````````````````````` example
4195	- one
4196
4197	two
4198	.
4199	<ul>
4200	<li>one</li>
4201	</ul>
4202	<p>two</p>
4203	````````````````````````````````
4204
4205
4206	```````````````````````````````` example
4207	- one
4208
4209	two
4210	.
4211	<ul>
4212	<li>
4213	<p>one</p>
4214	<p>two</p>
4215	</li>
4216	</ul>
4217	````````````````````````````````
4218
4219
4220	```````````````````````````````` example
4221	- one
4222
4223	two
4224	.
4225	<ul>
4226	<li>one</li>
4227	</ul>
4228	<pre><code> two
4229	</code></pre>
4230	````````````````````````````````
4231
4232
4233	```````````````````````````````` example
4234	- one
4235
4236	two
4237	.
4238	<ul>
4239	<li>
4240	<p>one</p>
4241	<p>two</p>
4242	</li>
4243	</ul>
4244	````````````````````````````````
4245
4246
4247	It is tempting to think of this in terms of columns: the continuation
4248	blocks must be indented at least to the column of the first character other than
4249	a space or tab after the list marker. However, that is not quite right.
4250	The spaces of indentation after the list marker determine how much relative
4251	indentation is needed. Which column this indentation reaches will depend on
4252	how the list item is embedded in other constructions, as shown by
4253	this example:
4254
4255	```````````````````````````````` example
4256	> > 1. one
4257	>>
4258	>> two
4259	.
4260	<blockquote>
4261	<blockquote>
4262	<ol>
4263	<li>
4264	<p>one</p>
4265	<p>two</p>
4266	</li>
4267	</ol>
4268	</blockquote>
4269	</blockquote>
4270	````````````````````````````````
4271
4272
4273	Here `two` occurs in the same column as the list marker `1.`,
4274	but is actually contained in the list item, because there is
4275	sufficient indentation after the last containing blockquote marker.
4276
4277	The converse is also possible. In the following example, the word `two`
4278	occurs far to the right of the initial text of the list item, `one`, but
4279	it is not considered part of the list item, because it is not indented
4280	far enough past the blockquote marker:
4281
4282	```````````````````````````````` example
4283	>>- one
4284	>>
4285	> > two
4286	.
4287	<blockquote>
4288	<blockquote>
4289	<ul>
4290	<li>one</li>
4291	</ul>
4292	<p>two</p>
4293	</blockquote>
4294	</blockquote>
4295	````````````````````````````````
4296
4297
4298	Note that at least one space or tab is needed between the list marker and
4299	any following content, so these are not list items:
4300
4301	```````````````````````````````` example
4302	-one
4303
4304	2.two
4305	.
4306	<p>-one</p>
4307	<p>2.two</p>
4308	````````````````````````````````
4309
4310
4311	A list item may contain blocks that are separated by more than
4312	one blank line.
4313
4314	```````````````````````````````` example
4315	- foo
4316
4317
4318	bar
4319	.
4320	<ul>
4321	<li>
4322	<p>foo</p>
4323	<p>bar</p>
4324	</li>
4325	</ul>
4326	````````````````````````````````
4327
4328
4329	A list item may contain any kind of block:
4330
4331	```````````````````````````````` example
4332	1. foo
4333
4334	```
4335	bar
4336	```
4337
4338	baz
4339
4340	> bam
4341	.
4342	<ol>
4343	<li>
4344	<p>foo</p>
4345	<pre><code>bar
4346	</code></pre>
4347	<p>baz</p>
4348	<blockquote>
4349	<p>bam</p>
4350	</blockquote>
4351	</li>
4352	</ol>
4353	````````````````````````````````
4354
4355
4356	A list item that contains an indented code block will preserve
4357	empty lines within the code block verbatim.
4358
4359	```````````````````````````````` example
4360	- Foo
4361
4362	bar
4363
4364
4365	baz
4366	.
4367	<ul>
4368	<li>
4369	<p>Foo</p>
4370	<pre><code>bar
4371
4372
4373	baz
4374	</code></pre>
4375	</li>
4376	</ul>
4377	````````````````````````````````
4378
4379	Note that ordered list start numbers must be nine digits or less:
4380
4381	```````````````````````````````` example
4382	123456789. ok
4383	.
4384	<ol start="123456789">
4385	<li>ok</li>
4386	</ol>
4387	````````````````````````````````
4388
4389
4390	```````````````````````````````` example
4391	1234567890. not ok
4392	.
4393	<p>1234567890. not ok</p>
4394	````````````````````````````````
4395
4396
4397	A start number may begin with 0s:
4398
4399	```````````````````````````````` example
4400	0. ok
4401	.
4402	<ol start="0">
4403	<li>ok</li>
4404	</ol>
4405	````````````````````````````````
4406
4407
4408	```````````````````````````````` example
4409	003. ok
4410	.
4411	<ol start="3">
4412	<li>ok</li>
4413	</ol>
4414	````````````````````````````````
4415
4416
4417	A start number may not be negative:
4418
4419	```````````````````````````````` example
4420	-1. not ok
4421	.
4422	<p>-1. not ok</p>
4423	````````````````````````````````
4424
4425
4426
4427	2. Item starting with indented code. If a sequence of lines Ls
4428	constitute a sequence of blocks Bs starting with an indented code
4429	block, and M is a list marker of width W followed by
4430	one space of indentation, then the result of prepending M and the
4431	following space to the first line of Ls, and indenting subsequent lines
4432	of Ls by W + 1 spaces, is a list item with Bs as its contents.
4433	If a line is empty, then it need not be indented. The type of the
4434	list item (bullet or ordered) is determined by the type of its list
4435	marker. If the list item is ordered, then it is also assigned a
4436	start number, based on the ordered list marker.
4437
4438	An indented code block will have to be preceded by four spaces of indentation
4439	beyond the edge of the region where text will be included in the list item.
4440	In the following case that is 6 spaces:
4441
4442	```````````````````````````````` example
4443	- foo
4444
4445	bar
4446	.
4447	<ul>
4448	<li>
4449	<p>foo</p>
4450	<pre><code>bar
4451	</code></pre>
4452	</li>
4453	</ul>
4454	````````````````````````````````
4455
4456
4457	And in this case it is 11 spaces:
4458
4459	```````````````````````````````` example
4460	10. foo
4461
4462	bar
4463	.
4464	<ol start="10">
4465	<li>
4466	<p>foo</p>
4467	<pre><code>bar
4468	</code></pre>
4469	</li>
4470	</ol>
4471	````````````````````````````````
4472
4473
4474	If the first block in the list item is an indented code block,
4475	then by rule #2, the contents must be preceded by one space of indentation
4476	after the list marker:
4477
4478	```````````````````````````````` example
4479	indented code
4480
4481	paragraph
4482
4483	more code
4484	.
4485	<pre><code>indented code
4486	</code></pre>
4487	<p>paragraph</p>
4488	<pre><code>more code
4489	</code></pre>
4490	````````````````````````````````
4491
4492
4493	```````````````````````````````` example
4494	1. indented code
4495
4496	paragraph
4497
4498	more code
4499	.
4500	<ol>
4501	<li>
4502	<pre><code>indented code
4503	</code></pre>
4504	<p>paragraph</p>
4505	<pre><code>more code
4506	</code></pre>
4507	</li>
4508	</ol>
4509	````````````````````````````````
4510
4511
4512	Note that an additional space of indentation is interpreted as space
4513	inside the code block:
4514
4515	```````````````````````````````` example
4516	1. indented code
4517
4518	paragraph
4519
4520	more code
4521	.
4522	<ol>
4523	<li>
4524	<pre><code> indented code
4525	</code></pre>
4526	<p>paragraph</p>
4527	<pre><code>more code
4528	</code></pre>
4529	</li>
4530	</ol>
4531	````````````````````````````````
4532
4533
4534	Note that rules #1 and #2 only apply to two cases: (a) cases
4535	in which the lines to be included in a list item begin with a
4536	characer other than a space or tab, and (b) cases in which
4537	they begin with an indented code
4538	block. In a case like the following, where the first block begins with
4539	three spaces of indentation, the rules do not allow us to form a list item by
4540	indenting the whole thing and prepending a list marker:
4541
4542	```````````````````````````````` example
4543	foo
4544
4545	bar
4546	.
4547	<p>foo</p>
4548	<p>bar</p>
4549	````````````````````````````````
4550
4551
4552	```````````````````````````````` example
4553	- foo
4554
4555	bar
4556	.
4557	<ul>
4558	<li>foo</li>
4559	</ul>
4560	<p>bar</p>
4561	````````````````````````````````
4562
4563
4564	This is not a significant restriction, because when a block is preceded by up to
4565	three spaces of indentation, the indentation can always be removed without
4566	a change in interpretation, allowing rule #1 to be applied. So, in
4567	the above case:
4568
4569	```````````````````````````````` example
4570	- foo
4571
4572	bar
4573	.
4574	<ul>
4575	<li>
4576	<p>foo</p>
4577	<p>bar</p>
4578	</li>
4579	</ul>
4580	````````````````````````````````
4581
4582
4583	3. Item starting with a blank line. If a sequence of lines Ls
4584	starting with a single [blank line] constitute a (possibly empty)
4585	sequence of blocks Bs, and M is a list marker of width W,
4586	then the result of prepending M to the first line of Ls, and
4587	preceding subsequent lines of Ls by W + 1 spaces of indentation, is a
4588	list item with Bs as its contents.
4589	If a line is empty, then it need not be indented. The type of the
4590	list item (bullet or ordered) is determined by the type of its list
4591	marker. If the list item is ordered, then it is also assigned a
4592	start number, based on the ordered list marker.
4593
4594	Here are some list items that start with a blank line but are not empty:
4595
4596	```````````````````````````````` example
4597	-
4598	foo
4599	-
4600	```
4601	bar
4602	```
4603	-
4604	baz
4605	.
4606	<ul>
4607	<li>foo</li>
4608	<li>
4609	<pre><code>bar
4610	</code></pre>
4611	</li>
4612	<li>
4613	<pre><code>baz
4614	</code></pre>
4615	</li>
4616	</ul>
4617	````````````````````````````````
4618
4619	When the list item starts with a blank line, the number of spaces
4620	following the list marker doesn't change the required indentation:
4621
4622	```````````````````````````````` example
4623	-
4624	foo
4625	.
4626	<ul>
4627	<li>foo</li>
4628	</ul>
4629	````````````````````````````````
4630
4631
4632	A list item can begin with at most one blank line.
4633	In the following example, `foo` is not part of the list
4634	item:
4635
4636	```````````````````````````````` example
4637	-
4638
4639	foo
4640	.
4641	<ul>
4642	<li></li>
4643	</ul>
4644	<p>foo</p>
4645	````````````````````````````````
4646
4647
4648	Here is an empty bullet list item:
4649
4650	```````````````````````````````` example
4651	- foo
4652	-
4653	- bar
4654	.
4655	<ul>
4656	<li>foo</li>
4657	<li></li>
4658	<li>bar</li>
4659	</ul>
4660	````````````````````````````````
4661
4662
4663	It does not matter whether there are spaces or tabs following the [list marker]:
4664
4665	```````````````````````````````` example
4666	- foo
4667	-
4668	- bar
4669	.
4670	<ul>
4671	<li>foo</li>
4672	<li></li>
4673	<li>bar</li>
4674	</ul>
4675	````````````````````````````````
4676
4677
4678	Here is an empty ordered list item:
4679
4680	```````````````````````````````` example
4681	1. foo
4682	2.
4683	3. bar
4684	.
4685	<ol>
4686	<li>foo</li>
4687	<li></li>
4688	<li>bar</li>
4689	</ol>
4690	````````````````````````````````
4691
4692
4693	A list may start or end with an empty list item:
4694
4695	```````````````````````````````` example
4696	*
4697	.
4698	<ul>
4699	<li></li>
4700	</ul>
4701	````````````````````````````````
4702
4703	However, an empty list item cannot interrupt a paragraph:
4704
4705	```````````````````````````````` example
4706	foo
4707	*
4708
4709	foo
4710	1.
4711	.
4712	<p>foo
4713	*</p>
4714	<p>foo
4715	1.</p>
4716	````````````````````````````````
4717
4718
4719	4. Indentation. If a sequence of lines Ls constitutes a list item
4720	according to rule #1, #2, or #3, then the result of preceding each line
4721	of Ls by up to three spaces of indentation (the same for each line) also
4722	constitutes a list item with the same contents and attributes. If a line is
4723	empty, then it need not be indented.
4724
4725	Indented one space:
4726
4727	```````````````````````````````` example
4728	1. A paragraph
4729	with two lines.
4730
4731	indented code
4732
4733	> A block quote.
4734	.
4735	<ol>
4736	<li>
4737	<p>A paragraph
4738	with two lines.</p>
4739	<pre><code>indented code
4740	</code></pre>
4741	<blockquote>
4742	<p>A block quote.</p>
4743	</blockquote>
4744	</li>
4745	</ol>
4746	````````````````````````````````
4747
4748
4749	Indented two spaces:
4750
4751	```````````````````````````````` example
4752	1. A paragraph
4753	with two lines.
4754
4755	indented code
4756
4757	> A block quote.
4758	.
4759	<ol>
4760	<li>
4761	<p>A paragraph
4762	with two lines.</p>
4763	<pre><code>indented code
4764	</code></pre>
4765	<blockquote>
4766	<p>A block quote.</p>
4767	</blockquote>
4768	</li>
4769	</ol>
4770	````````````````````````````````
4771
4772
4773	Indented three spaces:
4774
4775	```````````````````````````````` example
4776	1. A paragraph
4777	with two lines.
4778
4779	indented code
4780
4781	> A block quote.
4782	.
4783	<ol>
4784	<li>
4785	<p>A paragraph
4786	with two lines.</p>
4787	<pre><code>indented code
4788	</code></pre>
4789	<blockquote>
4790	<p>A block quote.</p>
4791	</blockquote>
4792	</li>
4793	</ol>
4794	````````````````````````````````
4795
4796
4797	Four spaces indent gives a code block:
4798
4799	```````````````````````````````` example
4800	1. A paragraph
4801	with two lines.
4802
4803	indented code
4804
4805	> A block quote.
4806	.
4807	<pre><code>1. A paragraph
4808	with two lines.
4809
4810	indented code
4811
4812	> A block quote.
4813	</code></pre>
4814	````````````````````````````````
4815
4816
4817
4818	5. Laziness. If a string of lines Ls constitute a [list
4819	item](#list-items) with contents Bs, then the result of deleting
4820	some or all of the indentation from one or more lines in which the
4821	next character other than a space or tab after the indentation is
4822	[paragraph continuation text] is a
4823	list item with the same contents and attributes. The unindented
4824	lines are called
4825	[lazy continuation line](@)s.
4826
4827	Here is an example with [lazy continuation lines]:
4828
4829	```````````````````````````````` example
4830	1. A paragraph
4831	with two lines.
4832
4833	indented code
4834
4835	> A block quote.
4836	.
4837	<ol>
4838	<li>
4839	<p>A paragraph
4840	with two lines.</p>
4841	<pre><code>indented code
4842	</code></pre>
4843	<blockquote>
4844	<p>A block quote.</p>
4845	</blockquote>
4846	</li>
4847	</ol>
4848	````````````````````````````````
4849
4850
4851	Indentation can be partially deleted:
4852
4853	```````````````````````````````` example
4854	1. A paragraph
4855	with two lines.
4856	.
4857	<ol>
4858	<li>A paragraph
4859	with two lines.</li>
4860	</ol>
4861	````````````````````````````````
4862
4863
4864	These examples show how laziness can work in nested structures:
4865
4866	```````````````````````````````` example
4867	> 1. > Blockquote
4868	continued here.
4869	.
4870	<blockquote>
4871	<ol>
4872	<li>
4873	<blockquote>
4874	<p>Blockquote
4875	continued here.</p>
4876	</blockquote>
4877	</li>
4878	</ol>
4879	</blockquote>
4880	````````````````````````````````
4881
4882
4883	```````````````````````````````` example
4884	> 1. > Blockquote
4885	> continued here.
4886	.
4887	<blockquote>
4888	<ol>
4889	<li>
4890	<blockquote>
4891	<p>Blockquote
4892	continued here.</p>
4893	</blockquote>
4894	</li>
4895	</ol>
4896	</blockquote>
4897	````````````````````````````````
4898
4899
4900
4901	6. That's all. Nothing that is not counted as a list item by rules
4902	#1--5 counts as a [list item](#list-items).
4903
4904	The rules for sublists follow from the general rules
4905	[above][List items]. A sublist must be indented the same number
4906	of spaces of indentation a paragraph would need to be in order to be included
4907	in the list item.
4908
4909	So, in this case we need two spaces indent:
4910
4911	```````````````````````````````` example
4912	- foo
4913	- bar
4914	- baz
4915	- boo
4916	.
4917	<ul>
4918	<li>foo
4919	<ul>
4920	<li>bar
4921	<ul>
4922	<li>baz
4923	<ul>
4924	<li>boo</li>
4925	</ul>
4926	</li>
4927	</ul>
4928	</li>
4929	</ul>
4930	</li>
4931	</ul>
4932	````````````````````````````````
4933
4934
4935	One is not enough:
4936
4937	```````````````````````````````` example
4938	- foo
4939	- bar
4940	- baz
4941	- boo
4942	.
4943	<ul>
4944	<li>foo</li>
4945	<li>bar</li>
4946	<li>baz</li>
4947	<li>boo</li>
4948	</ul>
4949	````````````````````````````````
4950
4951
4952	Here we need four, because the list marker is wider:
4953
4954	```````````````````````````````` example
4955	10) foo
4956	- bar
4957	.
4958	<ol start="10">
4959	<li>foo
4960	<ul>
4961	<li>bar</li>
4962	</ul>
4963	</li>
4964	</ol>
4965	````````````````````````````````
4966
4967
4968	Three is not enough:
4969
4970	```````````````````````````````` example
4971	10) foo
4972	- bar
4973	.
4974	<ol start="10">
4975	<li>foo</li>
4976	</ol>
4977	<ul>
4978	<li>bar</li>
4979	</ul>
4980	````````````````````````````````
4981
4982
4983	A list may be the first block in a list item:
4984
4985	```````````````````````````````` example
4986	- - foo
4987	.
4988	<ul>
4989	<li>
4990	<ul>
4991	<li>foo</li>
4992	</ul>
4993	</li>
4994	</ul>
4995	````````````````````````````````
4996
4997
4998	```````````````````````````````` example
4999	1. - 2. foo
5000	.
5001	<ol>
5002	<li>
5003	<ul>
5004	<li>
5005	<ol start="2">
5006	<li>foo</li>
5007	</ol>
5008	</li>
5009	</ul>
5010	</li>
5011	</ol>
5012	````````````````````````````````
5013
5014
5015	A list item can contain a heading:
5016
5017	```````````````````````````````` example
5018	- # Foo
5019	- Bar
5020	---
5021	baz
5022	.
5023	<ul>
5024	<li>
5025	<h1>Foo</h1>
5026	</li>
5027	<li>
5028	<h2>Bar</h2>
5029	baz</li>
5030	</ul>
5031	````````````````````````````````
5032
5033
5034	### Motivation
5035
5036	John Gruber's Markdown spec says the following about list items:
5037
5038	1. "List markers typically start at the left margin, but may be indented
5039	by up to three spaces. List markers must be followed by one or more
5040	spaces or a tab."
5041
5042	2. "To make lists look nice, you can wrap items with hanging indents....
5043	But if you don't want to, you don't have to."
5044
5045	3. "List items may consist of multiple paragraphs. Each subsequent
5046	paragraph in a list item must be indented by either 4 spaces or one
5047	tab."
5048
5049	4. "It looks nice if you indent every line of the subsequent paragraphs,
5050	but here again, Markdown will allow you to be lazy."
5051
5052	5. "To put a blockquote within a list item, the blockquote's `>`
5053	delimiters need to be indented."
5054
5055	6. "To put a code block within a list item, the code block needs to be
5056	indented twice — 8 spaces or two tabs."
5057
5058	These rules specify that a paragraph under a list item must be indented
5059	four spaces (presumably, from the left margin, rather than the start of
5060	the list marker, but this is not said), and that code under a list item
5061	must be indented eight spaces instead of the usual four. They also say
5062	that a block quote must be indented, but not by how much; however, the
5063	example given has four spaces indentation. Although nothing is said
5064	about other kinds of block-level content, it is certainly reasonable to
5065	infer that all block elements under a list item, including other
5066	lists, must be indented four spaces. This principle has been called the
5067	four-space rule.
5068
5069	The four-space rule is clear and principled, and if the reference
5070	implementation `Markdown.pl` had followed it, it probably would have
5071	become the standard. However, `Markdown.pl` allowed paragraphs and
5072	sublists to start with only two spaces indentation, at least on the
5073	outer level. Worse, its behavior was inconsistent: a sublist of an
5074	outer-level list needed two spaces indentation, but a sublist of this
5075	sublist needed three spaces. It is not surprising, then, that different
5076	implementations of Markdown have developed very different rules for
5077	determining what comes under a list item. (Pandoc and python-Markdown,
5078	for example, stuck with Gruber's syntax description and the four-space
5079	rule, while discount, redcarpet, marked, PHP Markdown, and others
5080	followed `Markdown.pl`'s behavior more closely.)
5081
5082	Unfortunately, given the divergences between implementations, there
5083	is no way to give a spec for list items that will be guaranteed not
5084	to break any existing documents. However, the spec given here should
5085	correctly handle lists formatted with either the four-space rule or
5086	the more forgiving `Markdown.pl` behavior, provided they are laid out
5087	in a way that is natural for a human to read.
5088
5089	The strategy here is to let the width and indentation of the list marker
5090	determine the indentation necessary for blocks to fall under the list
5091	item, rather than having a fixed and arbitrary number. The writer can
5092	think of the body of the list item as a unit which gets indented to the
5093	right enough to fit the list marker (and any indentation on the list
5094	marker). (The laziness rule, #5, then allows continuation lines to be
5095	unindented if needed.)
5096
5097	This rule is superior, we claim, to any rule requiring a fixed level of
5098	indentation from the margin. The four-space rule is clear but
5099	unnatural. It is quite unintuitive that
5100
5101	``` markdown
5102	- foo
5103
5104	bar
5105
5106	- baz
5107	```
5108
5109	should be parsed as two lists with an intervening paragraph,
5110
5111	``` html
5112	<ul>
5113	<li>foo</li>
5114	</ul>
5115	<p>bar</p>
5116	<ul>
5117	<li>baz</li>
5118	</ul>
5119	```
5120
5121	as the four-space rule demands, rather than a single list,
5122
5123	``` html
5124	<ul>
5125	<li>
5126	<p>foo</p>
5127	<p>bar</p>
5128	<ul>
5129	<li>baz</li>
5130	</ul>
5131	</li>
5132	</ul>
5133	```
5134
5135	The choice of four spaces is arbitrary. It can be learned, but it is
5136	not likely to be guessed, and it trips up beginners regularly.
5137
5138	Would it help to adopt a two-space rule? The problem is that such
5139	a rule, together with the rule allowing up to three spaces of indentation for
5140	the initial list marker, allows text that is indented less than the
5141	original list marker to be included in the list item. For example,
5142	`Markdown.pl` parses
5143
5144	``` markdown
5145	- one
5146
5147	two
5148	```
5149
5150	as a single list item, with `two` a continuation paragraph:
5151
5152	``` html
5153	<ul>
5154	<li>
5155	<p>one</p>
5156	<p>two</p>
5157	</li>
5158	</ul>
5159	```
5160
5161	and similarly
5162
5163	``` markdown
5164	> - one
5165	>
5166	> two
5167	```
5168
5169	as
5170
5171	``` html
5172	<blockquote>
5173	<ul>
5174	<li>
5175	<p>one</p>
5176	<p>two</p>
5177	</li>
5178	</ul>
5179	</blockquote>
5180	```
5181
5182	This is extremely unintuitive.
5183
5184	Rather than requiring a fixed indent from the margin, we could require
5185	a fixed indent (say, two spaces, or even one space) from the list marker (which
5186	may itself be indented). This proposal would remove the last anomaly
5187	discussed. Unlike the spec presented above, it would count the following
5188	as a list item with a subparagraph, even though the paragraph `bar`
5189	is not indented as far as the first paragraph `foo`:
5190
5191	``` markdown
5192	10. foo
5193
5194	bar
5195	```
5196
5197	Arguably this text does read like a list item with `bar` as a subparagraph,
5198	which may count in favor of the proposal. However, on this proposal indented
5199	code would have to be indented six spaces after the list marker. And this
5200	would break a lot of existing Markdown, which has the pattern:
5201
5202	``` markdown
5203	1. foo
5204
5205	indented code
5206	```
5207
5208	where the code is indented eight spaces. The spec above, by contrast, will
5209	parse this text as expected, since the code block's indentation is measured
5210	from the beginning of `foo`.
5211
5212	The one case that needs special treatment is a list item that starts
5213	with indented code. How much indentation is required in that case, since
5214	we don't have a "first paragraph" to measure from? Rule #2 simply stipulates
5215	that in such cases, we require one space indentation from the list marker
5216	(and then the normal four spaces for the indented code). This will match the
5217	four-space rule in cases where the list marker plus its initial indentation
5218	takes four spaces (a common case), but diverge in other cases.
5219
5220	## Lists
5221
5222	A [list](@) is a sequence of one or more
5223	list items [of the same type]. The list items
5224	may be separated by any number of blank lines.
5225
5226	Two list items are [of the same type](@)
5227	if they begin with a [list marker] of the same type.
5228	Two list markers are of the
5229	same type if (a) they are bullet list markers using the same character
5230	(`-`, `+`, or `*`) or (b) they are ordered list numbers with the same
5231	delimiter (either `.` or `)`).
5232
5233	A list is an [ordered list](@)
5234	if its constituent list items begin with
5235	[ordered list markers], and a
5236	[bullet list](@) if its constituent list
5237	items begin with [bullet list markers].
5238
5239	The [start number](@)
5240	of an [ordered list] is determined by the list number of
5241	its initial list item. The numbers of subsequent list items are
5242	disregarded.
5243
5244	A list is [loose](@) if any of its constituent
5245	list items are separated by blank lines, or if any of its constituent
5246	list items directly contain two block-level elements with a blank line
5247	between them. Otherwise a list is [tight](@).
5248	(The difference in HTML output is that paragraphs in a loose list are
5249	wrapped in `<p>` tags, while paragraphs in a tight list are not.)
5250
5251	Changing the bullet or ordered list delimiter starts a new list:
5252
5253	```````````````````````````````` example
5254	- foo
5255	- bar
5256	+ baz
5257	.
5258	<ul>
5259	<li>foo</li>
5260	<li>bar</li>
5261	</ul>
5262	<ul>
5263	<li>baz</li>
5264	</ul>
5265	````````````````````````````````
5266
5267
5268	```````````````````````````````` example
5269	1. foo
5270	2. bar
5271	3) baz
5272	.
5273	<ol>
5274	<li>foo</li>
5275	<li>bar</li>
5276	</ol>
5277	<ol start="3">
5278	<li>baz</li>
5279	</ol>
5280	````````````````````````````````
5281
5282
5283	In CommonMark, a list can interrupt a paragraph. That is,
5284	no blank line is needed to separate a paragraph from a following
5285	list:
5286
5287	```````````````````````````````` example
5288	Foo
5289	- bar
5290	- baz
5291	.
5292	<p>Foo</p>
5293	<ul>
5294	<li>bar</li>
5295	<li>baz</li>
5296	</ul>
5297	````````````````````````````````
5298
5299	`Markdown.pl` does not allow this, through fear of triggering a list
5300	via a numeral in a hard-wrapped line:
5301
5302	``` markdown
5303	The number of windows in my house is
5304	14. The number of doors is 6.
5305	```
5306
5307	Oddly, though, `Markdown.pl` does allow a blockquote to
5308	interrupt a paragraph, even though the same considerations might
5309	apply.
5310
5311	In CommonMark, we do allow lists to interrupt paragraphs, for
5312	two reasons. First, it is natural and not uncommon for people
5313	to start lists without blank lines:
5314
5315	``` markdown
5316	I need to buy
5317	- new shoes
5318	- a coat
5319	- a plane ticket
5320	```
5321
5322	Second, we are attracted to a
5323
5324	> [principle of uniformity](@):
5325	> if a chunk of text has a certain
5326	> meaning, it will continue to have the same meaning when put into a
5327	> container block (such as a list item or blockquote).
5328
5329	(Indeed, the spec for [list items] and [block quotes] presupposes
5330	this principle.) This principle implies that if
5331
5332	``` markdown
5333	* I need to buy
5334	- new shoes
5335	- a coat
5336	- a plane ticket
5337	```
5338
5339	is a list item containing a paragraph followed by a nested sublist,
5340	as all Markdown implementations agree it is (though the paragraph
5341	may be rendered without `<p>` tags, since the list is "tight"),
5342	then
5343
5344	``` markdown
5345	I need to buy
5346	- new shoes
5347	- a coat
5348	- a plane ticket
5349	```
5350
5351	by itself should be a paragraph followed by a nested sublist.
5352
5353	Since it is well established Markdown practice to allow lists to
5354	interrupt paragraphs inside list items, the [principle of
5355	uniformity] requires us to allow this outside list items as
5356	well. ([reStructuredText](http://docutils.sourceforge.net/rst.html)
5357	takes a different approach, requiring blank lines before lists
5358	even inside other list items.)
5359
5360	In order to solve of unwanted lists in paragraphs with
5361	hard-wrapped numerals, we allow only lists starting with `1` to
5362	interrupt paragraphs. Thus,
5363
5364	```````````````````````````````` example
5365	The number of windows in my house is
5366	14. The number of doors is 6.
5367	.
5368	<p>The number of windows in my house is
5369	14. The number of doors is 6.</p>
5370	````````````````````````````````
5371
5372	We may still get an unintended result in cases like
5373
5374	```````````````````````````````` example
5375	The number of windows in my house is
5376	1. The number of doors is 6.
5377	.
5378	<p>The number of windows in my house is</p>
5379	<ol>
5380	<li>The number of doors is 6.</li>
5381	</ol>
5382	````````````````````````````````
5383
5384	but this rule should prevent most spurious list captures.
5385
5386	There can be any number of blank lines between items:
5387
5388	```````````````````````````````` example
5389	- foo
5390
5391	- bar
5392
5393
5394	- baz
5395	.
5396	<ul>
5397	<li>
5398	<p>foo</p>
5399	</li>
5400	<li>
5401	<p>bar</p>
5402	</li>
5403	<li>
5404	<p>baz</p>
5405	</li>
5406	</ul>
5407	````````````````````````````````
5408
5409	```````````````````````````````` example
5410	- foo
5411	- bar
5412	- baz
5413
5414
5415	bim
5416	.
5417	<ul>
5418	<li>foo
5419	<ul>
5420	<li>bar
5421	<ul>
5422	<li>
5423	<p>baz</p>
5424	<p>bim</p>
5425	</li>
5426	</ul>
5427	</li>
5428	</ul>
5429	</li>
5430	</ul>
5431	````````````````````````````````
5432
5433
5434	To separate consecutive lists of the same type, or to separate a
5435	list from an indented code block that would otherwise be parsed
5436	as a subparagraph of the final list item, you can insert a blank HTML
5437	comment:
5438
5439	```````````````````````````````` example
5440	- foo
5441	- bar
5442
5443	<!-- -->
5444
5445	- baz
5446	- bim
5447	.
5448	<ul>
5449	<li>foo</li>
5450	<li>bar</li>
5451	</ul>
5452	<!-- -->
5453	<ul>
5454	<li>baz</li>
5455	<li>bim</li>
5456	</ul>
5457	````````````````````````````````
5458
5459
5460	```````````````````````````````` example
5461	- foo
5462
5463	notcode
5464
5465	- foo
5466
5467	<!-- -->
5468
5469	code
5470	.
5471	<ul>
5472	<li>
5473	<p>foo</p>
5474	<p>notcode</p>
5475	</li>
5476	<li>
5477	<p>foo</p>
5478	</li>
5479	</ul>
5480	<!-- -->
5481	<pre><code>code
5482	</code></pre>
5483	````````````````````````````````
5484
5485
5486	List items need not be indented to the same level. The following
5487	list items will be treated as items at the same list level,
5488	since none is indented enough to belong to the previous list
5489	item:
5490
5491	```````````````````````````````` example
5492	- a
5493	- b
5494	- c
5495	- d
5496	- e
5497	- f
5498	- g
5499	.
5500	<ul>
5501	<li>a</li>
5502	<li>b</li>
5503	<li>c</li>
5504	<li>d</li>
5505	<li>e</li>
5506	<li>f</li>
5507	<li>g</li>
5508	</ul>
5509	````````````````````````````````
5510
5511
5512	```````````````````````````````` example
5513	1. a
5514
5515	2. b
5516
5517	3. c
5518	.
5519	<ol>
5520	<li>
5521	<p>a</p>
5522	</li>
5523	<li>
5524	<p>b</p>
5525	</li>
5526	<li>
5527	<p>c</p>
5528	</li>
5529	</ol>
5530	````````````````````````````````
5531
5532	Note, however, that list items may not be preceded by more than
5533	three spaces of indentation. Here `- e` is treated as a paragraph continuation
5534	line, because it is indented more than three spaces:
5535
5536	```````````````````````````````` example
5537	- a
5538	- b
5539	- c
5540	- d
5541	- e
5542	.
5543	<ul>
5544	<li>a</li>
5545	<li>b</li>
5546	<li>c</li>
5547	<li>d
5548	- e</li>
5549	</ul>
5550	````````````````````````````````
5551
5552	And here, `3. c` is treated as in indented code block,
5553	because it is indented four spaces and preceded by a
5554	blank line.
5555
5556	```````````````````````````````` example
5557	1. a
5558
5559	2. b
5560
5561	3. c
5562	.
5563	<ol>
5564	<li>
5565	<p>a</p>
5566	</li>
5567	<li>
5568	<p>b</p>
5569	</li>
5570	</ol>
5571	<pre><code>3. c
5572	</code></pre>
5573	````````````````````````````````
5574
5575
5576	This is a loose list, because there is a blank line between
5577	two of the list items:
5578
5579	```````````````````````````````` example
5580	- a
5581	- b
5582
5583	- c
5584	.
5585	<ul>
5586	<li>
5587	<p>a</p>
5588	</li>
5589	<li>
5590	<p>b</p>
5591	</li>
5592	<li>
5593	<p>c</p>
5594	</li>
5595	</ul>
5596	````````````````````````````````
5597
5598
5599	So is this, with a empty second item:
5600
5601	```````````````````````````````` example
5602	* a
5603	*
5604
5605	* c
5606	.
5607	<ul>
5608	<li>
5609	<p>a</p>
5610	</li>
5611	<li></li>
5612	<li>
5613	<p>c</p>
5614	</li>
5615	</ul>
5616	````````````````````````````````
5617
5618
5619	These are loose lists, even though there are no blank lines between the items,
5620	because one of the items directly contains two block-level elements
5621	with a blank line between them:
5622
5623	```````````````````````````````` example
5624	- a
5625	- b
5626
5627	c
5628	- d
5629	.
5630	<ul>
5631	<li>
5632	<p>a</p>
5633	</li>
5634	<li>
5635	<p>b</p>
5636	<p>c</p>
5637	</li>
5638	<li>
5639	<p>d</p>
5640	</li>
5641	</ul>
5642	````````````````````````````````
5643
5644
5645	```````````````````````````````` example
5646	- a
5647	- b
5648
5649	[ref]: /url
5650	- d
5651	.
5652	<ul>
5653	<li>
5654	<p>a</p>
5655	</li>
5656	<li>
5657	<p>b</p>
5658	</li>
5659	<li>
5660	<p>d</p>
5661	</li>
5662	</ul>
5663	````````````````````````````````
5664
5665
5666	This is a tight list, because the blank lines are in a code block:
5667
5668	```````````````````````````````` example
5669	- a
5670	- ```
5671	b
5672
5673
5674	```
5675	- c
5676	.
5677	<ul>
5678	<li>a</li>
5679	<li>
5680	<pre><code>b
5681
5682
5683	</code></pre>
5684	</li>
5685	<li>c</li>
5686	</ul>
5687	````````````````````````````````
5688
5689
5690	This is a tight list, because the blank line is between two
5691	paragraphs of a sublist. So the sublist is loose while
5692	the outer list is tight:
5693
5694	```````````````````````````````` example
5695	- a
5696	- b
5697
5698	c
5699	- d
5700	.
5701	<ul>
5702	<li>a
5703	<ul>
5704	<li>
5705	<p>b</p>
5706	<p>c</p>
5707	</li>
5708	</ul>
5709	</li>
5710	<li>d</li>
5711	</ul>
5712	````````````````````````````````
5713
5714
5715	This is a tight list, because the blank line is inside the
5716	block quote:
5717
5718	```````````````````````````````` example
5719	* a
5720	> b
5721	>
5722	* c
5723	.
5724	<ul>
5725	<li>a
5726	<blockquote>
5727	<p>b</p>
5728	</blockquote>
5729	</li>
5730	<li>c</li>
5731	</ul>
5732	````````````````````````````````
5733
5734
5735	This list is tight, because the consecutive block elements
5736	are not separated by blank lines:
5737
5738	```````````````````````````````` example
5739	- a
5740	> b
5741	```
5742	c
5743	```
5744	- d
5745	.
5746	<ul>
5747	<li>a
5748	<blockquote>
5749	<p>b</p>
5750	</blockquote>
5751	<pre><code>c
5752	</code></pre>
5753	</li>
5754	<li>d</li>
5755	</ul>
5756	````````````````````````````````
5757
5758
5759	A single-paragraph list is tight:
5760
5761	```````````````````````````````` example
5762	- a
5763	.
5764	<ul>
5765	<li>a</li>
5766	</ul>
5767	````````````````````````````````
5768
5769
5770	```````````````````````````````` example
5771	- a
5772	- b
5773	.
5774	<ul>
5775	<li>a
5776	<ul>
5777	<li>b</li>
5778	</ul>
5779	</li>
5780	</ul>
5781	````````````````````````````````
5782
5783
5784	This list is loose, because of the blank line between the
5785	two block elements in the list item:
5786
5787	```````````````````````````````` example
5788	1. ```
5789	foo
5790	```
5791
5792	bar
5793	.
5794	<ol>
5795	<li>
5796	<pre><code>foo
5797	</code></pre>
5798	<p>bar</p>
5799	</li>
5800	</ol>
5801	````````````````````````````````
5802
5803
5804	Here the outer list is loose, the inner list tight:
5805
5806	```````````````````````````````` example
5807	* foo
5808	* bar
5809
5810	baz
5811	.
5812	<ul>
5813	<li>
5814	<p>foo</p>
5815	<ul>
5816	<li>bar</li>
5817	</ul>
5818	<p>baz</p>
5819	</li>
5820	</ul>
5821	````````````````````````````````
5822
5823
5824	```````````````````````````````` example
5825	- a
5826	- b
5827	- c
5828
5829	- d
5830	- e
5831	- f
5832	.
5833	<ul>
5834	<li>
5835	<p>a</p>
5836	<ul>
5837	<li>b</li>
5838	<li>c</li>
5839	</ul>
5840	</li>
5841	<li>
5842	<p>d</p>
5843	<ul>
5844	<li>e</li>
5845	<li>f</li>
5846	</ul>
5847	</li>
5848	</ul>
5849	````````````````````````````````
5850
5851
5852	# Inlines
5853
5854	Inlines are parsed sequentially from the beginning of the character
5855	stream to the end (left to right, in left-to-right languages).
5856	Thus, for example, in
5857
5858	```````````````````````````````` example
5859	`hi`lo`
5860	.
5861	<p><code>hi</code>lo`</p>
5862	````````````````````````````````
5863
5864	`hi` is parsed as code, leaving the backtick at the end as a literal
5865	backtick.
5866
5867
5868
5869	## Code spans
5870
5871	A [backtick string](@)
5872	is a string of one or more backtick characters (`` ` ``) that is neither
5873	preceded nor followed by a backtick.
5874
5875	A [code span](@) begins with a backtick string and ends with
5876	a backtick string of equal length. The contents of the code span are
5877	the characters between these two backtick strings, normalized in the
5878	following ways:
5879
5880	- First, [line endings] are converted to [spaces].
5881	- If the resulting string both begins and ends with a [space]
5882	character, but does not consist entirely of [space]
5883	characters, a single [space] character is removed from the
5884	front and back. This allows you to include code that begins
5885	or ends with backtick characters, which must be separated by
5886	whitespace from the opening or closing backtick strings.
5887
5888	This is a simple code span:
5889
5890	```````````````````````````````` example
5891	`foo`
5892	.
5893	<p><code>foo</code></p>
5894	````````````````````````````````
5895
5896
5897	Here two backticks are used, because the code contains a backtick.
5898	This example also illustrates stripping of a single leading and
5899	trailing space:
5900
5901	```````````````````````````````` example
5902	`` foo ` bar ``
5903	.
5904	<p><code>foo ` bar</code></p>
5905	````````````````````````````````
5906
5907
5908	This example shows the motivation for stripping leading and trailing
5909	spaces:
5910
5911	```````````````````````````````` example
5912	` `` `
5913	.
5914	<p><code>``</code></p>
5915	````````````````````````````````
5916
5917	Note that only one space is stripped:
5918
5919	```````````````````````````````` example
5920	` `` `
5921	.
5922	<p><code> `` </code></p>
5923	````````````````````````````````
5924
5925	The stripping only happens if the space is on both
5926	sides of the string:
5927
5928	```````````````````````````````` example
5929	` a`
5930	.
5931	<p><code> a</code></p>
5932	````````````````````````````````
5933
5934	Only [spaces], and not [unicode whitespace] in general, are
5935	stripped in this way:
5936
5937	```````````````````````````````` example
5938	` b `
5939	.
5940	<p><code> b </code></p>
5941	````````````````````````````````
5942
5943	No stripping occurs if the code span contains only spaces:
5944
5945	```````````````````````````````` example
5946	` `
5947	` `
5948	.
5949	<p><code> </code>
5950	<code> </code></p>
5951	````````````````````````````````
5952
5953
5954	[Line endings] are treated like spaces:
5955
5956	```````````````````````````````` example
5957	``
5958	foo
5959	bar
5960	baz
5961	``
5962	.
5963	<p><code>foo bar baz</code></p>
5964	````````````````````````````````
5965
5966	```````````````````````````````` example
5967	``
5968	foo
5969	``
5970	.
5971	<p><code>foo </code></p>
5972	````````````````````````````````
5973
5974
5975	Interior spaces are not collapsed:
5976
5977	```````````````````````````````` example
5978	`foo bar
5979	baz`
5980	.
5981	<p><code>foo bar baz</code></p>
5982	````````````````````````````````
5983
5984	Note that browsers will typically collapse consecutive spaces
5985	when rendering `<code>` elements, so it is recommended that
5986	the following CSS be used:
5987
5988	code{white-space: pre-wrap;}
5989
5990
5991	Note that backslash escapes do not work in code spans. All backslashes
5992	are treated literally:
5993
5994	```````````````````````````````` example
5995	`foo\`bar`
5996	.
5997	<p><code>foo\</code>bar`</p>
5998	````````````````````````````````
5999
6000
6001	Backslash escapes are never needed, because one can always choose a
6002	string of n backtick characters as delimiters, where the code does
6003	not contain any strings of exactly n backtick characters.
6004
6005	```````````````````````````````` example
6006	``foo`bar``
6007	.
6008	<p><code>foo`bar</code></p>
6009	````````````````````````````````
6010
6011	```````````````````````````````` example
6012	` foo `` bar `
6013	.
6014	<p><code>foo `` bar</code></p>
6015	````````````````````````````````
6016
6017
6018	Code span backticks have higher precedence than any other inline
6019	constructs except HTML tags and autolinks. Thus, for example, this is
6020	not parsed as emphasized text, since the second `*` is part of a code
6021	span:
6022
6023	```````````````````````````````` example
6024	foo``
6025	.
6026	<p>foo<code></code></p>
6027	````````````````````````````````
6028
6029
6030	And this is not parsed as a link:
6031
6032	```````````````````````````````` example
6033	[not a `link](/foo`)
6034	.
6035	<p>[not a <code>link](/foo</code>)</p>
6036	````````````````````````````````
6037
6038
6039	Code spans, HTML tags, and autolinks have the same precedence.
6040	Thus, this is code:
6041
6042	```````````````````````````````` example
6043	`<a href="`">`
6044	.
6045	<p><code><a href="</code>">`</p>
6046	````````````````````````````````
6047
6048
6049	But this is an HTML tag:
6050
6051	```````````````````````````````` example
6052	<a href="`">`
6053	.
6054	<p><a href="`">`</p>
6055	````````````````````````````````
6056
6057
6058	And this is code:
6059
6060	```````````````````````````````` example
6061	`<http://foo.bar.`baz>`
6062	.
6063	<p><code><http://foo.bar.</code>baz>`</p>
6064	````````````````````````````````
6065
6066
6067	But this is an autolink:
6068
6069	```````````````````````````````` example
6070	<http://foo.bar.`baz>`
6071	.
6072	<p><a href="http://foo.bar.%60baz">http://foo.bar.`baz</a>`</p>
6073	````````````````````````````````
6074
6075
6076	When a backtick string is not closed by a matching backtick string,
6077	we just have literal backticks:
6078
6079	```````````````````````````````` example
6080	```foo``
6081	.
6082	<p>```foo``</p>
6083	````````````````````````````````
6084
6085
6086	```````````````````````````````` example
6087	`foo
6088	.
6089	<p>`foo</p>
6090	````````````````````````````````
6091
6092	The following case also illustrates the need for opening and
6093	closing backtick strings to be equal in length:
6094
6095	```````````````````````````````` example
6096	`foo``bar``
6097	.
6098	<p>`foo<code>bar</code></p>
6099	````````````````````````````````
6100
6101
6102	## Emphasis and strong emphasis
6103
6104	John Gruber's original [Markdown syntax
6105	description](http://daringfireball.net/projects/markdown/syntax#em) says:
6106
6107	> Markdown treats asterisks (`*`) and underscores (`_`) as indicators of
6108	> emphasis. Text wrapped with one `*` or `_` will be wrapped with an HTML
6109	> `<em>` tag; double `*`'s or `_`'s will be wrapped with an HTML `<strong>`
6110	> tag.
6111
6112	This is enough for most users, but these rules leave much undecided,
6113	especially when it comes to nested emphasis. The original
6114	`Markdown.pl` test suite makes it clear that triple `***` and
6115	`___` delimiters can be used for strong emphasis, and most
6116	implementations have also allowed the following patterns:
6117
6118	``` markdown
6119	*strong emph*
6120	*strong in emph*
6121	**emph in strong**
6122	*in strong emph***
6123	in emph strong**
6124	```
6125
6126	The following patterns are less widely supported, but the intent
6127	is clear and they are useful (especially in contexts like bibliography
6128	entries):
6129
6130	``` markdown
6131	emph with emph* in it*
6132	strong with strong in it
6133	```
6134
6135	Many implementations have also restricted intraword emphasis to
6136	the `*` forms, to avoid unwanted emphasis in words containing
6137	internal underscores. (It is best practice to put these in code
6138	spans, but users often do not.)
6139
6140	``` markdown
6141	internal emphasis: foobarbaz
6142	no emphasis: foo_bar_baz
6143	```
6144
6145	The rules given below capture all of these patterns, while allowing
6146	for efficient parsing strategies that do not backtrack.
6147
6148	First, some definitions. A [delimiter run](@) is either
6149	a sequence of one or more `*` characters that is not preceded or
6150	followed by a non-backslash-escaped `*` character, or a sequence
6151	of one or more `_` characters that is not preceded or followed by
6152	a non-backslash-escaped `_` character.
6153
6154	A [left-flanking delimiter run](@) is
6155	a [delimiter run] that is (1) not followed by [Unicode whitespace],
6156	and either (2a) not followed by a [Unicode punctuation character], or
6157	(2b) followed by a [Unicode punctuation character] and
6158	preceded by [Unicode whitespace] or a [Unicode punctuation character].
6159	For purposes of this definition, the beginning and the end of
6160	the line count as Unicode whitespace.
6161
6162	A [right-flanking delimiter run](@) is
6163	a [delimiter run] that is (1) not preceded by [Unicode whitespace],
6164	and either (2a) not preceded by a [Unicode punctuation character], or
6165	(2b) preceded by a [Unicode punctuation character] and
6166	followed by [Unicode whitespace] or a [Unicode punctuation character].
6167	For purposes of this definition, the beginning and the end of
6168	the line count as Unicode whitespace.
6169
6170	Here are some examples of delimiter runs.
6171
6172	- left-flanking but not right-flanking:
6173
6174	```
6175	***abc
6176	_abc
6177	**"abc"
6178	_"abc"
6179	```
6180
6181	- right-flanking but not left-flanking:
6182
6183	```
6184	abc***
6185	abc_
6186	"abc"**
6187	"abc"_
6188	```
6189
6190	- Both left and right-flanking:
6191
6192	```
6193	abc***def
6194	"abc"_"def"
6195	```
6196
6197	- Neither left nor right-flanking:
6198
6199	```
6200	abc *** def
6201	a _ b
6202	```
6203
6204	(The idea of distinguishing left-flanking and right-flanking
6205	delimiter runs based on the character before and the character
6206	after comes from Roopesh Chander's
6207	[vfmd](http://www.vfmd.org/vfmd-spec/specification/#procedure-for-identifying-emphasis-tags).
6208	vfmd uses the terminology "emphasis indicator string" instead of "delimiter
6209	run," and its rules for distinguishing left- and right-flanking runs
6210	are a bit more complex than the ones given here.)
6211
6212	The following rules define emphasis and strong emphasis:
6213
6214	1. A single `*` character [can open emphasis](@)
6215	iff (if and only if) it is part of a [left-flanking delimiter run].
6216
6217	2. A single `_` character [can open emphasis] iff
6218	it is part of a [left-flanking delimiter run]
6219	and either (a) not part of a [right-flanking delimiter run]
6220	or (b) part of a [right-flanking delimiter run]
6221	preceded by a [Unicode punctuation character].
6222
6223	3. A single `*` character [can close emphasis](@)
6224	iff it is part of a [right-flanking delimiter run].
6225
6226	4. A single `_` character [can close emphasis] iff
6227	it is part of a [right-flanking delimiter run]
6228	and either (a) not part of a [left-flanking delimiter run]
6229	or (b) part of a [left-flanking delimiter run]
6230	followed by a [Unicode punctuation character].
6231
6232	5. A double `**` [can open strong emphasis](@)
6233	iff it is part of a [left-flanking delimiter run].
6234
6235	6. A double `__` [can open strong emphasis] iff
6236	it is part of a [left-flanking delimiter run]
6237	and either (a) not part of a [right-flanking delimiter run]
6238	or (b) part of a [right-flanking delimiter run]
6239	preceded by a [Unicode punctuation character].
6240
6241	7. A double `**` [can close strong emphasis](@)
6242	iff it is part of a [right-flanking delimiter run].
6243
6244	8. A double `__` [can close strong emphasis] iff
6245	it is part of a [right-flanking delimiter run]
6246	and either (a) not part of a [left-flanking delimiter run]
6247	or (b) part of a [left-flanking delimiter run]
6248	followed by a [Unicode punctuation character].
6249
6250	9. Emphasis begins with a delimiter that [can open emphasis] and ends
6251	with a delimiter that [can close emphasis], and that uses the same
6252	character (`_` or `*`) as the opening delimiter. The
6253	opening and closing delimiters must belong to separate
6254	[delimiter runs]. If one of the delimiters can both
6255	open and close emphasis, then the sum of the lengths of the
6256	delimiter runs containing the opening and closing delimiters
6257	must not be a multiple of 3 unless both lengths are
6258	multiples of 3.
6259
6260	10. Strong emphasis begins with a delimiter that
6261	[can open strong emphasis] and ends with a delimiter that
6262	[can close strong emphasis], and that uses the same character
6263	(`_` or `*`) as the opening delimiter. The
6264	opening and closing delimiters must belong to separate
6265	[delimiter runs]. If one of the delimiters can both open
6266	and close strong emphasis, then the sum of the lengths of
6267	the delimiter runs containing the opening and closing
6268	delimiters must not be a multiple of 3 unless both lengths
6269	are multiples of 3.
6270
6271	11. A literal `*` character cannot occur at the beginning or end of
6272	``-delimited emphasis or `*`-delimited strong emphasis, unless it
6273	is backslash-escaped.
6274
6275	12. A literal `_` character cannot occur at the beginning or end of
6276	`_`-delimited emphasis or `__`-delimited strong emphasis, unless it
6277	is backslash-escaped.
6278
6279	Where rules 1--12 above are compatible with multiple parsings,
6280	the following principles resolve ambiguity:
6281
6282	13. The number of nestings should be minimized. Thus, for example,
6283	an interpretation `<strong>...</strong>` is always preferred to
6284	`<em><em>...</em></em>`.
6285
6286	14. An interpretation `<em><strong>...</strong></em>` is always
6287	preferred to `<strong><em>...</em></strong>`.
6288
6289	15. When two potential emphasis or strong emphasis spans overlap,
6290	so that the second begins before the first ends and ends after
6291	the first ends, the first takes precedence. Thus, for example,
6292	`foo _bar baz_` is parsed as `<em>foo _bar</em> baz_` rather
6293	than `foo <em>bar baz</em>`.
6294
6295	16. When there are two potential emphasis or strong emphasis spans
6296	with the same closing delimiter, the shorter one (the one that
6297	opens later) takes precedence. Thus, for example,
6298	`foo bar baz` is parsed as `foo <strong>bar baz</strong>`
6299	rather than `<strong>foo **bar baz</strong>`.
6300
6301	17. Inline code spans, links, images, and HTML tags group more tightly
6302	than emphasis. So, when there is a choice between an interpretation
6303	that contains one of these elements and one that does not, the
6304	former always wins. Thus, for example, `[foo](bar)` is
6305	parsed as `<a href="bar">foo</a>` rather than as
6306	`<em>[foo</em>](bar)`.
6307
6308	These rules can be illustrated through a series of examples.
6309
6310	Rule 1:
6311
6312	```````````````````````````````` example
6313	foo bar
6314	.
6315	<p><em>foo bar</em></p>
6316	````````````````````````````````
6317
6318
6319	This is not emphasis, because the opening `*` is followed by
6320	whitespace, and hence not part of a [left-flanking delimiter run]:
6321
6322	```````````````````````````````` example
6323	a * foo bar*
6324	.
6325	<p>a * foo bar*</p>
6326	````````````````````````````````
6327
6328
6329	This is not emphasis, because the opening `*` is preceded
6330	by an alphanumeric and followed by punctuation, and hence
6331	not part of a [left-flanking delimiter run]:
6332
6333	```````````````````````````````` example
6334	a"foo"
6335	.
6336	<p>a"foo"</p>
6337	````````````````````````````````
6338
6339
6340	Unicode nonbreaking spaces count as whitespace, too:
6341
6342	```````````````````````````````` example
6343	* a *
6344	.
6345	<p>* a *</p>
6346	````````````````````````````````
6347
6348
6349	Intraword emphasis with `*` is permitted:
6350
6351	```````````````````````````````` example
6352	foobar
6353	.
6354	<p>foo<em>bar</em></p>
6355	````````````````````````````````
6356
6357
6358	```````````````````````````````` example
6359	5678
6360	.
6361	<p>5<em>6</em>78</p>
6362	````````````````````````````````
6363
6364
6365	Rule 2:
6366
6367	```````````````````````````````` example
6368	_foo bar_
6369	.
6370	<p><em>foo bar</em></p>
6371	````````````````````````````````
6372
6373
6374	This is not emphasis, because the opening `_` is followed by
6375	whitespace:
6376
6377	```````````````````````````````` example
6378	_ foo bar_
6379	.
6380	<p>_ foo bar_</p>
6381	````````````````````````````````
6382
6383
6384	This is not emphasis, because the opening `_` is preceded
6385	by an alphanumeric and followed by punctuation:
6386
6387	```````````````````````````````` example
6388	a_"foo"_
6389	.
6390	<p>a_"foo"_</p>
6391	````````````````````````````````
6392
6393
6394	Emphasis with `_` is not allowed inside words:
6395
6396	```````````````````````````````` example
6397	foo_bar_
6398	.
6399	<p>foo_bar_</p>
6400	````````````````````````````````
6401
6402
6403	```````````````````````````````` example
6404	5_6_78
6405	.
6406	<p>5_6_78</p>
6407	````````````````````````````````
6408
6409
6410	```````````````````````````````` example
6411	пристаням_стремятся_
6412	.
6413	<p>пристаням_стремятся_</p>
6414	````````````````````````````````
6415
6416
6417	Here `_` does not generate emphasis, because the first delimiter run
6418	is right-flanking and the second left-flanking:
6419
6420	```````````````````````````````` example
6421	aa_"bb"_cc
6422	.
6423	<p>aa_"bb"_cc</p>
6424	````````````````````````````````
6425
6426
6427	This is emphasis, even though the opening delimiter is
6428	both left- and right-flanking, because it is preceded by
6429	punctuation:
6430
6431	```````````````````````````````` example
6432	foo-_(bar)_
6433	.
6434	<p>foo-<em>(bar)</em></p>
6435	````````````````````````````````
6436
6437
6438	Rule 3:
6439
6440	This is not emphasis, because the closing delimiter does
6441	not match the opening delimiter:
6442
6443	```````````````````````````````` example
6444	_foo*
6445	.
6446	<p>_foo*</p>
6447	````````````````````````````````
6448
6449
6450	This is not emphasis, because the closing `*` is preceded by
6451	whitespace:
6452
6453	```````````````````````````````` example
6454	foo bar
6455	.
6456	<p>foo bar </p>
6457	````````````````````````````````
6458
6459
6460	A line ending also counts as whitespace:
6461
6462	```````````````````````````````` example
6463	*foo bar
6464	*
6465	.
6466	<p>*foo bar
6467	*</p>
6468	````````````````````````````````
6469
6470
6471	This is not emphasis, because the second `*` is
6472	preceded by punctuation and followed by an alphanumeric
6473	(hence it is not part of a [right-flanking delimiter run]:
6474
6475	```````````````````````````````` example
6476	(foo)
6477	.
6478	<p>(foo)</p>
6479	````````````````````````````````
6480
6481
6482	The point of this restriction is more easily appreciated
6483	with this example:
6484
6485	```````````````````````````````` example
6486	(foo)
6487	.
6488	<p><em>(<em>foo</em>)</em></p>
6489	````````````````````````````````
6490
6491
6492	Intraword emphasis with `*` is allowed:
6493
6494	```````````````````````````````` example
6495	foobar
6496	.
6497	<p><em>foo</em>bar</p>
6498	````````````````````````````````
6499
6500
6501
6502	Rule 4:
6503
6504	This is not emphasis, because the closing `_` is preceded by
6505	whitespace:
6506
6507	```````````````````````````````` example
6508	_foo bar _
6509	.
6510	<p>_foo bar _</p>
6511	````````````````````````````````
6512
6513
6514	This is not emphasis, because the second `_` is
6515	preceded by punctuation and followed by an alphanumeric:
6516
6517	```````````````````````````````` example
6518	_(_foo)
6519	.
6520	<p>_(_foo)</p>
6521	````````````````````````````````
6522
6523
6524	This is emphasis within emphasis:
6525
6526	```````````````````````````````` example
6527	_(_foo_)_
6528	.
6529	<p><em>(<em>foo</em>)</em></p>
6530	````````````````````````````````
6531
6532
6533	Intraword emphasis is disallowed for `_`:
6534
6535	```````````````````````````````` example
6536	_foo_bar
6537	.
6538	<p>_foo_bar</p>
6539	````````````````````````````````
6540
6541
6542	```````````````````````````````` example
6543	_пристаням_стремятся
6544	.
6545	<p>_пристаням_стремятся</p>
6546	````````````````````````````````
6547
6548
6549	```````````````````````````````` example
6550	_foo_bar_baz_
6551	.
6552	<p><em>foo_bar_baz</em></p>
6553	````````````````````````````````
6554
6555
6556	This is emphasis, even though the closing delimiter is
6557	both left- and right-flanking, because it is followed by
6558	punctuation:
6559
6560	```````````````````````````````` example
6561	_(bar)_.
6562	.
6563	<p><em>(bar)</em>.</p>
6564	````````````````````````````````
6565
6566
6567	Rule 5:
6568
6569	```````````````````````````````` example
6570	foo bar
6571	.
6572	<p><strong>foo bar</strong></p>
6573	````````````````````````````````
6574
6575
6576	This is not strong emphasis, because the opening delimiter is
6577	followed by whitespace:
6578
6579	```````````````````````````````` example
6580	foo bar
6581	.
6582	<p> foo bar</p>
6583	````````````````````````````````
6584
6585
6586	This is not strong emphasis, because the opening `**` is preceded
6587	by an alphanumeric and followed by punctuation, and hence
6588	not part of a [left-flanking delimiter run]:
6589
6590	```````````````````````````````` example
6591	a"foo"
6592	.
6593	<p>a"foo"</p>
6594	````````````````````````````````
6595
6596
6597	Intraword strong emphasis with `**` is permitted:
6598
6599	```````````````````````````````` example
6600	foobar
6601	.
6602	<p>foo<strong>bar</strong></p>
6603	````````````````````````````````
6604
6605
6606	Rule 6:
6607
6608	```````````````````````````````` example
6609	__foo bar__
6610	.
6611	<p><strong>foo bar</strong></p>
6612	````````````````````````````````
6613
6614
6615	This is not strong emphasis, because the opening delimiter is
6616	followed by whitespace:
6617
6618	```````````````````````````````` example
6619	__ foo bar__
6620	.
6621	<p>__ foo bar__</p>
6622	````````````````````````````````
6623
6624
6625	A line ending counts as whitespace:
6626	```````````````````````````````` example
6627	__
6628	foo bar__
6629	.
6630	<p>__
6631	foo bar__</p>
6632	````````````````````````````````
6633
6634
6635	This is not strong emphasis, because the opening `__` is preceded
6636	by an alphanumeric and followed by punctuation:
6637
6638	```````````````````````````````` example
6639	a__"foo"__
6640	.
6641	<p>a__"foo"__</p>
6642	````````````````````````````````
6643
6644
6645	Intraword strong emphasis is forbidden with `__`:
6646
6647	```````````````````````````````` example
6648	foo__bar__
6649	.
6650	<p>foo__bar__</p>
6651	````````````````````````````````
6652
6653
6654	```````````````````````````````` example
6655	5__6__78
6656	.
6657	<p>5__6__78</p>
6658	````````````````````````````````
6659
6660
6661	```````````````````````````````` example
6662	пристаням__стремятся__
6663	.
6664	<p>пристаням__стремятся__</p>
6665	````````````````````````````````
6666
6667
6668	```````````````````````````````` example
6669	__foo, __bar__, baz__
6670	.
6671	<p><strong>foo, <strong>bar</strong>, baz</strong></p>
6672	````````````````````````````````
6673
6674
6675	This is strong emphasis, even though the opening delimiter is
6676	both left- and right-flanking, because it is preceded by
6677	punctuation:
6678
6679	```````````````````````````````` example
6680	foo-__(bar)__
6681	.
6682	<p>foo-<strong>(bar)</strong></p>
6683	````````````````````````````````
6684
6685
6686
6687	Rule 7:
6688
6689	This is not strong emphasis, because the closing delimiter is preceded
6690	by whitespace:
6691
6692	```````````````````````````````` example
6693	foo bar
6694	.
6695	<p>foo bar </p>
6696	````````````````````````````````
6697
6698
6699	(Nor can it be interpreted as an emphasized `foo bar `, because of
6700	Rule 11.)
6701
6702	This is not strong emphasis, because the second `**` is
6703	preceded by punctuation and followed by an alphanumeric:
6704
6705	```````````````````````````````` example
6706	(foo)
6707	.
6708	<p>(foo)</p>
6709	````````````````````````````````
6710
6711
6712	The point of this restriction is more easily appreciated
6713	with these examples:
6714
6715	```````````````````````````````` example
6716	(foo)
6717	.
6718	<p><em>(<strong>foo</strong>)</em></p>
6719	````````````````````````````````
6720
6721
6722	```````````````````````````````` example
6723	*Gomphocarpus (Gomphocarpus physocarpus*, syn.
6724	Asclepias physocarpa)**
6725	.
6726	<p><strong>Gomphocarpus (<em>Gomphocarpus physocarpus</em>, syn.
6727	<em>Asclepias physocarpa</em>)</strong></p>
6728	````````````````````````````````
6729
6730
6731	```````````````````````````````` example
6732	*foo "bar" foo*
6733	.
6734	<p><strong>foo "<em>bar</em>" foo</strong></p>
6735	````````````````````````````````
6736
6737
6738	Intraword emphasis:
6739
6740	```````````````````````````````` example
6741	foobar
6742	.
6743	<p><strong>foo</strong>bar</p>
6744	````````````````````````````````
6745
6746
6747	Rule 8:
6748
6749	This is not strong emphasis, because the closing delimiter is
6750	preceded by whitespace:
6751
6752	```````````````````````````````` example
6753	__foo bar __
6754	.
6755	<p>__foo bar __</p>
6756	````````````````````````````````
6757
6758
6759	This is not strong emphasis, because the second `__` is
6760	preceded by punctuation and followed by an alphanumeric:
6761
6762	```````````````````````````````` example
6763	__(__foo)
6764	.
6765	<p>__(__foo)</p>
6766	````````````````````````````````
6767
6768
6769	The point of this restriction is more easily appreciated
6770	with this example:
6771
6772	```````````````````````````````` example
6773	_(__foo__)_
6774	.
6775	<p><em>(<strong>foo</strong>)</em></p>
6776	````````````````````````````````
6777
6778
6779	Intraword strong emphasis is forbidden with `__`:
6780
6781	```````````````````````````````` example
6782	__foo__bar
6783	.
6784	<p>__foo__bar</p>
6785	````````````````````````````````
6786
6787
6788	```````````````````````````````` example
6789	__пристаням__стремятся
6790	.
6791	<p>__пристаням__стремятся</p>
6792	````````````````````````````````
6793
6794
6795	```````````````````````````````` example
6796	__foo__bar__baz__
6797	.
6798	<p><strong>foo__bar__baz</strong></p>
6799	````````````````````````````````
6800
6801
6802	This is strong emphasis, even though the closing delimiter is
6803	both left- and right-flanking, because it is followed by
6804	punctuation:
6805
6806	```````````````````````````````` example
6807	__(bar)__.
6808	.
6809	<p><strong>(bar)</strong>.</p>
6810	````````````````````````````````
6811
6812
6813	Rule 9:
6814
6815	Any nonempty sequence of inline elements can be the contents of an
6816	emphasized span.
6817
6818	```````````````````````````````` example
6819	foo [bar](/url)
6820	.
6821	<p><em>foo <a href="/url">bar</a></em></p>
6822	````````````````````````````````
6823
6824
6825	```````````````````````````````` example
6826	*foo
6827	bar*
6828	.
6829	<p><em>foo
6830	bar</em></p>
6831	````````````````````````````````
6832
6833
6834	In particular, emphasis and strong emphasis can be nested
6835	inside emphasis:
6836
6837	```````````````````````````````` example
6838	_foo __bar__ baz_
6839	.
6840	<p><em>foo <strong>bar</strong> baz</em></p>
6841	````````````````````````````````
6842
6843
6844	```````````````````````````````` example
6845	_foo _bar_ baz_
6846	.
6847	<p><em>foo <em>bar</em> baz</em></p>
6848	````````````````````````````````
6849
6850
6851	```````````````````````````````` example
6852	__foo_ bar_
6853	.
6854	<p><em><em>foo</em> bar</em></p>
6855	````````````````````````````````
6856
6857
6858	```````````````````````````````` example
6859	foo bar**
6860	.
6861	<p><em>foo <em>bar</em></em></p>
6862	````````````````````````````````
6863
6864
6865	```````````````````````````````` example
6866	foo bar* baz*
6867	.
6868	<p><em>foo <strong>bar</strong> baz</em></p>
6869	````````````````````````````````
6870
6871	```````````````````````````````` example
6872	foobarbaz
6873	.
6874	<p><em>foo<strong>bar</strong>baz</em></p>
6875	````````````````````````````````
6876
6877	Note that in the preceding case, the interpretation
6878
6879	``` markdown
6880	<p><em>foo</em><em>bar<em></em>baz</em></p>
6881	```
6882
6883
6884	is precluded by the condition that a delimiter that
6885	can both open and close (like the `*` after `foo`)
6886	cannot form emphasis if the sum of the lengths of
6887	the delimiter runs containing the opening and
6888	closing delimiters is a multiple of 3 unless
6889	both lengths are multiples of 3.
6890
6891
6892	For the same reason, we don't get two consecutive
6893	emphasis sections in this example:
6894
6895	```````````````````````````````` example
6896	foobar
6897	.
6898	<p><em>foo**bar</em></p>
6899	````````````````````````````````
6900
6901
6902	The same condition ensures that the following
6903	cases are all strong emphasis nested inside
6904	emphasis, even when the interior whitespace is
6905	omitted:
6906
6907
6908	```````````````````````````````` example
6909	*foo bar*
6910	.
6911	<p><em><strong>foo</strong> bar</em></p>
6912	````````````````````````````````
6913
6914
6915	```````````````````````````````` example
6916	foo bar**
6917	.
6918	<p><em>foo <strong>bar</strong></em></p>
6919	````````````````````````````````
6920
6921
6922	```````````````````````````````` example
6923	foobar**
6924	.
6925	<p><em>foo<strong>bar</strong></em></p>
6926	````````````````````````````````
6927
6928
6929	When the lengths of the interior closing and opening
6930	delimiter runs are both multiples of 3, though,
6931	they can match to create emphasis:
6932
6933	```````````````````````````````` example
6934	foo*bar*baz
6935	.
6936	<p>foo<em><strong>bar</strong></em>baz</p>
6937	````````````````````````````````
6938
6939	```````````````````````````````` example
6940	foo****bar*******baz
6941	.
6942	<p>foo<strong><strong><strong>bar</strong></strong></strong>***baz</p>
6943	````````````````````````````````
6944
6945
6946	Indefinite levels of nesting are possible:
6947
6948	```````````````````````````````` example
6949	foo bar baz* bim** bop*
6950	.
6951	<p><em>foo <strong>bar <em>baz</em> bim</strong> bop</em></p>
6952	````````````````````````````````
6953
6954
6955	```````````````````````````````` example
6956	foo [bar](/url)
6957	.
6958	<p><em>foo <a href="/url"><em>bar</em></a></em></p>
6959	````````````````````````````````
6960
6961
6962	There can be no empty emphasis or strong emphasis:
6963
6964	```````````````````````````````` example
6965	** is not an empty emphasis
6966	.
6967	<p>** is not an empty emphasis</p>
6968	````````````````````````````````
6969
6970
6971	```````````````````````````````` example
6972	**** is not an empty strong emphasis
6973	.
6974	<p>**** is not an empty strong emphasis</p>
6975	````````````````````````````````
6976
6977
6978
6979	Rule 10:
6980
6981	Any nonempty sequence of inline elements can be the contents of an
6982	strongly emphasized span.
6983
6984	```````````````````````````````` example
6985	foo [bar](/url)
6986	.
6987	<p><strong>foo <a href="/url">bar</a></strong></p>
6988	````````````````````````````````
6989
6990
6991	```````````````````````````````` example
6992	**foo
6993	bar**
6994	.
6995	<p><strong>foo
6996	bar</strong></p>
6997	````````````````````````````````
6998
6999
7000	In particular, emphasis and strong emphasis can be nested
7001	inside strong emphasis:
7002
7003	```````````````````````````````` example
7004	__foo _bar_ baz__
7005	.
7006	<p><strong>foo <em>bar</em> baz</strong></p>
7007	````````````````````````````````
7008
7009
7010	```````````````````````````````` example
7011	__foo __bar__ baz__
7012	.
7013	<p><strong>foo <strong>bar</strong> baz</strong></p>
7014	````````````````````````````````
7015
7016
7017	```````````````````````````````` example
7018	____foo__ bar__
7019	.
7020	<p><strong><strong>foo</strong> bar</strong></p>
7021	````````````````````````````````
7022
7023
7024	```````````````````````````````` example
7025	foo bar****
7026	.
7027	<p><strong>foo <strong>bar</strong></strong></p>
7028	````````````````````````````````
7029
7030
7031	```````````````````````````````` example
7032	*foo bar* baz**
7033	.
7034	<p><strong>foo <em>bar</em> baz</strong></p>
7035	````````````````````````````````
7036
7037
7038	```````````````````````````````` example
7039	*foobarbaz*
7040	.
7041	<p><strong>foo<em>bar</em>baz</strong></p>
7042	````````````````````````````````
7043
7044
7045	```````````````````````````````` example
7046	**foo bar**
7047	.
7048	<p><strong><em>foo</em> bar</strong></p>
7049	````````````````````````````````
7050
7051
7052	```````````````````````````````` example
7053	*foo bar***
7054	.
7055	<p><strong>foo <em>bar</em></strong></p>
7056	````````````````````````````````
7057
7058
7059	Indefinite levels of nesting are possible:
7060
7061	```````````````````````````````` example
7062	*foo bar baz
7063	bim* bop**
7064	.
7065	<p><strong>foo <em>bar <strong>baz</strong>
7066	bim</em> bop</strong></p>
7067	````````````````````````````````
7068
7069
7070	```````````````````````````````` example
7071	*foo [bar](/url)*
7072	.
7073	<p><strong>foo <a href="/url"><em>bar</em></a></strong></p>
7074	````````````````````````````````
7075
7076
7077	There can be no empty emphasis or strong emphasis:
7078
7079	```````````````````````````````` example
7080	__ is not an empty emphasis
7081	.
7082	<p>__ is not an empty emphasis</p>
7083	````````````````````````````````
7084
7085
7086	```````````````````````````````` example
7087	____ is not an empty strong emphasis
7088	.
7089	<p>____ is not an empty strong emphasis</p>
7090	````````````````````````````````
7091
7092
7093
7094	Rule 11:
7095
7096	```````````````````````````````` example
7097	foo ***
7098	.
7099	<p>foo ***</p>
7100	````````````````````````````````
7101
7102
7103	```````````````````````````````` example
7104	foo \*
7105	.
7106	<p>foo <em>*</em></p>
7107	````````````````````````````````
7108
7109
7110	```````````````````````````````` example
7111	foo _
7112	.
7113	<p>foo <em>_</em></p>
7114	````````````````````````````````
7115
7116
7117	```````````````````````````````` example
7118	foo *****
7119	.
7120	<p>foo *****</p>
7121	````````````````````````````````
7122
7123
7124	```````````````````````````````` example
7125	foo \*
7126	.
7127	<p>foo <strong>*</strong></p>
7128	````````````````````````````````
7129
7130
7131	```````````````````````````````` example
7132	foo _
7133	.
7134	<p>foo <strong>_</strong></p>
7135	````````````````````````````````
7136
7137
7138	Note that when delimiters do not match evenly, Rule 11 determines
7139	that the excess literal `*` characters will appear outside of the
7140	emphasis, rather than inside it:
7141
7142	```````````````````````````````` example
7143	*foo
7144	.
7145	<p>*<em>foo</em></p>
7146	````````````````````````````````
7147
7148
7149	```````````````````````````````` example
7150	foo*
7151	.
7152	<p><em>foo</em>*</p>
7153	````````````````````````````````
7154
7155
7156	```````````````````````````````` example
7157	*foo
7158	.
7159	<p>*<strong>foo</strong></p>
7160	````````````````````````````````
7161
7162
7163	```````````````````````````````` example
7164	***foo
7165	.
7166	<p>***<em>foo</em></p>
7167	````````````````````````````````
7168
7169
7170	```````````````````````````````` example
7171	foo*
7172	.
7173	<p><strong>foo</strong>*</p>
7174	````````````````````````````````
7175
7176
7177	```````````````````````````````` example
7178	foo***
7179	.
7180	<p><em>foo</em>***</p>
7181	````````````````````````````````
7182
7183
7184
7185	Rule 12:
7186
7187	```````````````````````````````` example
7188	foo ___
7189	.
7190	<p>foo ___</p>
7191	````````````````````````````````
7192
7193
7194	```````````````````````````````` example
7195	foo _\__
7196	.
7197	<p>foo <em>_</em></p>
7198	````````````````````````````````
7199
7200
7201	```````````````````````````````` example
7202	foo _*_
7203	.
7204	<p>foo <em>*</em></p>
7205	````````````````````````````````
7206
7207
7208	```````````````````````````````` example
7209	foo _____
7210	.
7211	<p>foo _____</p>
7212	````````````````````````````````
7213
7214
7215	```````````````````````````````` example
7216	foo __\___
7217	.
7218	<p>foo <strong>_</strong></p>
7219	````````````````````````````````
7220
7221
7222	```````````````````````````````` example
7223	foo __*__
7224	.
7225	<p>foo <strong>*</strong></p>
7226	````````````````````````````````
7227
7228
7229	```````````````````````````````` example
7230	__foo_
7231	.
7232	<p>_<em>foo</em></p>
7233	````````````````````````````````
7234
7235
7236	Note that when delimiters do not match evenly, Rule 12 determines
7237	that the excess literal `_` characters will appear outside of the
7238	emphasis, rather than inside it:
7239
7240	```````````````````````````````` example
7241	_foo__
7242	.
7243	<p><em>foo</em>_</p>
7244	````````````````````````````````
7245
7246
7247	```````````````````````````````` example
7248	___foo__
7249	.
7250	<p>_<strong>foo</strong></p>
7251	````````````````````````````````
7252
7253
7254	```````````````````````````````` example
7255	____foo_
7256	.
7257	<p>___<em>foo</em></p>
7258	````````````````````````````````
7259
7260
7261	```````````````````````````````` example
7262	__foo___
7263	.
7264	<p><strong>foo</strong>_</p>
7265	````````````````````````````````
7266
7267
7268	```````````````````````````````` example
7269	_foo____
7270	.
7271	<p><em>foo</em>___</p>
7272	````````````````````````````````
7273
7274
7275	Rule 13 implies that if you want emphasis nested directly inside
7276	emphasis, you must use different delimiters:
7277
7278	```````````````````````````````` example
7279	foo
7280	.
7281	<p><strong>foo</strong></p>
7282	````````````````````````````````
7283
7284
7285	```````````````````````````````` example
7286	_foo_
7287	.
7288	<p><em><em>foo</em></em></p>
7289	````````````````````````````````
7290
7291
7292	```````````````````````````````` example
7293	__foo__
7294	.
7295	<p><strong>foo</strong></p>
7296	````````````````````````````````
7297
7298
7299	```````````````````````````````` example
7300	_foo_
7301	.
7302	<p><em><em>foo</em></em></p>
7303	````````````````````````````````
7304
7305
7306	However, strong emphasis within strong emphasis is possible without
7307	switching delimiters:
7308
7309	```````````````````````````````` example
7310	**foo**
7311	.
7312	<p><strong><strong>foo</strong></strong></p>
7313	````````````````````````````````
7314
7315
7316	```````````````````````````````` example
7317	____foo____
7318	.
7319	<p><strong><strong>foo</strong></strong></p>
7320	````````````````````````````````
7321
7322
7323
7324	Rule 13 can be applied to arbitrarily long sequences of
7325	delimiters:
7326
7327	```````````````````````````````` example
7328	****foo****
7329	.
7330	<p><strong><strong><strong>foo</strong></strong></strong></p>
7331	````````````````````````````````
7332
7333
7334	Rule 14:
7335
7336	```````````````````````````````` example
7337	*foo*
7338	.
7339	<p><em><strong>foo</strong></em></p>
7340	````````````````````````````````
7341
7342
7343	```````````````````````````````` example
7344	_____foo_____
7345	.
7346	<p><em><strong><strong>foo</strong></strong></em></p>
7347	````````````````````````````````
7348
7349
7350	Rule 15:
7351
7352	```````````````````````````````` example
7353	foo _bar baz_
7354	.
7355	<p><em>foo _bar</em> baz_</p>
7356	````````````````````````````````
7357
7358
7359	```````````````````````````````` example
7360	foo __bar baz bim__ bam*
7361	.
7362	<p><em>foo <strong>bar *baz bim</strong> bam</em></p>
7363	````````````````````````````````
7364
7365
7366	Rule 16:
7367
7368	```````````````````````````````` example
7369	foo bar baz**
7370	.
7371	<p>**foo <strong>bar baz</strong></p>
7372	````````````````````````````````
7373
7374
7375	```````````````````````````````` example
7376	foo bar baz*
7377	.
7378	<p>*foo <em>bar baz</em></p>
7379	````````````````````````````````
7380
7381
7382	Rule 17:
7383
7384	```````````````````````````````` example
7385	[bar](/url)
7386	.
7387	<p><a href="/url">bar</a></p>
7388	````````````````````````````````
7389
7390
7391	```````````````````````````````` example
7392	_foo [bar_](/url)
7393	.
7394	<p>_foo <a href="/url">bar_</a></p>
7395	````````````````````````````````
7396
7397
7398	```````````````````````````````` example
7399	<img src="foo" title=""/>
7400	.
7401	<p><img src="foo" title=""/></p>
7402	````````````````````````````````
7403
7404
7405	```````````````````````````````` example
7406	<a href="">
7407	.
7408	<p><a href=""></p>
7409	````````````````````````````````
7410
7411
7412	```````````````````````````````` example
7413	__<a href="__">
7414	.
7415	<p>__<a href="__"></p>
7416	````````````````````````````````
7417
7418
7419	```````````````````````````````` example
7420	a ``*
7421	.
7422	<p><em>a <code>*</code></em></p>
7423	````````````````````````````````
7424
7425
7426	```````````````````````````````` example
7427	_a `_`_
7428	.
7429	<p><em>a <code>_</code></em></p>
7430	````````````````````````````````
7431
7432
7433	```````````````````````````````` example
7434	a<http://foo.bar/?q=>
7435	.
7436	<p>a<a href="http://foo.bar/?q=">http://foo.bar/?q=**</a></p>
7437	````````````````````````````````
7438
7439
7440	```````````````````````````````` example
7441	__a<http://foo.bar/?q=__>
7442	.
7443	<p>__a<a href="http://foo.bar/?q=__">http://foo.bar/?q=__</a></p>
7444	````````````````````````````````
7445
7446
7447
7448	## Links
7449
7450	A link contains [link text] (the visible text), a [link destination]
7451	(the URI that is the link destination), and optionally a [link title].
7452	There are two basic kinds of links in Markdown. In [inline links] the
7453	destination and title are given immediately after the link text. In
7454	[reference links] the destination and title are defined elsewhere in
7455	the document.
7456
7457	A [link text](@) consists of a sequence of zero or more
7458	inline elements enclosed by square brackets (`[` and `]`). The
7459	following rules apply:
7460
7461	- Links may not contain other links, at any level of nesting. If
7462	multiple otherwise valid link definitions appear nested inside each
7463	other, the inner-most definition is used.
7464
7465	- Brackets are allowed in the [link text] only if (a) they
7466	are backslash-escaped or (b) they appear as a matched pair of brackets,
7467	with an open bracket `[`, a sequence of zero or more inlines, and
7468	a close bracket `]`.
7469
7470	- Backtick [code spans], [autolinks], and raw [HTML tags] bind more tightly
7471	than the brackets in link text. Thus, for example,
7472	`` [foo`]` `` could not be a link text, since the second `]`
7473	is part of a code span.
7474
7475	- The brackets in link text bind more tightly than markers for
7476	[emphasis and strong emphasis]. Thus, for example, `[foo](url)` is a link.
7477
7478	A [link destination](@) consists of either
7479
7480	- a sequence of zero or more characters between an opening `<` and a
7481	closing `>` that contains no line endings or unescaped
7482	`<` or `>` characters, or
7483
7484	- a nonempty sequence of characters that does not start with `<`,
7485	does not include [ASCII control characters][ASCII control character]
7486	or [space] character, and includes parentheses only if (a) they are
7487	backslash-escaped or (b) they are part of a balanced pair of
7488	unescaped parentheses.
7489	(Implementations may impose limits on parentheses nesting to
7490	avoid performance issues, but at least three levels of nesting
7491	should be supported.)
7492
7493	A [link title](@) consists of either
7494
7495	- a sequence of zero or more characters between straight double-quote
7496	characters (`"`), including a `"` character only if it is
7497	backslash-escaped, or
7498
7499	- a sequence of zero or more characters between straight single-quote
7500	characters (`'`), including a `'` character only if it is
7501	backslash-escaped, or
7502
7503	- a sequence of zero or more characters between matching parentheses
7504	(`(...)`), including a `(` or `)` character only if it is
7505	backslash-escaped.
7506
7507	Although [link titles] may span multiple lines, they may not contain
7508	a [blank line].
7509
7510	An [inline link](@) consists of a [link text] followed immediately
7511	by a left parenthesis `(`, an optional [link destination], an optional
7512	[link title], and a right parenthesis `)`.
7513	These four components may be separated by spaces, tabs, and up to one line
7514	ending.
7515	If both [link destination] and [link title] are present, they must be
7516	separated by spaces, tabs, and up to one line ending.
7517
7518	The link's text consists of the inlines contained
7519	in the [link text] (excluding the enclosing square brackets).
7520	The link's URI consists of the link destination, excluding enclosing
7521	`<...>` if present, with backslash-escapes in effect as described
7522	above. The link's title consists of the link title, excluding its
7523	enclosing delimiters, with backslash-escapes in effect as described
7524	above.
7525
7526	Here is a simple inline link:
7527
7528	```````````````````````````````` example
7529	[link](/uri "title")
7530	.
7531	<p><a href="/uri" title="title">link</a></p>
7532	````````````````````````````````
7533
7534
7535	The title, the link text and even
7536	the destination may be omitted:
7537
7538	```````````````````````````````` example
7539	[link](/uri)
7540	.
7541	<p><a href="/uri">link</a></p>
7542	````````````````````````````````
7543
7544	```````````````````````````````` example
7545	[](./target.md)
7546	.
7547	<p><a href="./target.md"></a></p>
7548	````````````````````````````````
7549
7550
7551	```````````````````````````````` example
7552	[link]()
7553	.
7554	<p><a href="">link</a></p>
7555	````````````````````````````````
7556
7557
7558	```````````````````````````````` example
7559	[link](<>)
7560	.
7561	<p><a href="">link</a></p>
7562	````````````````````````````````
7563
7564
7565	```````````````````````````````` example
7566	[]()
7567	.
7568	<p><a href=""></a></p>
7569	````````````````````````````````
7570
7571	The destination can only contain spaces if it is
7572	enclosed in pointy brackets:
7573
7574	```````````````````````````````` example
7575	[link](/my uri)
7576	.
7577	<p>[link](/my uri)</p>
7578	````````````````````````````````
7579
7580	```````````````````````````````` example
7581	[link](</my uri>)
7582	.
7583	<p><a href="/my%20uri">link</a></p>
7584	````````````````````````````````
7585
7586	The destination cannot contain line endings,
7587	even if enclosed in pointy brackets:
7588
7589	```````````````````````````````` example
7590	[link](foo
7591	bar)
7592	.
7593	<p>[link](foo
7594	bar)</p>
7595	````````````````````````````````
7596
7597	```````````````````````````````` example
7598	[link](<foo
7599	bar>)
7600	.
7601	<p>[link](<foo
7602	bar>)</p>
7603	````````````````````````````````
7604
7605	The destination can contain `)` if it is enclosed
7606	in pointy brackets:
7607
7608	```````````````````````````````` example
7609	[a](<b)c>)
7610	.
7611	<p><a href="b)c">a</a></p>
7612	````````````````````````````````
7613
7614	Pointy brackets that enclose links must be unescaped:
7615
7616	```````````````````````````````` example
7617	[link](<foo\>)
7618	.
7619	<p>[link](<foo>)</p>
7620	````````````````````````````````
7621
7622	These are not links, because the opening pointy bracket
7623	is not matched properly:
7624
7625	```````````````````````````````` example
7626	[a](<b)c
7627	[a](<b)c>
7628	[a](<b>c)
7629	.
7630	<p>[a](<b)c
7631	[a](<b)c>
7632	[a](<b>c)</p>
7633	````````````````````````````````
7634
7635	Parentheses inside the link destination may be escaped:
7636
7637	```````````````````````````````` example
7638	[link]($foo$)
7639	.
7640	<p><a href="(foo)">link</a></p>
7641	````````````````````````````````
7642
7643	Any number of parentheses are allowed without escaping, as long as they are
7644	balanced:
7645
7646	```````````````````````````````` example
7647	[link](foo(and(bar)))
7648	.
7649	<p><a href="foo(and(bar))">link</a></p>
7650	````````````````````````````````
7651
7652	However, if you have unbalanced parentheses, you need to escape or use the
7653	`<...>` form:
7654
7655	```````````````````````````````` example
7656	[link](foo(and(bar))
7657	.
7658	<p>[link](foo(and(bar))</p>
7659	````````````````````````````````
7660
7661
7662	```````````````````````````````` example
7663	[link](foo$and\(bar$)
7664	.
7665	<p><a href="foo(and(bar)">link</a></p>
7666	````````````````````````````````
7667
7668
7669	```````````````````````````````` example
7670	[link](<foo(and(bar)>)
7671	.
7672	<p><a href="foo(and(bar)">link</a></p>
7673	````````````````````````````````
7674
7675
7676	Parentheses and other symbols can also be escaped, as usual
7677	in Markdown:
7678
7679	```````````````````````````````` example
7680	[link](foo\)\:)
7681	.
7682	<p><a href="foo):">link</a></p>
7683	````````````````````````````````
7684
7685
7686	A link can contain fragment identifiers and queries:
7687
7688	```````````````````````````````` example
7689	[link](#fragment)
7690
7691	[link](http://example.com#fragment)
7692
7693	[link](http://example.com?foo=3#frag)
7694	.
7695	<p><a href="#fragment">link</a></p>
7696	<p><a href="http://example.com#fragment">link</a></p>
7697	<p><a href="http://example.com?foo=3#frag">link</a></p>
7698	````````````````````````````````
7699
7700
7701	Note that a backslash before a non-escapable character is
7702	just a backslash:
7703
7704	```````````````````````````````` example
7705	[link](foo\bar)
7706	.
7707	<p><a href="foo%5Cbar">link</a></p>
7708	````````````````````````````````
7709
7710
7711	URL-escaping should be left alone inside the destination, as all
7712	URL-escaped characters are also valid URL characters. Entity and
7713	numerical character references in the destination will be parsed
7714	into the corresponding Unicode code points, as usual. These may
7715	be optionally URL-escaped when written as HTML, but this spec
7716	does not enforce any particular policy for rendering URLs in
7717	HTML or other formats. Renderers may make different decisions
7718	about how to escape or normalize URLs in the output.
7719
7720	```````````````````````````````` example
7721	[link](foo%20bä)
7722	.
7723	<p><a href="foo%20b%C3%A4">link</a></p>
7724	````````````````````````````````
7725
7726
7727	Note that, because titles can often be parsed as destinations,
7728	if you try to omit the destination and keep the title, you'll
7729	get unexpected results:
7730
7731	```````````````````````````````` example
7732	[link]("title")
7733	.
7734	<p><a href="%22title%22">link</a></p>
7735	````````````````````````````````
7736
7737
7738	Titles may be in single quotes, double quotes, or parentheses:
7739
7740	```````````````````````````````` example
7741	[link](/url "title")
7742	[link](/url 'title')
7743	[link](/url (title))
7744	.
7745	<p><a href="/url" title="title">link</a>
7746	<a href="/url" title="title">link</a>
7747	<a href="/url" title="title">link</a></p>
7748	````````````````````````````````
7749
7750
7751	Backslash escapes and entity and numeric character references
7752	may be used in titles:
7753
7754	```````````````````````````````` example
7755	[link](/url "title \""")
7756	.
7757	<p><a href="/url" title="title """>link</a></p>
7758	````````````````````````````````
7759
7760
7761	Titles must be separated from the link using spaces, tabs, and up to one line
7762	ending.
7763	Other [Unicode whitespace] like non-breaking space doesn't work.
7764
7765	```````````````````````````````` example
7766	[link](/url "title")
7767	.
7768	<p><a href="/url%C2%A0%22title%22">link</a></p>
7769	````````````````````````````````
7770
7771
7772	Nested balanced quotes are not allowed without escaping:
7773
7774	```````````````````````````````` example
7775	[link](/url "title "and" title")
7776	.
7777	<p>[link](/url "title "and" title")</p>
7778	````````````````````````````````
7779
7780
7781	But it is easy to work around this by using a different quote type:
7782
7783	```````````````````````````````` example
7784	[link](/url 'title "and" title')
7785	.
7786	<p><a href="/url" title="title "and" title">link</a></p>
7787	````````````````````````````````
7788
7789
7790	(Note: `Markdown.pl` did allow double quotes inside a double-quoted
7791	title, and its test suite included a test demonstrating this.
7792	But it is hard to see a good rationale for the extra complexity this
7793	brings, since there are already many ways---backslash escaping,
7794	entity and numeric character references, or using a different
7795	quote type for the enclosing title---to write titles containing
7796	double quotes. `Markdown.pl`'s handling of titles has a number
7797	of other strange features. For example, it allows single-quoted
7798	titles in inline links, but not reference links. And, in
7799	reference links but not inline links, it allows a title to begin
7800	with `"` and end with `)`. `Markdown.pl` 1.0.1 even allows
7801	titles with no closing quotation mark, though 1.0.2b8 does not.
7802	It seems preferable to adopt a simple, rational rule that works
7803	the same way in inline links and link reference definitions.)
7804
7805	Spaces, tabs, and up to one line ending is allowed around the destination and
7806	title:
7807
7808	```````````````````````````````` example
7809	[link]( /uri
7810	"title" )
7811	.
7812	<p><a href="/uri" title="title">link</a></p>
7813	````````````````````````````````
7814
7815
7816	But it is not allowed between the link text and the
7817	following parenthesis:
7818
7819	```````````````````````````````` example
7820	[link] (/uri)
7821	.
7822	<p>[link] (/uri)</p>
7823	````````````````````````````````
7824
7825
7826	The link text may contain balanced brackets, but not unbalanced ones,
7827	unless they are escaped:
7828
7829	```````````````````````````````` example
7830	[link [foo [bar]]](/uri)
7831	.
7832	<p><a href="/uri">link [foo [bar]]</a></p>
7833	````````````````````````````````
7834
7835
7836	```````````````````````````````` example
7837	[link] bar](/uri)
7838	.
7839	<p>[link] bar](/uri)</p>
7840	````````````````````````````````
7841
7842
7843	```````````````````````````````` example
7844	[link [bar](/uri)
7845	.
7846	<p>[link <a href="/uri">bar</a></p>
7847	````````````````````````````````
7848
7849
7850	```````````````````````````````` example
7851	[link \[bar](/uri)
7852	.
7853	<p><a href="/uri">link [bar</a></p>
7854	````````````````````````````````
7855
7856
7857	The link text may contain inline content:
7858
7859	```````````````````````````````` example
7860	[link foo bar* `#`*](/uri)
7861	.
7862	<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
7863	````````````````````````````````
7864
7865
7866	```````````````````````````````` example
7867	[![moon](moon.jpg)](/uri)
7868	.
7869	<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
7870	````````````````````````````````
7871
7872
7873	However, links may not contain other links, at any level of nesting.
7874
7875	```````````````````````````````` example
7876	[foo [bar](/uri)](/uri)
7877	.
7878	<p>[foo <a href="/uri">bar</a>](/uri)</p>
7879	````````````````````````````````
7880
7881
7882	```````````````````````````````` example
7883	[foo [bar [baz](/uri)](/uri)](/uri)
7884	.
7885	<p>[foo <em>[bar <a href="/uri">baz</a>](/uri)</em>](/uri)</p>
7886	````````````````````````````````
7887
7888
7889	```````````````````````````````` example
7890	![[[foo](uri1)](uri2)](uri3)
7891	.
7892	<p><img src="uri3" alt="[foo](uri2)" /></p>
7893	````````````````````````````````
7894
7895
7896	These cases illustrate the precedence of link text grouping over
7897	emphasis grouping:
7898
7899	```````````````````````````````` example
7900	[foo](/uri)
7901	.
7902	<p><a href="/uri">foo</a></p>
7903	````````````````````````````````
7904
7905
7906	```````````````````````````````` example
7907	[foo bar](baz)
7908	.
7909	<p><a href="baz">foo bar</a></p>
7910	````````````````````````````````
7911
7912
7913	Note that brackets that aren't part of links do not take
7914	precedence:
7915
7916	```````````````````````````````` example
7917	foo [bar baz]
7918	.
7919	<p><em>foo [bar</em> baz]</p>
7920	````````````````````````````````
7921
7922
7923	These cases illustrate the precedence of HTML tags, code spans,
7924	and autolinks over link grouping:
7925
7926	```````````````````````````````` example
7927	[foo <bar attr="](baz)">
7928	.
7929	<p>[foo <bar attr="](baz)"></p>
7930	````````````````````````````````
7931
7932
7933	```````````````````````````````` example
7934	[foo`](/uri)`
7935	.
7936	<p>[foo<code>](/uri)</code></p>
7937	````````````````````````````````
7938
7939
7940	```````````````````````````````` example
7941	[foo<http://example.com/?search=](uri)>
7942	.
7943	<p>[foo<a href="http://example.com/?search=%5D(uri)">http://example.com/?search=](uri)</a></p>
7944	````````````````````````````````
7945
7946
7947	There are three kinds of [reference link](@)s:
7948	[full](#full-reference-link), [collapsed](#collapsed-reference-link),
7949	and [shortcut](#shortcut-reference-link).
7950
7951	A [full reference link](@)
7952	consists of a [link text] immediately followed by a [link label]
7953	that [matches] a [link reference definition] elsewhere in the document.
7954
7955	A [link label](@) begins with a left bracket (`[`) and ends
7956	with the first right bracket (`]`) that is not backslash-escaped.
7957	Between these brackets there must be at least one character that is not a space,
7958	tab, or line ending.
7959	Unescaped square bracket characters are not allowed inside the
7960	opening and closing square brackets of [link labels]. A link
7961	label can have at most 999 characters inside the square
7962	brackets.
7963
7964	One label [matches](@)
7965	another just in case their normalized forms are equal. To normalize a
7966	label, strip off the opening and closing brackets,
7967	perform the Unicode case fold, strip leading and trailing
7968	spaces, tabs, and line endings, and collapse consecutive internal
7969	spaces, tabs, and line endings to a single space. If there are multiple
7970	matching reference link definitions, the one that comes first in the
7971	document is used. (It is desirable in such cases to emit a warning.)
7972
7973	The link's URI and title are provided by the matching [link
7974	reference definition].
7975
7976	Here is a simple example:
7977
7978	```````````````````````````````` example
7979	[foo][bar]
7980
7981	[bar]: /url "title"
7982	.
7983	<p><a href="/url" title="title">foo</a></p>
7984	````````````````````````````````
7985
7986
7987	The rules for the [link text] are the same as with
7988	[inline links]. Thus:
7989
7990	The link text may contain balanced brackets, but not unbalanced ones,
7991	unless they are escaped:
7992
7993	```````````````````````````````` example
7994	[link [foo [bar]]][ref]
7995
7996	[ref]: /uri
7997	.
7998	<p><a href="/uri">link [foo [bar]]</a></p>
7999	````````````````````````````````
8000
8001
8002	```````````````````````````````` example
8003	[link \[bar][ref]
8004
8005	[ref]: /uri
8006	.
8007	<p><a href="/uri">link [bar</a></p>
8008	````````````````````````````````
8009
8010
8011	The link text may contain inline content:
8012
8013	```````````````````````````````` example
8014	[link foo bar* `#`*][ref]
8015
8016	[ref]: /uri
8017	.
8018	<p><a href="/uri">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>
8019	````````````````````````````````
8020
8021
8022	```````````````````````````````` example
8023	[![moon](moon.jpg)][ref]
8024
8025	[ref]: /uri
8026	.
8027	<p><a href="/uri"><img src="moon.jpg" alt="moon" /></a></p>
8028	````````````````````````````````
8029
8030
8031	However, links may not contain other links, at any level of nesting.
8032
8033	```````````````````````````````` example
8034	[foo [bar](/uri)][ref]
8035
8036	[ref]: /uri
8037	.
8038	<p>[foo <a href="/uri">bar</a>]<a href="/uri">ref</a></p>
8039	````````````````````````````````
8040
8041
8042	```````````````````````````````` example
8043	[foo bar [baz][ref]][ref]
8044
8045	[ref]: /uri
8046	.
8047	<p>[foo <em>bar <a href="/uri">baz</a></em>]<a href="/uri">ref</a></p>
8048	````````````````````````````````
8049
8050
8051	(In the examples above, we have two [shortcut reference links]
8052	instead of one [full reference link].)
8053
8054	The following cases illustrate the precedence of link text grouping over
8055	emphasis grouping:
8056
8057	```````````````````````````````` example
8058	[foo][ref]
8059
8060	[ref]: /uri
8061	.
8062	<p><a href="/uri">foo</a></p>
8063	````````````````````````````````
8064
8065
8066	```````````````````````````````` example
8067	[foo bar][ref]
8068
8069	[ref]: /uri
8070	.
8071	<p><a href="/uri">foo bar</a></p>
8072	````````````````````````````````
8073
8074
8075	These cases illustrate the precedence of HTML tags, code spans,
8076	and autolinks over link grouping:
8077
8078	```````````````````````````````` example
8079	[foo <bar attr="][ref]">
8080
8081	[ref]: /uri
8082	.
8083	<p>[foo <bar attr="][ref]"></p>
8084	````````````````````````````````
8085
8086
8087	```````````````````````````````` example
8088	[foo`][ref]`
8089
8090	[ref]: /uri
8091	.
8092	<p>[foo<code>][ref]</code></p>
8093	````````````````````````````````
8094
8095
8096	```````````````````````````````` example
8097	[foo<http://example.com/?search=][ref]>
8098
8099	[ref]: /uri
8100	.
8101	<p>[foo<a href="http://example.com/?search=%5D%5Bref%5D">http://example.com/?search=][ref]</a></p>
8102	````````````````````````````````
8103
8104
8105	Matching is case-insensitive:
8106
8107	```````````````````````````````` example
8108	[foo][BaR]
8109
8110	[bar]: /url "title"
8111	.
8112	<p><a href="/url" title="title">foo</a></p>
8113	````````````````````````````````
8114
8115
8116	Unicode case fold is used:
8117
8118	```````````````````````````````` example
8119	[ẞ]
8120
8121	[SS]: /url
8122	.
8123	<p><a href="/url">ẞ</a></p>
8124	````````````````````````````````
8125
8126
8127	Consecutive internal spaces, tabs, and line endings are treated as one space for
8128	purposes of determining matching:
8129
8130	```````````````````````````````` example
8131	[Foo
8132	bar]: /url
8133
8134	[Baz][Foo bar]
8135	.
8136	<p><a href="/url">Baz</a></p>
8137	````````````````````````````````
8138
8139
8140	No spaces, tabs, or line endings are allowed between the [link text] and the
8141	[link label]:
8142
8143	```````````````````````````````` example
8144	[foo] [bar]
8145
8146	[bar]: /url "title"
8147	.
8148	<p>[foo] <a href="/url" title="title">bar</a></p>
8149	````````````````````````````````
8150
8151
8152	```````````````````````````````` example
8153	[foo]
8154	[bar]
8155
8156	[bar]: /url "title"
8157	.
8158	<p>[foo]
8159	<a href="/url" title="title">bar</a></p>
8160	````````````````````````````````
8161
8162
8163	This is a departure from John Gruber's original Markdown syntax
8164	description, which explicitly allows whitespace between the link
8165	text and the link label. It brings reference links in line with
8166	[inline links], which (according to both original Markdown and
8167	this spec) cannot have whitespace after the link text. More
8168	importantly, it prevents inadvertent capture of consecutive
8169	[shortcut reference links]. If whitespace is allowed between the
8170	link text and the link label, then in the following we will have
8171	a single reference link, not two shortcut reference links, as
8172	intended:
8173
8174	``` markdown
8175	[foo]
8176	[bar]
8177
8178	[foo]: /url1
8179	[bar]: /url2
8180	```
8181
8182	(Note that [shortcut reference links] were introduced by Gruber
8183	himself in a beta version of `Markdown.pl`, but never included
8184	in the official syntax description. Without shortcut reference
8185	links, it is harmless to allow space between the link text and
8186	link label; but once shortcut references are introduced, it is
8187	too dangerous to allow this, as it frequently leads to
8188	unintended results.)
8189
8190	When there are multiple matching [link reference definitions],
8191	the first is used:
8192
8193	```````````````````````````````` example
8194	[foo]: /url1
8195
8196	[foo]: /url2
8197
8198	[bar][foo]
8199	.
8200	<p><a href="/url1">bar</a></p>
8201	````````````````````````````````
8202
8203
8204	Note that matching is performed on normalized strings, not parsed
8205	inline content. So the following does not match, even though the
8206	labels define equivalent inline content:
8207
8208	```````````````````````````````` example
8209	[bar][foo\!]
8210
8211	[foo!]: /url
8212	.
8213	<p>[bar][foo!]</p>
8214	````````````````````````````````
8215
8216
8217	[Link labels] cannot contain brackets, unless they are
8218	backslash-escaped:
8219
8220	```````````````````````````````` example
8221	[foo][ref[]
8222
8223	[ref[]: /uri
8224	.
8225	<p>[foo][ref[]</p>
8226	<p>[ref[]: /uri</p>
8227	````````````````````````````````
8228
8229
8230	```````````````````````````````` example
8231	[foo][ref[bar]]
8232
8233	[ref[bar]]: /uri
8234	.
8235	<p>[foo][ref[bar]]</p>
8236	<p>[ref[bar]]: /uri</p>
8237	````````````````````````````````
8238
8239
8240	```````````````````````````````` example
8241	[[[foo]]]
8242
8243	[[[foo]]]: /url
8244	.
8245	<p>[[[foo]]]</p>
8246	<p>[[[foo]]]: /url</p>
8247	````````````````````````````````
8248
8249
8250	```````````````````````````````` example
8251	[foo][ref\[]
8252
8253	[ref\[]: /uri
8254	.
8255	<p><a href="/uri">foo</a></p>
8256	````````````````````````````````
8257
8258
8259	Note that in this example `]` is not backslash-escaped:
8260
8261	```````````````````````````````` example
8262	[bar\\]: /uri
8263
8264	[bar\\]
8265	.
8266	<p><a href="/uri">bar\</a></p>
8267	````````````````````````````````
8268
8269
8270	A [link label] must contain at least one character that is not a space, tab, or
8271	line ending:
8272
8273	```````````````````````````````` example
8274	[]
8275
8276	[]: /uri
8277	.
8278	<p>[]</p>
8279	<p>[]: /uri</p>
8280	````````````````````````````````
8281
8282
8283	```````````````````````````````` example
8284	[
8285	]
8286
8287	[
8288	]: /uri
8289	.
8290	<p>[
8291	]</p>
8292	<p>[
8293	]: /uri</p>
8294	````````````````````````````````
8295
8296
8297	A [collapsed reference link](@)
8298	consists of a [link label] that [matches] a
8299	[link reference definition] elsewhere in the
8300	document, followed by the string `[]`.
8301	The contents of the first link label are parsed as inlines,
8302	which are used as the link's text. The link's URI and title are
8303	provided by the matching reference link definition. Thus,
8304	`[foo][]` is equivalent to `[foo][foo]`.
8305
8306	```````````````````````````````` example
8307	[foo][]
8308
8309	[foo]: /url "title"
8310	.
8311	<p><a href="/url" title="title">foo</a></p>
8312	````````````````````````````````
8313
8314
8315	```````````````````````````````` example
8316	[foo bar][]
8317
8318	[foo bar]: /url "title"
8319	.
8320	<p><a href="/url" title="title"><em>foo</em> bar</a></p>
8321	````````````````````````````````
8322
8323
8324	The link labels are case-insensitive:
8325
8326	```````````````````````````````` example
8327	[Foo][]
8328
8329	[foo]: /url "title"
8330	.
8331	<p><a href="/url" title="title">Foo</a></p>
8332	````````````````````````````````
8333
8334
8335
8336	As with full reference links, spaces, tabs, or line endings are not
8337	allowed between the two sets of brackets:
8338
8339	```````````````````````````````` example
8340	[foo]
8341	[]
8342
8343	[foo]: /url "title"
8344	.
8345	<p><a href="/url" title="title">foo</a>
8346	[]</p>
8347	````````````````````````````````
8348
8349
8350	A [shortcut reference link](@)
8351	consists of a [link label] that [matches] a
8352	[link reference definition] elsewhere in the
8353	document and is not followed by `[]` or a link label.
8354	The contents of the first link label are parsed as inlines,
8355	which are used as the link's text. The link's URI and title
8356	are provided by the matching link reference definition.
8357	Thus, `[foo]` is equivalent to `[foo][]`.
8358
8359	```````````````````````````````` example
8360	[foo]
8361
8362	[foo]: /url "title"
8363	.
8364	<p><a href="/url" title="title">foo</a></p>
8365	````````````````````````````````
8366
8367
8368	```````````````````````````````` example
8369	[foo bar]
8370
8371	[foo bar]: /url "title"
8372	.
8373	<p><a href="/url" title="title"><em>foo</em> bar</a></p>
8374	````````````````````````````````
8375
8376
8377	```````````````````````````````` example
8378	[[foo bar]]
8379
8380	[foo bar]: /url "title"
8381	.
8382	<p>[<a href="/url" title="title"><em>foo</em> bar</a>]</p>
8383	````````````````````````````````
8384
8385
8386	```````````````````````````````` example
8387	[[bar [foo]
8388
8389	[foo]: /url
8390	.
8391	<p>[[bar <a href="/url">foo</a></p>
8392	````````````````````````````````
8393
8394
8395	The link labels are case-insensitive:
8396
8397	```````````````````````````````` example
8398	[Foo]
8399
8400	[foo]: /url "title"
8401	.
8402	<p><a href="/url" title="title">Foo</a></p>
8403	````````````````````````````````
8404
8405
8406	A space after the link text should be preserved:
8407
8408	```````````````````````````````` example
8409	[foo] bar
8410
8411	[foo]: /url
8412	.
8413	<p><a href="/url">foo</a> bar</p>
8414	````````````````````````````````
8415
8416
8417	If you just want bracketed text, you can backslash-escape the
8418	opening bracket to avoid links:
8419
8420	```````````````````````````````` example
8421	\[foo]
8422
8423	[foo]: /url "title"
8424	.
8425	<p>[foo]</p>
8426	````````````````````````````````
8427
8428
8429	Note that this is a link, because a link label ends with the first
8430	following closing bracket:
8431
8432	```````````````````````````````` example
8433	[foo*]: /url
8434
8435	[foo]
8436	.
8437	<p><a href="/url">foo</a></p>
8438	````````````````````````````````
8439
8440
8441	Full and compact references take precedence over shortcut
8442	references:
8443
8444	```````````````````````````````` example
8445	[foo][bar]
8446
8447	[foo]: /url1
8448	[bar]: /url2
8449	.
8450	<p><a href="/url2">foo</a></p>
8451	````````````````````````````````
8452
8453	```````````````````````````````` example
8454	[foo][]
8455
8456	[foo]: /url1
8457	.
8458	<p><a href="/url1">foo</a></p>
8459	````````````````````````````````
8460
8461	Inline links also take precedence:
8462
8463	```````````````````````````````` example
8464	[foo]()
8465
8466	[foo]: /url1
8467	.
8468	<p><a href="">foo</a></p>
8469	````````````````````````````````
8470
8471	```````````````````````````````` example
8472	[foo](not a link)
8473
8474	[foo]: /url1
8475	.
8476	<p><a href="/url1">foo</a>(not a link)</p>
8477	````````````````````````````````
8478
8479	In the following case `[bar][baz]` is parsed as a reference,
8480	`[foo]` as normal text:
8481
8482	```````````````````````````````` example
8483	[foo][bar][baz]
8484
8485	[baz]: /url
8486	.
8487	<p>[foo]<a href="/url">bar</a></p>
8488	````````````````````````````````
8489
8490
8491	Here, though, `[foo][bar]` is parsed as a reference, since
8492	`[bar]` is defined:
8493
8494	```````````````````````````````` example
8495	[foo][bar][baz]
8496
8497	[baz]: /url1
8498	[bar]: /url2
8499	.
8500	<p><a href="/url2">foo</a><a href="/url1">baz</a></p>
8501	````````````````````````````````
8502
8503
8504	Here `[foo]` is not parsed as a shortcut reference, because it
8505	is followed by a link label (even though `[bar]` is not defined):
8506
8507	```````````````````````````````` example
8508	[foo][bar][baz]
8509
8510	[baz]: /url1
8511	[foo]: /url2
8512	.
8513	<p>[foo]<a href="/url1">bar</a></p>
8514	````````````````````````````````
8515
8516
8517
8518	## Images
8519
8520	Syntax for images is like the syntax for links, with one
8521	difference. Instead of [link text], we have an
8522	[image description](@). The rules for this are the
8523	same as for [link text], except that (a) an
8524	image description starts with `![` rather than `[`, and
8525	(b) an image description may contain links.
8526	An image description has inline elements
8527	as its contents. When an image is rendered to HTML,
8528	this is standardly used as the image's `alt` attribute.
8529
8530	```````````````````````````````` example
8531	![foo](/url "title")
8532	.
8533	<p><img src="/url" alt="foo" title="title" /></p>
8534	````````````````````````````````
8535
8536
8537	```````````````````````````````` example
8538	![foo bar]
8539
8540	[foo bar]: train.jpg "train & tracks"
8541	.
8542	<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>
8543	````````````````````````````````
8544
8545
8546	```````````````````````````````` example
8547	![foo ![bar](/url)](/url2)
8548	.
8549	<p><img src="/url2" alt="foo bar" /></p>
8550	````````````````````````````````
8551
8552
8553	```````````````````````````````` example
8554	![foo [bar](/url)](/url2)
8555	.
8556	<p><img src="/url2" alt="foo bar" /></p>
8557	````````````````````````````````
8558
8559
8560	Though this spec is concerned with parsing, not rendering, it is
8561	recommended that in rendering to HTML, only the plain string content
8562	of the [image description] be used. Note that in
8563	the above example, the alt attribute's value is `foo bar`, not `foo
8564	[bar](/url)` or `foo <a href="/url">bar</a>`. Only the plain string
8565	content is rendered, without formatting.
8566
8567	```````````````````````````````` example
8568	![foo bar][]
8569
8570	[foo bar]: train.jpg "train & tracks"
8571	.
8572	<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>
8573	````````````````````````````````
8574
8575
8576	```````````````````````````````` example
8577	![foo bar][foobar]
8578
8579	[FOOBAR]: train.jpg "train & tracks"
8580	.
8581	<p><img src="train.jpg" alt="foo bar" title="train & tracks" /></p>
8582	````````````````````````````````
8583
8584
8585	```````````````````````````````` example
8586	![foo](train.jpg)
8587	.
8588	<p><img src="train.jpg" alt="foo" /></p>
8589	````````````````````````````````
8590
8591
8592	```````````````````````````````` example
8593	My ![foo bar](/path/to/train.jpg "title" )
8594	.
8595	<p>My <img src="/path/to/train.jpg" alt="foo bar" title="title" /></p>
8596	````````````````````````````````
8597
8598
8599	```````````````````````````````` example
8600	![foo](<url>)
8601	.
8602	<p><img src="url" alt="foo" /></p>
8603	````````````````````````````````
8604
8605
8606	```````````````````````````````` example
8607	![](/url)
8608	.
8609	<p><img src="/url" alt="" /></p>
8610	````````````````````````````````
8611
8612
8613	Reference-style:
8614
8615	```````````````````````````````` example
8616	![foo][bar]
8617
8618	[bar]: /url
8619	.
8620	<p><img src="/url" alt="foo" /></p>
8621	````````````````````````````````
8622
8623
8624	```````````````````````````````` example
8625	![foo][bar]
8626
8627	[BAR]: /url
8628	.
8629	<p><img src="/url" alt="foo" /></p>
8630	````````````````````````````````
8631
8632
8633	Collapsed:
8634
8635	```````````````````````````````` example
8636	![foo][]
8637
8638	[foo]: /url "title"
8639	.
8640	<p><img src="/url" alt="foo" title="title" /></p>
8641	````````````````````````````````
8642
8643
8644	```````````````````````````````` example
8645	![foo bar][]
8646
8647	[foo bar]: /url "title"
8648	.
8649	<p><img src="/url" alt="foo bar" title="title" /></p>
8650	````````````````````````````````
8651
8652
8653	The labels are case-insensitive:
8654
8655	```````````````````````````````` example
8656	![Foo][]
8657
8658	[foo]: /url "title"
8659	.
8660	<p><img src="/url" alt="Foo" title="title" /></p>
8661	````````````````````````````````
8662
8663
8664	As with reference links, spaces, tabs, and line endings, are not allowed
8665	between the two sets of brackets:
8666
8667	```````````````````````````````` example
8668	![foo]
8669	[]
8670
8671	[foo]: /url "title"
8672	.
8673	<p><img src="/url" alt="foo" title="title" />
8674	[]</p>
8675	````````````````````````````````
8676
8677
8678	Shortcut:
8679
8680	```````````````````````````````` example
8681	![foo]
8682
8683	[foo]: /url "title"
8684	.
8685	<p><img src="/url" alt="foo" title="title" /></p>
8686	````````````````````````````````
8687
8688
8689	```````````````````````````````` example
8690	![foo bar]
8691
8692	[foo bar]: /url "title"
8693	.
8694	<p><img src="/url" alt="foo bar" title="title" /></p>
8695	````````````````````````````````
8696
8697
8698	Note that link labels cannot contain unescaped brackets:
8699
8700	```````````````````````````````` example
8701	![[foo]]
8702
8703	[[foo]]: /url "title"
8704	.
8705	<p>![[foo]]</p>
8706	<p>[[foo]]: /url "title"</p>
8707	````````````````````````````````
8708
8709
8710	The link labels are case-insensitive:
8711
8712	```````````````````````````````` example
8713	![Foo]
8714
8715	[foo]: /url "title"
8716	.
8717	<p><img src="/url" alt="Foo" title="title" /></p>
8718	````````````````````````````````
8719
8720
8721	If you just want a literal `!` followed by bracketed text, you can
8722	backslash-escape the opening `[`:
8723
8724	```````````````````````````````` example
8725	!\[foo]
8726
8727	[foo]: /url "title"
8728	.
8729	<p>![foo]</p>
8730	````````````````````````````````
8731
8732
8733	If you want a link after a literal `!`, backslash-escape the
8734	`!`:
8735
8736	```````````````````````````````` example
8737	\![foo]
8738
8739	[foo]: /url "title"
8740	.
8741	<p>!<a href="/url" title="title">foo</a></p>
8742	````````````````````````````````
8743
8744
8745	## Autolinks
8746
8747	[Autolink](@)s are absolute URIs and email addresses inside
8748	`<` and `>`. They are parsed as links, with the URL or email address
8749	as the link label.
8750
8751	A [URI autolink](@) consists of `<`, followed by an
8752	[absolute URI] followed by `>`. It is parsed as
8753	a link to the URI, with the URI as the link's label.
8754
8755	An [absolute URI](@),
8756	for these purposes, consists of a [scheme] followed by a colon (`:`)
8757	followed by zero or more characters other [ASCII control
8758	characters][ASCII control character], [space], `<`, and `>`.
8759	If the URI includes these characters, they must be percent-encoded
8760	(e.g. `%20` for a space).
8761
8762	For purposes of this spec, a [scheme](@) is any sequence
8763	of 2--32 characters beginning with an ASCII letter and followed
8764	by any combination of ASCII letters, digits, or the symbols plus
8765	("+"), period ("."), or hyphen ("-").
8766
8767	Here are some valid autolinks:
8768
8769	```````````````````````````````` example
8770	<http://foo.bar.baz>
8771	.
8772	<p><a href="http://foo.bar.baz">http://foo.bar.baz</a></p>
8773	````````````````````````````````
8774
8775
8776	```````````````````````````````` example
8777	<http://foo.bar.baz/test?q=hello&id=22&boolean>
8778	.
8779	<p><a href="http://foo.bar.baz/test?q=hello&id=22&boolean">http://foo.bar.baz/test?q=hello&id=22&boolean</a></p>
8780	````````````````````````````````
8781
8782
8783	```````````````````````````````` example
8784	<irc://foo.bar:2233/baz>
8785	.
8786	<p><a href="irc://foo.bar:2233/baz">irc://foo.bar:2233/baz</a></p>
8787	````````````````````````````````
8788
8789
8790	Uppercase is also fine:
8791
8792	```````````````````````````````` example
8793	<MAILTO:FOO@BAR.BAZ>
8794	.
8795	<p><a href="MAILTO:FOO@BAR.BAZ">MAILTO:FOO@BAR.BAZ</a></p>
8796	````````````````````````````````
8797
8798
8799	Note that many strings that count as [absolute URIs] for
8800	purposes of this spec are not valid URIs, because their
8801	schemes are not registered or because of other problems
8802	with their syntax:
8803
8804	```````````````````````````````` example
8805	<a+b+c:d>
8806	.
8807	<p><a href="a+b+c:d">a+b+c:d</a></p>
8808	````````````````````````````````
8809
8810
8811	```````````````````````````````` example
8812	<made-up-scheme://foo,bar>
8813	.
8814	<p><a href="made-up-scheme://foo,bar">made-up-scheme://foo,bar</a></p>
8815	````````````````````````````````
8816
8817
8818	```````````````````````````````` example
8819	<http://../>
8820	.
8821	<p><a href="http://../">http://../</a></p>
8822	````````````````````````````````
8823
8824
8825	```````````````````````````````` example
8826	<localhost:5001/foo>
8827	.
8828	<p><a href="localhost:5001/foo">localhost:5001/foo</a></p>
8829	````````````````````````````````
8830
8831
8832	Spaces are not allowed in autolinks:
8833
8834	```````````````````````````````` example
8835	<http://foo.bar/baz bim>
8836	.
8837	<p><http://foo.bar/baz bim></p>
8838	````````````````````````````````
8839
8840
8841	Backslash-escapes do not work inside autolinks:
8842
8843	```````````````````````````````` example
8844	<http://example.com/\[\>
8845	.
8846	<p><a href="http://example.com/%5C%5B%5C">http://example.com/\[\</a></p>
8847	````````````````````````````````
8848
8849
8850	An [email autolink](@)
8851	consists of `<`, followed by an [email address],
8852	followed by `>`. The link's label is the email address,
8853	and the URL is `mailto:` followed by the email address.
8854
8855	An [email address](@),
8856	for these purposes, is anything that matches
8857	the [non-normative regex from the HTML5
8858	spec](https://html.spec.whatwg.org/multipage/forms.html#e-mail-state-(type=email)):
8859
8860	/^[a-zA-Z0-9.!#$%&'*+/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?
8861	(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
8862
8863	Examples of email autolinks:
8864
8865	```````````````````````````````` example
8866	<foo@bar.example.com>
8867	.
8868	<p><a href="mailto:foo@bar.example.com">foo@bar.example.com</a></p>
8869	````````````````````````````````
8870
8871
8872	```````````````````````````````` example
8873	<foo+special@Bar.baz-bar0.com>
8874	.
8875	<p><a href="mailto:foo+special@Bar.baz-bar0.com">foo+special@Bar.baz-bar0.com</a></p>
8876	````````````````````````````````
8877
8878
8879	Backslash-escapes do not work inside email autolinks:
8880
8881	```````````````````````````````` example
8882	<foo\+@bar.example.com>
8883	.
8884	<p><foo+@bar.example.com></p>
8885	````````````````````````````````
8886
8887
8888	These are not autolinks:
8889
8890	```````````````````````````````` example
8891	<>
8892	.
8893	<p><></p>
8894	````````````````````````````````
8895
8896
8897	```````````````````````````````` example
8898	< http://foo.bar >
8899	.
8900	<p>< http://foo.bar ></p>
8901	````````````````````````````````
8902
8903
8904	```````````````````````````````` example
8905	<m:abc>
8906	.
8907	<p><m:abc></p>
8908	````````````````````````````````
8909
8910
8911	```````````````````````````````` example
8912	<foo.bar.baz>
8913	.
8914	<p><foo.bar.baz></p>
8915	````````````````````````````````
8916
8917
8918	```````````````````````````````` example
8919	http://example.com
8920	.
8921	<p>http://example.com</p>
8922	````````````````````````````````
8923
8924
8925	```````````````````````````````` example
8926	foo@bar.example.com
8927	.
8928	<p>foo@bar.example.com</p>
8929	````````````````````````````````
8930
8931
8932	## Raw HTML
8933
8934	Text between `<` and `>` that looks like an HTML tag is parsed as a
8935	raw HTML tag and will be rendered in HTML without escaping.
8936	Tag and attribute names are not limited to current HTML tags,
8937	so custom tags (and even, say, DocBook tags) may be used.
8938
8939	Here is the grammar for tags:
8940
8941	A [tag name](@) consists of an ASCII letter
8942	followed by zero or more ASCII letters, digits, or
8943	hyphens (`-`).
8944
8945	An [attribute](@) consists of spaces, tabs, and up to one line ending,
8946	an [attribute name], and an optional
8947	[attribute value specification].
8948
8949	An [attribute name](@)
8950	consists of an ASCII letter, `_`, or `:`, followed by zero or more ASCII
8951	letters, digits, `_`, `.`, `:`, or `-`. (Note: This is the XML
8952	specification restricted to ASCII. HTML5 is laxer.)
8953
8954	An [attribute value specification](@)
8955	consists of optional spaces, tabs, and up to one line ending,
8956	a `=` character, optional spaces, tabs, and up to one line ending,
8957	and an [attribute value].
8958
8959	An [attribute value](@)
8960	consists of an [unquoted attribute value],
8961	a [single-quoted attribute value], or a [double-quoted attribute value].
8962
8963	An [unquoted attribute value](@)
8964	is a nonempty string of characters not
8965	including spaces, tabs, line endings, `"`, `'`, `=`, `<`, `>`, or `` ` ``.
8966
8967	A [single-quoted attribute value](@)
8968	consists of `'`, zero or more
8969	characters not including `'`, and a final `'`.
8970
8971	A [double-quoted attribute value](@)
8972	consists of `"`, zero or more
8973	characters not including `"`, and a final `"`.
8974
8975	An [open tag](@) consists of a `<` character, a [tag name],
8976	zero or more [attributes], optional spaces, tabs, and up to one line ending,
8977	an optional `/` character, and a `>` character.
8978
8979	A [closing tag](@) consists of the string `</`, a
8980	[tag name], optional spaces, tabs, and up to one line ending, and the character
8981	`>`.
8982
8983	An [HTML comment](@) consists of `<!--` + text + `-->`,
8984	where text does not start with `>` or `->`, does not end with `-`,
8985	and does not contain `--`. (See the
8986	[HTML5 spec](http://www.w3.org/TR/html5/syntax.html#comments).)
8987
8988	A [processing instruction](@)
8989	consists of the string `<?`, a string
8990	of characters not including the string `?>`, and the string
8991	`?>`.
8992
8993	A [declaration](@) consists of the string `<!`, an ASCII letter, zero or more
8994	characters not including the character `>`, and the character `>`.
8995
8996	A [CDATA section](@) consists of
8997	the string `<![CDATA[`, a string of characters not including the string
8998	`]]>`, and the string `]]>`.
8999
9000	An [HTML tag](@) consists of an [open tag], a [closing tag],
9001	an [HTML comment], a [processing instruction], a [declaration],
9002	or a [CDATA section].
9003
9004	Here are some simple open tags:
9005
9006	```````````````````````````````` example
9007	<a><bab><c2c>
9008	.
9009	<p><a><bab><c2c></p>
9010	````````````````````````````````
9011
9012
9013	Empty elements:
9014
9015	```````````````````````````````` example
9016	<a/><b2/>
9017	.
9018	<p><a/><b2/></p>
9019	````````````````````````````````
9020
9021
9022	Whitespace is allowed:
9023
9024	```````````````````````````````` example
9025	<a /><b2
9026	data="foo" >
9027	.
9028	<p><a /><b2
9029	data="foo" ></p>
9030	````````````````````````````````
9031
9032
9033	With attributes:
9034
9035	```````````````````````````````` example
9036	<a foo="bar" bam = 'baz <em>"</em>'
9037	_boolean zoop:33=zoop:33 />
9038	.
9039	<p><a foo="bar" bam = 'baz <em>"</em>'
9040	_boolean zoop:33=zoop:33 /></p>
9041	````````````````````````````````
9042
9043
9044	Custom tag names can be used:
9045
9046	```````````````````````````````` example
9047	Foo <responsive-image src="foo.jpg" />
9048	.
9049	<p>Foo <responsive-image src="foo.jpg" /></p>
9050	````````````````````````````````
9051
9052
9053	Illegal tag names, not parsed as HTML:
9054
9055	```````````````````````````````` example
9056	<33> <__>
9057	.
9058	<p><33> <__></p>
9059	````````````````````````````````
9060
9061
9062	Illegal attribute names:
9063
9064	```````````````````````````````` example
9065	<a h*#ref="hi">
9066	.
9067	<p><a h*#ref="hi"></p>
9068	````````````````````````````````
9069
9070
9071	Illegal attribute values:
9072
9073	```````````````````````````````` example
9074	<a href="hi'> <a href=hi'>
9075	.
9076	<p><a href="hi'> <a href=hi'></p>
9077	````````````````````````````````
9078
9079
9080	Illegal whitespace:
9081
9082	```````````````````````````````` example
9083	< a><
9084	foo><bar/ >
9085	<foo bar=baz
9086	bim!bop />
9087	.
9088	<p>< a><
9089	foo><bar/ >
9090	<foo bar=baz
9091	bim!bop /></p>
9092	````````````````````````````````
9093
9094
9095	Missing whitespace:
9096
9097	```````````````````````````````` example
9098	<a href='bar'title=title>
9099	.
9100	<p><a href='bar'title=title></p>
9101	````````````````````````````````
9102
9103
9104	Closing tags:
9105
9106	```````````````````````````````` example
9107	</a></foo >
9108	.
9109	<p></a></foo ></p>
9110	````````````````````````````````
9111
9112
9113	Illegal attributes in closing tag:
9114
9115	```````````````````````````````` example
9116	</a href="foo">
9117	.
9118	<p></a href="foo"></p>
9119	````````````````````````````````
9120
9121
9122	Comments:
9123
9124	```````````````````````````````` example
9125	foo <!-- this is a
9126	comment - with hyphen -->
9127	.
9128	<p>foo <!-- this is a
9129	comment - with hyphen --></p>
9130	````````````````````````````````
9131
9132
9133	```````````````````````````````` example
9134	foo <!-- not a comment -- two hyphens -->
9135	.
9136	<p>foo <!-- not a comment -- two hyphens --></p>
9137	````````````````````````````````
9138
9139
9140	Not comments:
9141
9142	```````````````````````````````` example
9143	foo <!--> foo -->
9144
9145	foo <!-- foo--->
9146	.
9147	<p>foo <!--> foo --></p>
9148	<p>foo <!-- foo---></p>
9149	````````````````````````````````
9150
9151
9152	Processing instructions:
9153
9154	```````````````````````````````` example
9155	foo <?php echo $a; ?>
9156	.
9157	<p>foo <?php echo $a; ?></p>
9158	````````````````````````````````
9159
9160
9161	Declarations:
9162
9163	```````````````````````````````` example
9164	foo <!ELEMENT br EMPTY>
9165	.
9166	<p>foo <!ELEMENT br EMPTY></p>
9167	````````````````````````````````
9168
9169
9170	CDATA sections:
9171
9172	```````````````````````````````` example
9173	foo <![CDATA[>&<]]>
9174	.
9175	<p>foo <![CDATA[>&<]]></p>
9176	````````````````````````````````
9177
9178
9179	Entity and numeric character references are preserved in HTML
9180	attributes:
9181
9182	```````````````````````````````` example
9183	foo <a href="ö">
9184	.
9185	<p>foo <a href="ö"></p>
9186	````````````````````````````````
9187
9188
9189	Backslash escapes do not work in HTML attributes:
9190
9191	```````````````````````````````` example
9192	foo <a href="\*">
9193	.
9194	<p>foo <a href="\*"></p>
9195	````````````````````````````````
9196
9197
9198	```````````````````````````````` example
9199	<a href="\"">
9200	.
9201	<p><a href="""></p>
9202	````````````````````````````````
9203
9204
9205	## Hard line breaks
9206
9207	A line ending (not in a code span or HTML tag) that is preceded
9208	by two or more spaces and does not occur at the end of a block
9209	is parsed as a [hard line break](@) (rendered
9210	in HTML as a `<br />` tag):
9211
9212	```````````````````````````````` example
9213	foo
9214	baz
9215	.
9216	<p>foo<br />
9217	baz</p>
9218	````````````````````````````````
9219
9220
9221	For a more visible alternative, a backslash before the
9222	[line ending] may be used instead of two or more spaces:
9223
9224	```````````````````````````````` example
9225	foo\
9226	baz
9227	.
9228	<p>foo<br />
9229	baz</p>
9230	````````````````````````````````
9231
9232
9233	More than two spaces can be used:
9234
9235	```````````````````````````````` example
9236	foo
9237	baz
9238	.
9239	<p>foo<br />
9240	baz</p>
9241	````````````````````````````````
9242
9243
9244	Leading spaces at the beginning of the next line are ignored:
9245
9246	```````````````````````````````` example
9247	foo
9248	bar
9249	.
9250	<p>foo<br />
9251	bar</p>
9252	````````````````````````````````
9253
9254
9255	```````````````````````````````` example
9256	foo\
9257	bar
9258	.
9259	<p>foo<br />
9260	bar</p>
9261	````````````````````````````````
9262
9263
9264	Hard line breaks can occur inside emphasis, links, and other constructs
9265	that allow inline content:
9266
9267	```````````````````````````````` example
9268	*foo
9269	bar*
9270	.
9271	<p><em>foo<br />
9272	bar</em></p>
9273	````````````````````````````````
9274
9275
9276	```````````````````````````````` example
9277	*foo\
9278	bar*
9279	.
9280	<p><em>foo<br />
9281	bar</em></p>
9282	````````````````````````````````
9283
9284
9285	Hard line breaks do not occur inside code spans
9286
9287	```````````````````````````````` example
9288	`code
9289	span`
9290	.
9291	<p><code>code span</code></p>
9292	````````````````````````````````
9293
9294
9295	```````````````````````````````` example
9296	`code\
9297	span`
9298	.
9299	<p><code>code\ span</code></p>
9300	````````````````````````````````
9301
9302
9303	or HTML tags:
9304
9305	```````````````````````````````` example
9306	<a href="foo
9307	bar">
9308	.
9309	<p><a href="foo
9310	bar"></p>
9311	````````````````````````````````
9312
9313
9314	```````````````````````````````` example
9315	<a href="foo\
9316	bar">
9317	.
9318	<p><a href="foo\
9319	bar"></p>
9320	````````````````````````````````
9321
9322
9323	Hard line breaks are for separating inline content within a block.
9324	Neither syntax for hard line breaks works at the end of a paragraph or
9325	other block element:
9326
9327	```````````````````````````````` example
9328	foo\
9329	.
9330	<p>foo\</p>
9331	````````````````````````````````
9332
9333
9334	```````````````````````````````` example
9335	foo
9336	.
9337	<p>foo</p>
9338	````````````````````````````````
9339
9340
9341	```````````````````````````````` example
9342	### foo\
9343	.
9344	<h3>foo\</h3>
9345	````````````````````````````````
9346
9347
9348	```````````````````````````````` example
9349	### foo
9350	.
9351	<h3>foo</h3>
9352	````````````````````````````````
9353
9354
9355	## Soft line breaks
9356
9357	A regular line ending (not in a code span or HTML tag) that is not
9358	preceded by two or more spaces or a backslash is parsed as a
9359	[softbreak](@). (A soft line break may be rendered in HTML either as a
9360	[line ending] or as a space. The result will be the same in
9361	browsers. In the examples here, a [line ending] will be used.)
9362
9363	```````````````````````````````` example
9364	foo
9365	baz
9366	.
9367	<p>foo
9368	baz</p>
9369	````````````````````````````````
9370
9371
9372	Spaces at the end of the line and beginning of the next line are
9373	removed:
9374
9375	```````````````````````````````` example
9376	foo
9377	baz
9378	.
9379	<p>foo
9380	baz</p>
9381	````````````````````````````````
9382
9383
9384	A conforming parser may render a soft line break in HTML either as a
9385	line ending or as a space.
9386
9387	A renderer may also provide an option to render soft line breaks
9388	as hard line breaks.
9389
9390	## Textual content
9391
9392	Any characters not given an interpretation by the above rules will
9393	be parsed as plain textual content.
9394
9395	```````````````````````````````` example
9396	hello $.;'there
9397	.
9398	<p>hello $.;'there</p>
9399	````````````````````````````````
9400
9401
9402	```````````````````````````````` example
9403	Foo χρῆν
9404	.
9405	<p>Foo χρῆν</p>
9406	````````````````````````````````
9407
9408
9409	Internal spaces are preserved verbatim:
9410
9411	```````````````````````````````` example
9412	Multiple spaces
9413	.
9414	<p>Multiple spaces</p>
9415	````````````````````````````````
9416
9417
9418	<!-- END TESTS -->
9419
9420	# Appendix: A parsing strategy
9421
9422	In this appendix we describe some features of the parsing strategy
9423	used in the CommonMark reference implementations.
9424
9425	## Overview
9426
9427	Parsing has two phases:
9428
9429	1. In the first phase, lines of input are consumed and the block
9430	structure of the document---its division into paragraphs, block quotes,
9431	list items, and so on---is constructed. Text is assigned to these
9432	blocks but not parsed. Link reference definitions are parsed and a
9433	map of links is constructed.
9434
9435	2. In the second phase, the raw text contents of paragraphs and headings
9436	are parsed into sequences of Markdown inline elements (strings,
9437	code spans, links, emphasis, and so on), using the map of link
9438	references constructed in phase 1.
9439
9440	At each point in processing, the document is represented as a tree of
9441	blocks. The root of the tree is a `document` block. The `document`
9442	may have any number of other blocks as children. These children
9443	may, in turn, have other blocks as children. The last child of a block
9444	is normally considered open, meaning that subsequent lines of input
9445	can alter its contents. (Blocks that are not open are closed.)
9446	Here, for example, is a possible document tree, with the open blocks
9447	marked by arrows:
9448
9449	``` tree
9450	-> document
9451	-> block_quote
9452	paragraph
9453	"Lorem ipsum dolor\nsit amet."
9454	-> list (type=bullet tight=true bullet_char=-)
9455	list_item
9456	paragraph
9457	"Qui quodsi iracundia"
9458	-> list_item
9459	-> paragraph
9460	"aliquando id"
9461	```
9462
9463	## Phase 1: block structure
9464
9465	Each line that is processed has an effect on this tree. The line is
9466	analyzed and, depending on its contents, the document may be altered
9467	in one or more of the following ways:
9468
9469	1. One or more open blocks may be closed.
9470	2. One or more new blocks may be created as children of the
9471	last open block.
9472	3. Text may be added to the last (deepest) open block remaining
9473	on the tree.
9474
9475	Once a line has been incorporated into the tree in this way,
9476	it can be discarded, so input can be read in a stream.
9477
9478	For each line, we follow this procedure:
9479
9480	1. First we iterate through the open blocks, starting with the
9481	root document, and descending through last children down to the last
9482	open block. Each block imposes a condition that the line must satisfy
9483	if the block is to remain open. For example, a block quote requires a
9484	`>` character. A paragraph requires a non-blank line.
9485	In this phase we may match all or just some of the open
9486	blocks. But we cannot close unmatched blocks yet, because we may have a
9487	[lazy continuation line].
9488
9489	2. Next, after consuming the continuation markers for existing
9490	blocks, we look for new block starts (e.g. `>` for a block quote).
9491	If we encounter a new block start, we close any blocks unmatched
9492	in step 1 before creating the new block as a child of the last
9493	matched container block.
9494
9495	3. Finally, we look at the remainder of the line (after block
9496	markers like `>`, list markers, and indentation have been consumed).
9497	This is text that can be incorporated into the last open
9498	block (a paragraph, code block, heading, or raw HTML).
9499
9500	Setext headings are formed when we see a line of a paragraph
9501	that is a [setext heading underline].
9502
9503	Reference link definitions are detected when a paragraph is closed;
9504	the accumulated text lines are parsed to see if they begin with
9505	one or more reference link definitions. Any remainder becomes a
9506	normal paragraph.
9507
9508	We can see how this works by considering how the tree above is
9509	generated by four lines of Markdown:
9510
9511	``` markdown
9512	> Lorem ipsum dolor
9513	sit amet.
9514	> - Qui quodsi iracundia
9515	> - aliquando id
9516	```
9517
9518	At the outset, our document model is just
9519
9520	``` tree
9521	-> document
9522	```
9523
9524	The first line of our text,
9525
9526	``` markdown
9527	> Lorem ipsum dolor
9528	```
9529
9530	causes a `block_quote` block to be created as a child of our
9531	open `document` block, and a `paragraph` block as a child of
9532	the `block_quote`. Then the text is added to the last open
9533	block, the `paragraph`:
9534
9535	``` tree
9536	-> document
9537	-> block_quote
9538	-> paragraph
9539	"Lorem ipsum dolor"
9540	```
9541
9542	The next line,
9543
9544	``` markdown
9545	sit amet.
9546	```
9547
9548	is a "lazy continuation" of the open `paragraph`, so it gets added
9549	to the paragraph's text:
9550
9551	``` tree
9552	-> document
9553	-> block_quote
9554	-> paragraph
9555	"Lorem ipsum dolor\nsit amet."
9556	```
9557
9558	The third line,
9559
9560	``` markdown
9561	> - Qui quodsi iracundia
9562	```
9563
9564	causes the `paragraph` block to be closed, and a new `list` block
9565	opened as a child of the `block_quote`. A `list_item` is also
9566	added as a child of the `list`, and a `paragraph` as a child of
9567	the `list_item`. The text is then added to the new `paragraph`:
9568
9569	``` tree
9570	-> document
9571	-> block_quote
9572	paragraph
9573	"Lorem ipsum dolor\nsit amet."
9574	-> list (type=bullet tight=true bullet_char=-)
9575	-> list_item
9576	-> paragraph
9577	"Qui quodsi iracundia"
9578	```
9579
9580	The fourth line,
9581
9582	``` markdown
9583	> - aliquando id
9584	```
9585
9586	causes the `list_item` (and its child the `paragraph`) to be closed,
9587	and a new `list_item` opened up as child of the `list`. A `paragraph`
9588	is added as a child of the new `list_item`, to contain the text.
9589	We thus obtain the final tree:
9590
9591	``` tree
9592	-> document
9593	-> block_quote
9594	paragraph
9595	"Lorem ipsum dolor\nsit amet."
9596	-> list (type=bullet tight=true bullet_char=-)
9597	list_item
9598	paragraph
9599	"Qui quodsi iracundia"
9600	-> list_item
9601	-> paragraph
9602	"aliquando id"
9603	```
9604
9605	## Phase 2: inline structure
9606
9607	Once all of the input has been parsed, all open blocks are closed.
9608
9609	We then "walk the tree," visiting every node, and parse raw
9610	string contents of paragraphs and headings as inlines. At this
9611	point we have seen all the link reference definitions, so we can
9612	resolve reference links as we go.
9613
9614	``` tree
9615	document
9616	block_quote
9617	paragraph
9618	str "Lorem ipsum dolor"
9619	softbreak
9620	str "sit amet."
9621	list (type=bullet tight=true bullet_char=-)
9622	list_item
9623	paragraph
9624	str "Qui "
9625	emph
9626	str "quodsi iracundia"
9627	list_item
9628	paragraph
9629	str "aliquando id"
9630	```
9631
9632	Notice how the [line ending] in the first paragraph has
9633	been parsed as a `softbreak`, and the asterisks in the first list item
9634	have become an `emph`.
9635
9636	### An algorithm for parsing nested emphasis and links
9637
9638	By far the trickiest part of inline parsing is handling emphasis,
9639	strong emphasis, links, and images. This is done using the following
9640	algorithm.
9641
9642	When we're parsing inlines and we hit either
9643
9644	- a run of `*` or `_` characters, or
9645	- a `[` or `![`
9646
9647	we insert a text node with these symbols as its literal content, and we
9648	add a pointer to this text node to the [delimiter stack](@).
9649
9650	The [delimiter stack] is a doubly linked list. Each
9651	element contains a pointer to a text node, plus information about
9652
9653	- the type of delimiter (`[`, `![`, `*`, `_`)
9654	- the number of delimiters,
9655	- whether the delimiter is "active" (all are active to start), and
9656	- whether the delimiter is a potential opener, a potential closer,
9657	or both (which depends on what sort of characters precede
9658	and follow the delimiters).
9659
9660	When we hit a `]` character, we call the look for link or image
9661	procedure (see below).
9662
9663	When we hit the end of the input, we call the process emphasis
9664	procedure (see below), with `stack_bottom` = NULL.
9665
9666	#### look for link or image
9667
9668	Starting at the top of the delimiter stack, we look backwards
9669	through the stack for an opening `[` or `![` delimiter.
9670
9671	- If we don't find one, we return a literal text node `]`.
9672
9673	- If we do find one, but it's not active, we remove the inactive
9674	delimiter from the stack, and return a literal text node `]`.
9675
9676	- If we find one and it's active, then we parse ahead to see if
9677	we have an inline link/image, reference link/image, compact reference
9678	link/image, or shortcut reference link/image.
9679
9680	+ If we don't, then we remove the opening delimiter from the
9681	delimiter stack and return a literal text node `]`.
9682
9683	+ If we do, then
9684
9685	* We return a link or image node whose children are the inlines
9686	after the text node pointed to by the opening delimiter.
9687
9688	* We run process emphasis on these inlines, with the `[` opener
9689	as `stack_bottom`.
9690
9691	* We remove the opening delimiter.
9692
9693	* If we have a link (and not an image), we also set all
9694	`[` delimiters before the opening delimiter to inactive. (This
9695	will prevent us from getting links within links.)
9696
9697	#### process emphasis
9698
9699	Parameter `stack_bottom` sets a lower bound to how far we
9700	descend in the [delimiter stack]. If it is NULL, we can
9701	go all the way to the bottom. Otherwise, we stop before
9702	visiting `stack_bottom`.
9703
9704	Let `current_position` point to the element on the [delimiter stack]
9705	just above `stack_bottom` (or the first element if `stack_bottom`
9706	is NULL).
9707
9708	We keep track of the `openers_bottom` for each delimiter
9709	type (`*`, `_`), indexed to the length of the closing delimiter run
9710	(modulo 3) and to whether the closing delimiter can also be an
9711	opener. Initialize this to `stack_bottom`.
9712
9713	Then we repeat the following until we run out of potential
9714	closers:
9715
9716	- Move `current_position` forward in the delimiter stack (if needed)
9717	until we find the first potential closer with delimiter `*` or `_`.
9718	(This will be the potential closer closest
9719	to the beginning of the input -- the first one in parse order.)
9720
9721	- Now, look back in the stack (staying above `stack_bottom` and
9722	the `openers_bottom` for this delimiter type) for the
9723	first matching potential opener ("matching" means same delimiter).
9724
9725	- If one is found:
9726
9727	+ Figure out whether we have emphasis or strong emphasis:
9728	if both closer and opener spans have length >= 2, we have
9729	strong, otherwise regular.
9730
9731	+ Insert an emph or strong emph node accordingly, after
9732	the text node corresponding to the opener.
9733
9734	+ Remove any delimiters between the opener and closer from
9735	the delimiter stack.
9736
9737	+ Remove 1 (for regular emph) or 2 (for strong emph) delimiters
9738	from the opening and closing text nodes. If they become empty
9739	as a result, remove them and remove the corresponding element
9740	of the delimiter stack. If the closing node is removed, reset
9741	`current_position` to the next element in the stack.
9742
9743	- If none is found:
9744
9745	+ Set `openers_bottom` to the element before `current_position`.
9746	(We know that there are no openers for this kind of closer up to and
9747	including this point, so this puts a lower bound on future searches.)
9748
9749	+ If the closer at `current_position` is not a potential opener,
9750	remove it from the delimiter stack (since we know it can't
9751	be a closer either).
9752
9753	+ Advance `current_position` to the next element in the stack.
9754
9755	After we're done, we remove all delimiters above `stack_bottom` from the
9756	delimiter stack.

crates/markdown-it/tests/fixtures/deno.lock created+72

...	@@ -0,0 +1,72 @@
1	{
2	"version": "3",
3	"packages": {
4	"specifiers": {
5	"npm:markdown-it-testgen": "npm:markdown-it-testgen@0.1.6"
6	},
7	"npm": {
8	"argparse@1.0.10": {
9	"integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
10	"dependencies": {
11	"sprintf-js": "sprintf-js@1.0.3"
12	}
13	},
14	"assertion-error@1.0.0": {
15	"integrity": "sha512-g/gZV+G476cnmtYI+Ko9d5khxSoCSoom/EaNmmCfwpOvBXEJ18qwFrxfP1/CsIqk2no1sAKKwxndV0tP7ROOFQ==",
16	"dependencies": {}
17	},
18	"chai@1.10.0": {
19	"integrity": "sha512-E3L9M2SeQU1XagJkE9KJyTAXXHKJkJ1EsKkFp0Rl53lYa3mro2PVgYHNiCb2YRa2nUeyg7aqmI1EIcSBayNd5w==",
20	"dependencies": {
21	"assertion-error": "assertion-error@1.0.0",
22	"deep-eql": "deep-eql@0.1.3"
23	}
24	},
25	"deep-eql@0.1.3": {
26	"integrity": "sha512-6sEotTRGBFiNcqVoeHwnfopbSpi5NbH1VWJmYCVkmxMmaVTT0bUTrNaGyBwhgP4MZL012W/mkzIn3Da+iDYweg==",
27	"dependencies": {
28	"type-detect": "type-detect@0.1.1"
29	}
30	},
31	"esprima@4.0.1": {
32	"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
33	"dependencies": {}
34	},
35	"js-yaml@3.14.1": {
36	"integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
37	"dependencies": {
38	"argparse": "argparse@1.0.10",
39	"esprima": "esprima@4.0.1"
40	}
41	},
42	"markdown-it-testgen@0.1.6": {
43	"integrity": "sha512-hYC71G4Mcv3Y7fLTsi4PyoHKSs0P4UgkpzmGBtUYoR/TS83lFbfXUMaI71OiMJ9r4p3fbMhHBwdNTLhSDwmt6Q==",
44	"dependencies": {
45	"chai": "chai@1.10.0",
46	"js-yaml": "js-yaml@3.14.1",
47	"object-assign": "object-assign@4.1.1"
48	}
49	},
50	"object-assign@4.1.1": {
51	"integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
52	"dependencies": {}
53	},
54	"sprintf-js@1.0.3": {
55	"integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
56	"dependencies": {}
57	},
58	"type-detect@0.1.1": {
59	"integrity": "sha512-5rqszGVwYgBoDkIm2oUtvkfZMQ0vk29iDMU0W2qCa3rG0vPDNczCMT4hV/bLBgLg8k8ri6+u3Zbt+S/14eMzlA==",
60	"dependencies": {}
61	}
62	}
63	},
64	"remote": {},
65	"workspace": {
66	"packageJson": {
67	"dependencies": [
68	"npm:markdown-it-testgen@^0.1.6"
69	]
70	}
71	}
72	}

crates/markdown-it/tests/fixtures/markdown-it/markdown-it-rs.txt created+6

...	@@ -0,0 +1,6 @@
1	regression test for panic in #40
2	.
3	![hello'"`world](x)\
4	.
5	<p><img src="x" alt="hello'"`world">\</p>
6	.

crates/markdown-it/tests/fixtures/markdown-it/smartquotes.txt created+192

...	@@ -0,0 +1,192 @@
1	Should parse nested quotes:
2	.
3	"foo 'bar' baz"
4
5	'foo 'bar' baz'
6	.
7	<p>“foo ‘bar’ baz”</p>
8	<p>‘foo ‘bar’ baz’</p>
9	.
10
11
12	Should not overlap quotes:
13	.
14	'foo "bar' baz"
15	.
16	<p>‘foo "bar’ baz"</p>
17	.
18
19
20	Should match quotes on the same level:
21	.
22	"foo bar baz"
23	.
24	<p>“foo <em>bar</em> baz”</p>
25	.
26
27
28	Should handle adjacent nested quotes:
29	.
30	'"double in single"'
31
32	"'single in double'"
33	.
34	<p>‘“double in single”’</p>
35	<p>“‘single in double’”</p>
36	.
37
38
39
40	Should not match quotes on different levels:
41	.
42	"foo bar"
43
44	"foo bar"
45
46	"foo bar baz"
47	.
48	<p><em>"foo</em> bar"</p>
49	<p>"foo <em>bar"</em></p>
50	<p><em>"foo</em> bar <em>baz"</em></p>
51	.
52
53	Smartquotes should not overlap with other tags:
54	.
55	foo "bar baz" quux
56	.
57	<p><em>foo "bar</em> <em>baz" quux</em></p>
58	.
59
60
61	Should try and find matching quote in this case:
62	.
63	"foo "bar 'baz"
64	.
65	<p>"foo “bar 'baz”</p>
66	.
67
68
69	Should not touch 'inches' in quotes:
70	.
71	"Monitor 21"" and "Monitor""
72	.
73	<p>“Monitor 21"” and “Monitor”"</p>
74	.
75
76
77	Should render an apostrophe as a rsquo:
78	.
79	This isn't and can't be the best approach to implement this...
80	.
81	<p>This isn’t and can’t be the best approach to implement this…</p>
82	.
83
84
85	Apostrophe could end the word, that's why original smartypants replaces all of them as rsquo:
86	.
87	users' stuff
88	.
89	<p>users’ stuff</p>
90	.
91
92	Quotes between punctuation chars:
93
94	.
95	"(hai)".
96	.
97	<p>“(hai)”.</p>
98	.
99
100	Quotes at the start/end of the tokens:
101	.
102	"foo bar"
103
104	"foo bar"
105
106	"foo bar"
107	.
108	<p>“<em>foo</em> bar”</p>
109	<p>“foo <em>bar</em>”</p>
110	<p>“<em>foo bar</em>”</p>
111	.
112
113	Should treat softbreak as a space:
114	.
115	"this"
116	and "that".
117
118	"this" and
119	"that".
120	.
121	<p>“this”
122	and “that”.</p>
123	<p>“this” and
124	“that”.</p>
125	.
126
127	Should treat hardbreak as a space:
128	.
129	"this"\
130	and "that".
131
132	"this" and\
133	"that".
134	.
135	<p>“this”<br>
136	and “that”.</p>
137	<p>“this” and<br>
138	“that”.</p>
139	.
140
141	Should allow quotes adjacent to other punctuation characters, #643:
142	.
143	The dog---"'man's' best friend"
144	.
145	<p>The dog—“‘man’s’ best friend”</p>
146	.
147
148	Should parse quotes adjacent to code block, #677:
149	.
150	"test `code`"
151
152	"`code` test"
153	.
154	<p>“test <code>code</code>”</p>
155	<p>“<code>code</code> test”</p>
156	.
157
158	Should parse quotes adjacent to inline html, #677:
159	.
160	"test <br>"
161
162	"<br> test"
163	.
164	<p>“test <br>”</p>
165	<p>“<br> test”</p>
166	.
167
168	Should be escapable:
169	.
170	"foo"
171
172	\"foo"
173
174	"foo\"
175	.
176	<p>“foo”</p>
177	<p>"foo"</p>
178	<p>"foo"</p>
179	.
180
181	Should not replace entities:
182	.
183	"foo"
184
185	"foo"
186
187	"foo"
188	.
189	<p>"foo"</p>
190	<p>"foo"</p>
191	<p>"foo"</p>
192	.

crates/markdown-it/tests/fixtures/markdown-it/tables.txt created+808

...	@@ -0,0 +1,808 @@
1	Simple:
2	.
3	\| Heading 1 \| Heading 2
4	\| --------- \| ---------
5	\| Cell 1 \| Cell 2
6	\| Cell 3 \| Cell 4
7	.
8	<table>
9	<thead>
10	<tr>
11	<th>Heading 1</th>
12	<th>Heading 2</th>
13	</tr>
14	</thead>
15	<tbody>
16	<tr>
17	<td>Cell 1</td>
18	<td>Cell 2</td>
19	</tr>
20	<tr>
21	<td>Cell 3</td>
22	<td>Cell 4</td>
23	</tr>
24	</tbody>
25	</table>
26	.
27
28
29	Column alignment:
30	.
31	\| Header 1 \| Header 2 \| Header 3 \| Header 4 \|
32	\| :------: \| -------: \| :------- \| -------- \|
33	\| Cell 1 \| Cell 2 \| Cell 3 \| Cell 4 \|
34	\| Cell 5 \| Cell 6 \| Cell 7 \| Cell 8 \|
35	.
36	<table>
37	<thead>
38	<tr>
39	<th style="text-align:center">Header 1</th>
40	<th style="text-align:right">Header 2</th>
41	<th style="text-align:left">Header 3</th>
42	<th>Header 4</th>
43	</tr>
44	</thead>
45	<tbody>
46	<tr>
47	<td style="text-align:center">Cell 1</td>
48	<td style="text-align:right">Cell 2</td>
49	<td style="text-align:left">Cell 3</td>
50	<td>Cell 4</td>
51	</tr>
52	<tr>
53	<td style="text-align:center">Cell 5</td>
54	<td style="text-align:right">Cell 6</td>
55	<td style="text-align:left">Cell 7</td>
56	<td>Cell 8</td>
57	</tr>
58	</tbody>
59	</table>
60	.
61
62
63	Nested emphases:
64	.
65	Header 1\|Header 2\|Header 3\|Header 4
66	:-------\|:------:\|-------:\|--------
67	Cell 1 \|Cell 2 \|Cell 3 \|Cell 4
68	Cell 5\|Cell 6 \|Cell 7 \|Cell 8
69	.
70	<table>
71	<thead>
72	<tr>
73	<th style="text-align:left">Header 1</th>
74	<th style="text-align:center">Header 2</th>
75	<th style="text-align:right">Header 3</th>
76	<th>Header 4</th>
77	</tr>
78	</thead>
79	<tbody>
80	<tr>
81	<td style="text-align:left">Cell 1</td>
82	<td style="text-align:center">Cell 2</td>
83	<td style="text-align:right">Cell 3</td>
84	<td>Cell 4</td>
85	</tr>
86	<tr>
87	<td style="text-align:left"><em>Cell 5</em></td>
88	<td style="text-align:center">Cell 6</td>
89	<td style="text-align:right">Cell 7</td>
90	<td>Cell 8</td>
91	</tr>
92	</tbody>
93	</table>
94	.
95
96
97	Nested tables inside blockquotes:
98	.
99	> foo\|foo
100	> ---\|---
101	> bar\|bar
102	baz\|baz
103	.
104	<blockquote>
105	<table>
106	<thead>
107	<tr>
108	<th>foo</th>
109	<th>foo</th>
110	</tr>
111	</thead>
112	<tbody>
113	<tr>
114	<td>bar</td>
115	<td>bar</td>
116	</tr>
117	</tbody>
118	</table>
119	</blockquote>
120	<p>baz\|baz</p>
121	.
122
123
124	Minimal one-column:
125	.
126	\| foo
127	\|----
128	\| test2
129	.
130	<table>
131	<thead>
132	<tr>
133	<th>foo</th>
134	</tr>
135	</thead>
136	<tbody>
137	<tr>
138	<td>test2</td>
139	</tr>
140	</tbody>
141	</table>
142	.
143
144
145	This is parsed as one big table:
146	.
147	- foo\|foo
148	---\|---
149	bar\|bar
150	.
151	<table>
152	<thead>
153	<tr>
154	<th>- foo</th>
155	<th>foo</th>
156	</tr>
157	</thead>
158	<tbody>
159	<tr>
160	<td>bar</td>
161	<td>bar</td>
162	</tr>
163	</tbody>
164	</table>
165	.
166
167
168	Second line should not contain symbols except "-", ":", "\|" and " ":
169	.
170	foo\|foo
171	-----\|-----s
172	bar\|bar
173	.
174	<p>foo\|foo
175	-----\|-----s
176	bar\|bar</p>
177	.
178
179
180	Second line should contain "\|" symbol:
181	.
182	foo\|foo
183	-----:-----
184	bar\|bar
185	.
186	<p>foo\|foo
187	-----:-----
188	bar\|bar</p>
189	.
190
191
192	Second line should not have empty columns in the middle:
193	.
194	foo\|foo
195	-----\|\|-----
196	bar\|bar
197	.
198	<p>foo\|foo
199	-----\|\|-----
200	bar\|bar</p>
201	.
202
203
204	Wrong alignment symbol position:
205	.
206	foo\|foo
207	-----\|-::-
208	bar\|bar
209	.
210	<p>foo\|foo
211	-----\|-::-
212	bar\|bar</p>
213	.
214
215
216	Title line should contain "\|" symbol:
217	.
218	foo
219	-----\|-----
220	bar\|bar
221	.
222	<p>foo
223	-----\|-----
224	bar\|bar</p>
225	.
226
227
228	Allow tabs as a separator on 2nd line
229	.
230	\| foo \| bar \|
231	\| --- \| --- \|
232	\| baz \| quux \|
233	.
234	<table>
235	<thead>
236	<tr>
237	<th>foo</th>
238	<th>bar</th>
239	</tr>
240	</thead>
241	<tbody>
242	<tr>
243	<td>baz</td>
244	<td>quux</td>
245	</tr>
246	</tbody>
247	</table>
248	.
249
250
251	Should terminate paragraph:
252	.
253	paragraph
254	foo\|foo
255	---\|---
256	bar\|bar
257	.
258	<p>paragraph</p>
259	<table>
260	<thead>
261	<tr>
262	<th>foo</th>
263	<th>foo</th>
264	</tr>
265	</thead>
266	<tbody>
267	<tr>
268	<td>bar</td>
269	<td>bar</td>
270	</tr>
271	</tbody>
272	</table>
273	.
274
275
276	Another complicated backticks case
277	.
278	\| Heading 1 \| Heading 2
279	\| --------- \| ---------
280	\| Cell 1 \| Cell 2
281	\| \\\`\|\\\`
282	.
283	<table>
284	<thead>
285	<tr>
286	<th>Heading 1</th>
287	<th>Heading 2</th>
288	</tr>
289	</thead>
290	<tbody>
291	<tr>
292	<td>Cell 1</td>
293	<td>Cell 2</td>
294	</tr>
295	<tr>
296	<td>\`</td>
297	<td>\`</td>
298	</tr>
299	</tbody>
300	</table>
301	.
302
303	`\` in tables should not count as escaped backtick
304	.
305	# \| 1 \| 2
306	--\|--\|--
307	x \| `\` \| `x`
308	.
309	<table>
310	<thead>
311	<tr>
312	<th>#</th>
313	<th>1</th>
314	<th>2</th>
315	</tr>
316	</thead>
317	<tbody>
318	<tr>
319	<td>x</td>
320	<td><code>\</code></td>
321	<td><code>x</code></td>
322	</tr>
323	</tbody>
324	</table>
325	.
326
327	Tables should handle escaped backticks
328	.
329	# \| 1 \| 2
330	--\|--\|--
331	x \| \`\` \| `x`
332	.
333	<table>
334	<thead>
335	<tr>
336	<th>#</th>
337	<th>1</th>
338	<th>2</th>
339	</tr>
340	</thead>
341	<tbody>
342	<tr>
343	<td>x</td>
344	<td>``</td>
345	<td><code>x</code></td>
346	</tr>
347	</tbody>
348	</table>
349	.
350
351
352	An amount of rows might be different across the table (issue #171):
353	.
354	\| 1 \| 2 \|
355	\| :-----: \| :-----: \|
356	\| 3 \| 4 \| 5 \| 6 \|
357	.
358	<table>
359	<thead>
360	<tr>
361	<th style="text-align:center">1</th>
362	<th style="text-align:center">2</th>
363	</tr>
364	</thead>
365	<tbody>
366	<tr>
367	<td style="text-align:center">3</td>
368	<td style="text-align:center">4</td>
369	</tr>
370	</tbody>
371	</table>
372	.
373
374
375	An amount of rows might be different across the table #2:
376	.
377	\| 1 \| 2 \| 3 \| 4 \|
378	\| :-----: \| :-----: \| :-----: \| :-----: \|
379	\| 5 \| 6 \|
380	.
381	<table>
382	<thead>
383	<tr>
384	<th style="text-align:center">1</th>
385	<th style="text-align:center">2</th>
386	<th style="text-align:center">3</th>
387	<th style="text-align:center">4</th>
388	</tr>
389	</thead>
390	<tbody>
391	<tr>
392	<td style="text-align:center">5</td>
393	<td style="text-align:center">6</td>
394	<td style="text-align:center"></td>
395	<td style="text-align:center"></td>
396	</tr>
397	</tbody>
398	</table>
399	.
400
401
402	Allow one-column tables (issue #171):
403	.
404	\| foo \|
405	:-----:
406	\| bar \|
407	.
408	<table>
409	<thead>
410	<tr>
411	<th style="text-align:center">foo</th>
412	</tr>
413	</thead>
414	<tbody>
415	<tr>
416	<td style="text-align:center">bar</td>
417	</tr>
418	</tbody>
419	</table>
420	.
421
422
423	Allow indented tables (issue #325):
424	.
425	\| Col1a \| Col2a \|
426	\| ----- \| ----- \|
427	\| Col1b \| Col2b \|
428	.
429	<table>
430	<thead>
431	<tr>
432	<th>Col1a</th>
433	<th>Col2a</th>
434	</tr>
435	</thead>
436	<tbody>
437	<tr>
438	<td>Col1b</td>
439	<td>Col2b</td>
440	</tr>
441	</tbody>
442	</table>
443	.
444
445
446	Tables should not be indented more than 4 spaces (1st line):
447	.
448	\| Col1a \| Col2a \|
449	\| ----- \| ----- \|
450	\| Col1b \| Col2b \|
451	.
452	<pre><code>\| Col1a \| Col2a \|
453	</code></pre>
454	<p>\| ----- \| ----- \|
455	\| Col1b \| Col2b \|</p>
456	.
457
458
459	Tables should not be indented more than 4 spaces (2nd line):
460	.
461	\| Col1a \| Col2a \|
462	\| ----- \| ----- \|
463	\| Col1b \| Col2b \|
464	.
465	<p>\| Col1a \| Col2a \|
466	\| ----- \| ----- \|
467	\| Col1b \| Col2b \|</p>
468	.
469
470
471	Tables should not be indented more than 4 spaces (3rd line):
472	.
473	\| Col1a \| Col2a \|
474	\| ----- \| ----- \|
475	\| Col1b \| Col2b \|
476	.
477	<table>
478	<thead>
479	<tr>
480	<th>Col1a</th>
481	<th>Col2a</th>
482	</tr>
483	</thead>
484	</table>
485	<pre><code>\| Col1b \| Col2b \|
486	</code></pre>
487	.
488
489
490	Allow tables with empty body:
491	.
492	\| Col1a \| Col2a \|
493	\| ----- \| ----- \|
494	.
495	<table>
496	<thead>
497	<tr>
498	<th>Col1a</th>
499	<th>Col2a</th>
500	</tr>
501	</thead>
502	</table>
503	.
504
505
506	Align row should be at least as large as any actual rows:
507	.
508	Col1a \| Col1b \| Col1c
509	----- \| -----
510	Col2a \| Col2b \| Col2c
511	.
512	<p>Col1a \| Col1b \| Col1c
513	----- \| -----
514	Col2a \| Col2b \| Col2c</p>
515	.
516
517	Escaped pipes inside backticks don't split cells:
518	.
519	\| Heading 1 \| Heading 2
520	\| --------- \| ---------
521	\| Cell 1 \| Cell 2
522	\| `Cell 3\\|` \| Cell 4
523	.
524	<table>
525	<thead>
526	<tr>
527	<th>Heading 1</th>
528	<th>Heading 2</th>
529	</tr>
530	</thead>
531	<tbody>
532	<tr>
533	<td>Cell 1</td>
534	<td>Cell 2</td>
535	</tr>
536	<tr>
537	<td><code>Cell 3\|</code></td>
538	<td>Cell 4</td>
539	</tr>
540	</tbody>
541	</table>
542	.
543
544	Escape before escaped Pipes inside backticks don't split cells:
545	.
546	\| Heading 1 \| Heading 2
547	\| --------- \| ---------
548	\| Cell 1 \| Cell 2
549	\| `Cell 3\\\|` \| Cell 4
550	.
551	<table>
552	<thead>
553	<tr>
554	<th>Heading 1</th>
555	<th>Heading 2</th>
556	</tr>
557	</thead>
558	<tbody>
559	<tr>
560	<td>Cell 1</td>
561	<td>Cell 2</td>
562	</tr>
563	<tr>
564	<td><code>Cell 3\\|</code></td>
565	<td>Cell 4</td>
566	</tr>
567	</tbody>
568	</table>
569	.
570
571	Regression test for #721, table in a list indented with tabs:
572	.
573	- Level 1
574
575	- Level 2
576
577	\| Column 1 \| Column 2 \|
578	\| -------- \| -------- \|
579	\| abcdefgh \| ijklmnop \|
580	.
581	<ul>
582	<li>
583	<p>Level 1</p>
584	<ul>
585	<li>
586	<p>Level 2</p>
587	<table>
588	<thead>
589	<tr>
590	<th>Column 1</th>
591	<th>Column 2</th>
592	</tr>
593	</thead>
594	<tbody>
595	<tr>
596	<td>abcdefgh</td>
597	<td>ijklmnop</td>
598	</tr>
599	</tbody>
600	</table>
601	</li>
602	</ul>
603	</li>
604	</ul>
605	.
606
607
608	Table without any columns is not a table, #724
609	.
610	\|
611	\|
612	\|
613	.
614	<p>\|
615	\|
616	\|</p>
617	.
618
619
620	GFM 4.10 Tables (extension), Example 198
621	.
622	\| foo \| bar \|
623	\| --- \| --- \|
624	\| baz \| bim \|
625	.
626	<table>
627	<thead>
628	<tr>
629	<th>foo</th>
630	<th>bar</th>
631	</tr>
632	</thead>
633	<tbody>
634	<tr>
635	<td>baz</td>
636	<td>bim</td>
637	</tr>
638	</tbody>
639	</table>
640	.
641
642	GFM 4.10 Tables (extension), Example 199
643	.
644	\| abc \| defghi \|
645	:-: \| -----------:
646	bar \| baz
647	.
648	<table>
649	<thead>
650	<tr>
651	<th style="text-align:center">abc</th>
652	<th style="text-align:right">defghi</th>
653	</tr>
654	</thead>
655	<tbody>
656	<tr>
657	<td style="text-align:center">bar</td>
658	<td style="text-align:right">baz</td>
659	</tr>
660	</tbody>
661	</table>
662	.
663
664	GFM 4.10 Tables (extension), Example 200
665	.
666	\| f\\|oo \|
667	\| ------ \|
668	\| b `\\|` az \|
669	\| b \\| im \|
670	.
671	<table>
672	<thead>
673	<tr>
674	<th>f\|oo</th>
675	</tr>
676	</thead>
677	<tbody>
678	<tr>
679	<td>b <code>\|</code> az</td>
680	</tr>
681	<tr>
682	<td>b <strong>\|</strong> im</td>
683	</tr>
684	</tbody>
685	</table>
686	.
687
688	GFM 4.10 Tables (extension), Example 201
689	.
690	\| abc \| def \|
691	\| --- \| --- \|
692	\| bar \| baz \|
693	> bar
694	.
695	<table>
696	<thead>
697	<tr>
698	<th>abc</th>
699	<th>def</th>
700	</tr>
701	</thead>
702	<tbody>
703	<tr>
704	<td>bar</td>
705	<td>baz</td>
706	</tr>
707	</tbody>
708	</table>
709	<blockquote>
710	<p>bar</p>
711	</blockquote>
712	.
713
714	GFM 4.10 Tables (extension), Example 202
715	.
716	\| abc \| def \|
717	\| --- \| --- \|
718	\| bar \| baz \|
719	bar
720
721	bar
722	.
723	<table>
724	<thead>
725	<tr>
726	<th>abc</th>
727	<th>def</th>
728	</tr>
729	</thead>
730	<tbody>
731	<tr>
732	<td>bar</td>
733	<td>baz</td>
734	</tr>
735	<tr>
736	<td>bar</td>
737	<td></td>
738	</tr>
739	</tbody>
740	</table>
741	<p>bar</p>
742	.
743
744	GFM 4.10 Tables (extension), Example 203
745	.
746	\| abc \| def \|
747	\| --- \|
748	\| bar \|
749	.
750	<p>\| abc \| def \|
751	\| — \|
752	\| bar \|</p>
753	.
754
755	GFM 4.10 Tables (extension), Example 204
756	.
757	\| abc \| def \|
758	\| --- \| --- \|
759	\| bar \|
760	\| bar \| baz \| boo \|
761	.
762	<table>
763	<thead>
764	<tr>
765	<th>abc</th>
766	<th>def</th>
767	</tr>
768	</thead>
769	<tbody>
770	<tr>
771	<td>bar</td>
772	<td></td>
773	</tr>
774	<tr>
775	<td>bar</td>
776	<td>baz</td>
777	</tr>
778	</tbody>
779	</table>
780	.
781
782	GFM 4.10 Tables (extension), Example 205
783	.
784	\| abc \| def \|
785	\| --- \| --- \|
786	.
787	<table>
788	<thead>
789	<tr>
790	<th>abc</th>
791	<th>def</th>
792	</tr>
793	</thead>
794	</table>
795	.
796
797	A list takes precedence in case of ambiguity
798	.
799	a \| b
800	- \| -
801	1 \| 2
802	.
803	<p>a \| b</p>
804	<ul>
805	<li>\| -
806	1 \| 2</li>
807	</ul>
808	.

crates/markdown-it/tests/fixtures/markdown-it/typographer-extra.txt created+14

...	@@ -0,0 +1,14 @@
1	don't touch text in autolinks
2	.
3	URL with (C) (c) (R) (r) (TM) (tm): https://example.com/(c)(r)(tm)/(C)(R)(TM) what do you think?
4	.
5	<p>URL with © © ® ® ™ ™: <a href="https://example.com/(c)(r)(tm)/(C)(R)(TM)">https://example.com/(c)(r)(tm)/(C)(R)(TM)</a> what do you think?</p>
6	.
7
8
9	replacements for TM should allow mixed case tM and Tm
10	.
11	These two should both end up the same as (TM) and (tm): (tM), (Tm).
12	.
13	<p>These two should both end up the same as ™ and ™: ™, ™.</p>
14	.

crates/markdown-it/tests/fixtures/markdown-it/typographer.txt created+110

...	@@ -0,0 +1,110 @@
1	.
2	(bad)
3	.
4	<p>(bad)</p>
5	.
6
7
8	copyright
9	.
10	(c) (C)
11	.
12	<p>© ©</p>
13	.
14
15
16	reserved
17	.
18	(r) (R)
19	.
20	<p>® ®</p>
21	.
22
23
24	trademark
25	.
26	(tm) (TM)
27	.
28	<p>™ ™</p>
29	.
30
31
32	plus-minus
33	.
34	+-5
35	.
36	<p>±5</p>
37	.
38
39
40	ellipsis
41	.
42	test.. test... test..... test?..... test!....
43	.
44	<p>test… test… test… test?.. test!..</p>
45	.
46
47
48	dupes
49	.
50	!!!!!! ???? ,,
51	.
52	<p>!!! ??? ,</p>
53	.
54
55	copyright should be escapable
56	.
57	\(c)
58	.
59	<p>(c)</p>
60	.
61
62	shouldn't replace entities
63	.
64	(c) (c) (c)
65	.
66	<p>(c) (c) ©</p>
67	.
68
69
70	dashes
71	.
72	---markdownit --- super---
73
74	markdownit---awesome
75
76	abc ----
77
78	--markdownit -- super--
79
80	markdownit--awesome
81	.
82	<p>—markdownit — super—</p>
83	<p>markdownit—awesome</p>
84	<p>abc ----</p>
85	<p>–markdownit – super–</p>
86	<p>markdownit–awesome</p>
87	.
88
89	dashes should be escapable
90	.
91	foo \-- bar
92
93	foo -\- bar
94	.
95	<p>foo -- bar</p>
96	<p>foo -- bar</p>
97	.
98
99	regression tests for #624
100	.
101	1---2---3
102
103	1--2--3
104
105	1 -- -- 3
106	.
107	<p>1—2—3</p>
108	<p>1–2–3</p>
109	<p>1 – – 3</p>
110	.

crates/markdown-it/tests/fixtures/package.json created+6

...	@@ -0,0 +1,6 @@
1	{
2	"type": "module",
3	"dependencies": {
4	"markdown-it-testgen": "^0.1.6"
5	}
6	}

crates/markdown-it/tests/fixtures/testgen.js created+99

...	@@ -0,0 +1,99 @@
1	// use `deno run --allow-read --allow-write ./fixtures/testgen.js ./commonmark.rs` to run this script
2
3	if (Deno.args.length !== 1) {
4	console.error(`
5	Usage: deno run --allow-read --allow-write ./fixtures/testgen.js ./commonmark.rs
6	`)
7	Deno.exit(1)
8	}
9
10	import testgen from 'npm:markdown-it-testgen@^0.1.6'
11
12	function rust_escape(s) {
13	if (s.match(/( $\|\t)/m)) {
14	return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/ $/mg, '\\x20').replace(/\t/g, '\\t') + '"'
15	}
16
17	if (s.match(/#"\|"#/)) return 'r##"' + s + '"##'
18	return 'r#"' + s + '"#'
19	}
20
21	let identmap = new Set()
22	function ident(str) {
23	str = str.toLowerCase()
24	.replace(/[^a-z0-9]+/g, '_')
25	.replace(/^_+\|_+$/g, '')
26
27	if (!str) str = 'unnamed'
28
29	let result = str
30	let idx = 0
31	while (identmap.has(result)) {
32	result = str + '_' + (++idx)
33	}
34
35	identmap.add(result)
36	return result
37	}
38
39	function generate(fixture) {
40	return `
41	#[test]
42	fn ${ident(fixture.header)}() {
43	let input = ${rust_escape(fixture.first.text.replace(/\n$/, ''))};
44	let output = ${rust_escape(fixture.second.text.replace(/\n$/, ''))};
45	run(input, output);
46	}
47	`.trim()
48	}
49
50	let input_raw = await Deno.readFile(Deno.args[0])
51	let input = new TextDecoder().decode(input_raw)
52	let lines = []
53	let state = 'passthrough'
54
55	for (let line of input.split('\n')) {
56	switch (state) {
57	case 'passthrough':
58	lines.push(line)
59	if (line.match(/^\/{4,}$/)) {
60	state = 'maybeheader'
61	}
62	break
63	case 'skipping':
64	if (line.match(/^\/{4,}$/)) {
65	lines.push(line)
66	state = 'maybeheader'
67	}
68	break
69	case 'maybeheader':
70	lines.push(line)
71	let match = line.match(/^\/{2,}\s+TESTGEN:\s(.+)\s$/)
72	if (match) {
73	let has_data = false
74	lines.push('#[rustfmt::skip]')
75	lines.push(`mod ${ident(match[1])} {`)
76	lines.push('use super::run;')
77	lines.push('// this part of the file is auto-generated')
78	lines.push('// don\'t edit it, otherwise your changes might be lost')
79	testgen.load(match[1], data => {
80	data.fixtures.forEach((data, idx) => {
81	has_data = true
82	if (idx++ > 0) lines.push('')
83	let generated = generate(data).replace(/\r?\n$/, '')
84	lines = lines.concat(generated.split('\n'))
85	})
86	})
87	lines.push('// end of auto-generated module')
88	lines.push('}')
89	if (!has_data) throw new Error(`no data found for ${match[1]}`)
90	state = 'skipping'
91	}
92	break
93	default:
94	throw Error('unknown state')
95	}
96	}
97
98	await Deno.rename(Deno.args[0], Deno.args[0] + '.old')
99	await Deno.writeFile(Deno.args[0], new TextEncoder().encode(lines.join('\n') + '\n'))

crates/markdown-it/tests/linkify.rs created+170

...	@@ -0,0 +1,170 @@
1	#![cfg(feature = "linkify")]
2	fn run(input: &str, output: &str) {
3	let output = if output.is_empty() { "".to_owned() } else { output.to_owned() + "\n" };
4	let md = &mut markdown_it::MarkdownIt::new();
5	markdown_it::plugins::cmark::add(md);
6	markdown_it::plugins::html::add(md);
7	markdown_it::plugins::extra::linkify::add(md);
8	let node = md.parse(&(input.to_owned() + "\n"));
9
10	// make sure we have sourcemaps for everything
11	node.walk(\|node, _\| assert!(node.srcmap.is_some()));
12
13	let result = node.render();
14	assert_eq!(result, output);
15
16	// make sure it doesn't crash without trailing \n
17	let _ = md.parse(input.trim_end());
18	}
19
20	#[test]
21	fn linkify() {
22	let input = r#"url http://www.youtube.com/watch?v=5Jt5GEr4AYg."#;
23	let output = r#"<p>url <a href="http://www.youtube.com/watch?v=5Jt5GEr4AYg">http://www.youtube.com/watch?v=5Jt5GEr4AYg</a>.</p>"#;
24	run(input, output);
25	}
26
27	#[test]
28	fn don_t_touch_text_in_links() {
29	let input = r#"[https://example.com](https://example.com)"#;
30	let output = r#"<p><a href="https://example.com">https://example.com</a></p>"#;
31	run(input, output);
32	}
33
34	#[test]
35	fn don_t_touch_text_in_autolinks() {
36	let input = r#"<https://example.com>"#;
37	let output = r#"<p><a href="https://example.com">https://example.com</a></p>"#;
38	run(input, output);
39	}
40
41	#[test]
42	fn don_t_touch_text_in_html_a_tags() {
43	let input = r#"<a href="https://example.com">https://example.com</a>"#;
44	let output = r#"<p><a href="https://example.com">https://example.com</a></p>"#;
45	run(input, output);
46	}
47
48	#[test]
49	fn entities_inside_raw_links() {
50	let input = r#"https://example.com/foo&bar"#;
51	let output = r#"<p><a href="https://example.com/foo&amp;bar">https://example.com/foo&amp;bar</a></p>"#;
52	run(input, output);
53	}
54
55	#[test]
56	fn emphasis_inside_raw_links_asterisk_can_happen_in_links_with_params() {
57	let input = r#"https://example.com/foobarbaz"#;
58	let output = r#"<p><a href="https://example.com/foobarbaz">https://example.com/foobarbaz</a></p>"#;
59	run(input, output);
60	}
61
62	#[test]
63	fn emphasis_inside_raw_links_underscore() {
64	let input = r#"http://example.org/foo._bar_-_baz"#;
65	let output = r#"<p><a href="http://example.org/foo._bar_-_baz">http://example.org/foo._bar_-_baz</a></p>"#;
66	run(input, output);
67	}
68
69	// not accepted as link by rust linkify
70	/*#[test]
71	fn backticks_inside_raw_links() {
72	let input = r#"https://example.com/foo`bar`baz"#;
73	let output = r#"<p><a href="https://example.com/foo%60bar%60baz">https://example.com/foo`bar`baz</a></p>"#;
74	run(input, output);
75	}*/
76
77	#[test]
78	fn links_inside_raw_links() {
79	let input = r#"https://example.com/foo[123](456)bar"#;
80	let output = r#"<p><a href="https://example.com/foo%5B123%5D(456)bar">https://example.com/foo[123](456)bar</a></p>"#;
81	run(input, output);
82	}
83
84	#[test]
85	fn escapes_not_allowed_at_the_start() {
86	let input = r#"\https://example.com"#;
87	let output = r#"<p>\https://example.com</p>"#;
88	run(input, output);
89	}
90
91	#[test]
92	fn escapes_not_allowed_at_comma() {
93	let input = r#"https\://example.com"#;
94	let output = r#"<p>https://example.com</p>"#;
95	run(input, output);
96	}
97
98	#[test]
99	fn escapes_not_allowed_at_slashes() {
100	let input = r#"https:\//aa.org https://bb.org"#;
101	let output = r#"<p>https://aa.org <a href="https://bb.org">https://bb.org</a></p>"#;
102	run(input, output);
103	}
104
105	#[test]
106	fn fuzzy_link_shouldn_t_match_cc_org() {
107	let input = r#"https:/\/cc.org"#;
108	let output = r#"<p>https://cc.org</p>"#;
109	run(input, output);
110	}
111
112	#[test]
113	fn bold_links_exclude_markup_of_pairs_from_link_tail() {
114	let input = r#"http://example.com/foobar"#;
115	let output = r#"<p><strong><a href="http://example.com/foobar">http://example.com/foobar</a></strong></p>"#;
116	run(input, output);
117	}
118
119	/*#[test]
120	fn match_links_without_protocol() {
121	let input = r#"www.example.org"#;
122	let output = r#"<p><a href="http://www.example.org">www.example.org</a></p>"#;
123	run(input, output);
124	}*/
125
126	/*#[test]
127	fn emails() {
128	let input = r#"test@example.com
129
130	mailto:test@example.com"#;
131	let output = r#"<p><a href="mailto:test@example.com">test@example.com</a></p>
132	<p><a href="mailto:test@example.com">mailto:test@example.com</a></p>"#;
133	run(input, output);
134	}*/
135
136	#[test]
137	fn typorgapher_should_not_break_href() {
138	let input = r#"http://example.com/(c)"#;
139	let output = r#"<p><a href="http://example.com/(c)">http://example.com/(c)</a></p>"#;
140	run(input, output);
141	}
142
143	#[test]
144	fn coverage_prefix_not_valid() {
145	let input = r#"http:/example.com/"#;
146	let output = r#"<p>http:/example.com/</p>"#;
147	run(input, output);
148	}
149
150	#[test]
151	fn coverage_negative_link_level() {
152	let input = r#"</a>[https://example.com](https://example.com)"#;
153	let output = r#"<p></a><a href="https://example.com"><a href="https://example.com">https://example.com</a></a></p>"#;
154	run(input, output);
155	}
156
157	/*#[test]
158	fn emphasis_with_real_link() {
159	let input = r#"http://cdecl.ridiculousfish.com/?q=int+%28f%29+%28float+%29%3B"#;
160	let output = r#"<p><a href="http://cdecl.ridiculousfish.com/?q=int+%28f%29+%28float+%29%3B">http://cdecl.ridiculousfish.com/?q=int+(f)+(float+)%3B</a></p>"#;
161	run(input, output);
162	}*/
163
164	#[test]
165	fn emphasis_with_real_link_1() {
166	let input = r#"https://www.sell.fi/sites/default/files/elainlaakarilehti/tieteelliset_artikkelit/kahkonen_t._et_al.canine_pancreatitis-_review.pdf"#;
167	let output = r#"<p><a href="https://www.sell.fi/sites/default/files/elainlaakarilehti/tieteelliset_artikkelit/kahkonen_t._et_al.canine_pancreatitis-_review.pdf">https://www.sell.fi/sites/default/files/elainlaakarilehti/tieteelliset_artikkelit/kahkonen_t._et_al.canine_pancreatitis-_review.pdf</a></p>"#;
168	run(input, output);
169	}
170

crates/markdown-it/tests/markdown-it-smartquotes.rs created+214

...	@@ -0,0 +1,214 @@
1	fn run(input: &str, output: &str) {
2	let output = if output.is_empty() {
3	"".to_owned()
4	} else {
5	output.to_owned() + "\n"
6	};
7	let md = &mut markdown_it::MarkdownIt::new();
8	markdown_it::plugins::cmark::add(md);
9	markdown_it::plugins::html::add(md);
10	markdown_it::plugins::extra::linkify::add(md);
11	markdown_it::plugins::extra::typographer::add(md);
12	markdown_it::plugins::extra::smartquotes::add(md);
13	let node = md.parse(&(input.to_owned() + "\n"));
14
15	// make sure we have sourcemaps for everything
16	node.walk(\|node, _\| assert!(node.srcmap.is_some()));
17
18	let result = node.render();
19	assert_eq!(result, output);
20
21	// make sure it doesn't crash without trailing \n
22	let _ = md.parse(input.trim_end());
23	}
24	///////////////////////////////////////////////////////////////////////////
25	// TESTGEN: fixtures/markdown-it/smartquotes.txt
26	#[rustfmt::skip]
27	mod fixtures_markdown_it_smartquotes_txt {
28	use super::run;
29	// this part of the file is auto-generated
30	// don't edit it, otherwise your changes might be lost
31	#[test]
32	fn should_parse_nested_quotes() {
33	let input = r#""foo 'bar' baz"
34
35	'foo 'bar' baz'"#;
36	let output = r#"<p>“foo ‘bar’ baz”</p>
37	<p>‘foo ‘bar’ baz’</p>"#;
38	run(input, output);
39	}
40
41	#[test]
42	fn should_not_overlap_quotes() {
43	let input = r#"'foo "bar' baz""#;
44	let output = r#"<p>‘foo "bar’ baz"</p>"#;
45	run(input, output);
46	}
47
48	#[test]
49	fn should_match_quotes_on_the_same_level() {
50	let input = r#""foo bar baz""#;
51	let output = r#"<p>“foo <em>bar</em> baz”</p>"#;
52	run(input, output);
53	}
54
55	#[test]
56	fn should_handle_adjacent_nested_quotes() {
57	let input = r#"'"double in single"'
58
59	"'single in double'""#;
60	let output = r#"<p>‘“double in single”’</p>
61	<p>“‘single in double’”</p>"#;
62	run(input, output);
63	}
64
65	#[test]
66	fn should_not_match_quotes_on_different_levels() {
67	let input = r#""foo bar"
68
69	"foo bar"
70
71	"foo bar baz""#;
72	let output = r#"<p><em>"foo</em> bar"</p>
73	<p>"foo <em>bar"</em></p>
74	<p><em>"foo</em> bar <em>baz"</em></p>"#;
75	run(input, output);
76	}
77
78	#[test]
79	fn smartquotes_should_not_overlap_with_other_tags() {
80	let input = r#"foo "bar baz" quux"#;
81	let output = r#"<p><em>foo "bar</em> <em>baz" quux</em></p>"#;
82	run(input, output);
83	}
84
85	#[test]
86	fn should_try_and_find_matching_quote_in_this_case() {
87	let input = r#""foo "bar 'baz""#;
88	let output = r#"<p>"foo “bar 'baz”</p>"#;
89	run(input, output);
90	}
91
92	#[test]
93	fn should_not_touch_inches_in_quotes() {
94	let input = r#""Monitor 21"" and "Monitor"""#;
95	let output = r#"<p>“Monitor 21"” and “Monitor”"</p>"#;
96	run(input, output);
97	}
98
99	#[test]
100	fn should_render_an_apostrophe_as_a_rsquo() {
101	let input = r#"This isn't and can't be the best approach to implement this..."#;
102	let output = r#"<p>This isn’t and can’t be the best approach to implement this…</p>"#;
103	run(input, output);
104	}
105
106	#[test]
107	fn apostrophe_could_end_the_word_that_s_why_original_smartypants_replaces_all_of_them_as_rsquo() {
108	let input = r#"users' stuff"#;
109	let output = r#"<p>users’ stuff</p>"#;
110	run(input, output);
111	}
112
113	#[test]
114	fn quotes_between_punctuation_chars() {
115	let input = r#""(hai)"."#;
116	let output = r#"<p>“(hai)”.</p>"#;
117	run(input, output);
118	}
119
120	#[test]
121	fn quotes_at_the_start_end_of_the_tokens() {
122	let input = r#""foo bar"
123
124	"foo bar"
125
126	"foo bar""#;
127	let output = r#"<p>“<em>foo</em> bar”</p>
128	<p>“foo <em>bar</em>”</p>
129	<p>“<em>foo bar</em>”</p>"#;
130	run(input, output);
131	}
132
133	#[test]
134	fn should_treat_softbreak_as_a_space() {
135	let input = r#""this"
136	and "that".
137
138	"this" and
139	"that"."#;
140	let output = r#"<p>“this”
141	and “that”.</p>
142	<p>“this” and
143	“that”.</p>"#;
144	run(input, output);
145	}
146
147	#[test]
148	fn should_treat_hardbreak_as_a_space() {
149	let input = r#""this"\
150	and "that".
151
152	"this" and\
153	"that"."#;
154	let output = r#"<p>“this”<br>
155	and “that”.</p>
156	<p>“this” and<br>
157	“that”.</p>"#;
158	run(input, output);
159	}
160
161	#[test]
162	fn should_allow_quotes_adjacent_to_other_punctuation_characters_643() {
163	let input = r#"The dog---"'man's' best friend""#;
164	let output = r#"<p>The dog—“‘man’s’ best friend”</p>"#;
165	run(input, output);
166	}
167
168	#[test]
169	fn should_parse_quotes_adjacent_to_code_block_677() {
170	let input = r#""test `code`"
171
172	"`code` test""#;
173	let output = r#"<p>“test <code>code</code>”</p>
174	<p>“<code>code</code> test”</p>"#;
175	run(input, output);
176	}
177
178	#[test]
179	fn should_parse_quotes_adjacent_to_inline_html_677() {
180	let input = r#""test <br>"
181
182	"<br> test""#;
183	let output = r#"<p>“test <br>”</p>
184	<p>“<br> test”</p>"#;
185	run(input, output);
186	}
187
188	#[test]
189	fn should_be_escapable() {
190	let input = r#""foo"
191
192	\"foo"
193
194	"foo\""#;
195	let output = r#"<p>“foo”</p>
196	<p>"foo"</p>
197	<p>"foo"</p>"#;
198	run(input, output);
199	}
200
201	#[test]
202	fn should_not_replace_entities() {
203	let input = r#""foo"
204
205	"foo"
206
207	"foo""#;
208	let output = r#"<p>"foo"</p>
209	<p>"foo"</p>
210	<p>"foo"</p>"#;
211	run(input, output);
212	}
213	// end of auto-generated module
214	}

crates/markdown-it/tests/markdown-it-typographer.rs created+157

...	@@ -0,0 +1,157 @@
1	fn run(input: &str, output: &str) {
2	let output = if output.is_empty() {
3	"".to_owned()
4	} else {
5	output.to_owned() + "\n"
6	};
7	let md = &mut markdown_it::MarkdownIt::new();
8	markdown_it::plugins::cmark::add(md);
9	markdown_it::plugins::html::add(md);
10	markdown_it::plugins::extra::linkify::add(md);
11	markdown_it::plugins::extra::typographer::add(md);
12	let node = md.parse(&(input.to_owned() + "\n"));
13
14	// make sure we have sourcemaps for everything
15	node.walk(\|node, _\| assert!(node.srcmap.is_some()));
16
17	let result = node.render();
18	assert_eq!(result, output);
19
20	// make sure it doesn't crash without trailing \n
21	let _ = md.parse(input.trim_end());
22	}
23	///////////////////////////////////////////////////////////////////////////
24	// TESTGEN: fixtures/markdown-it/typographer-extra.txt
25	#[rustfmt::skip]
26	mod fixtures_markdown_it_typographer_extra_txt {
27	use super::run;
28	// this part of the file is auto-generated
29	// don't edit it, otherwise your changes might be lost
30	#[test]
31	fn don_t_touch_text_in_autolinks() {
32	let input = r#"URL with (C) (c) (R) (r) (TM) (tm): https://example.com/(c)(r)(tm)/(C)(R)(TM) what do you think?"#;
33	let output = r#"<p>URL with © © ® ® ™ ™: <a href="https://example.com/(c)(r)(tm)/(C)(R)(TM)">https://example.com/(c)(r)(tm)/(C)(R)(TM)</a> what do you think?</p>"#;
34	run(input, output);
35	}
36
37	#[test]
38	fn replacements_for_tm_should_allow_mixed_case_tm_and_tm() {
39	let input = r#"These two should both end up the same as (TM) and (tm): (tM), (Tm)."#;
40	let output = r#"<p>These two should both end up the same as ™ and ™: ™, ™.</p>"#;
41	run(input, output);
42	}
43	// end of auto-generated module
44	}
45	///////////////////////////////////////////////////////////////////////////
46	// TESTGEN: fixtures/markdown-it/typographer.txt
47	#[rustfmt::skip]
48	mod fixtures_markdown_it_typographer_txt {
49	use super::run;
50	// this part of the file is auto-generated
51	// don't edit it, otherwise your changes might be lost
52	#[test]
53	fn unnamed() {
54	let input = r#"(bad)"#;
55	let output = r#"<p>(bad)</p>"#;
56	run(input, output);
57	}
58
59	#[test]
60	fn copyright() {
61	let input = r#"(c) (C)"#;
62	let output = r#"<p>© ©</p>"#;
63	run(input, output);
64	}
65
66	#[test]
67	fn reserved() {
68	let input = r#"(r) (R)"#;
69	let output = r#"<p>® ®</p>"#;
70	run(input, output);
71	}
72
73	#[test]
74	fn trademark() {
75	let input = r#"(tm) (TM)"#;
76	let output = r#"<p>™ ™</p>"#;
77	run(input, output);
78	}
79
80	#[test]
81	fn plus_minus() {
82	let input = r#"+-5"#;
83	let output = r#"<p>±5</p>"#;
84	run(input, output);
85	}
86
87	#[test]
88	fn ellipsis() {
89	let input = r#"test.. test... test..... test?..... test!...."#;
90	let output = r#"<p>test… test… test… test?.. test!..</p>"#;
91	run(input, output);
92	}
93
94	#[test]
95	fn dupes() {
96	let input = r#"!!!!!! ???? ,,"#;
97	let output = r#"<p>!!! ??? ,</p>"#;
98	run(input, output);
99	}
100
101	#[test]
102	fn copyright_should_be_escapable() {
103	let input = r#"\(c)"#;
104	let output = r#"<p>(c)</p>"#;
105	run(input, output);
106	}
107
108	#[test]
109	fn shouldn_t_replace_entities() {
110	let input = r#"(c) (c) (c)"#;
111	let output = r#"<p>(c) (c) ©</p>"#;
112	run(input, output);
113	}
114
115	#[test]
116	fn dashes() {
117	let input = r#"---markdownit --- super---
118
119	markdownit---awesome
120
121	abc ----
122
123	--markdownit -- super--
124
125	markdownit--awesome"#;
126	let output = r#"<p>—markdownit — super—</p>
127	<p>markdownit—awesome</p>
128	<p>abc ----</p>
129	<p>–markdownit – super–</p>
130	<p>markdownit–awesome</p>"#;
131	run(input, output);
132	}
133
134	#[test]
135	fn dashes_should_be_escapable() {
136	let input = r#"foo \-- bar
137
138	foo -\- bar"#;
139	let output = r#"<p>foo -- bar</p>
140	<p>foo -- bar</p>"#;
141	run(input, output);
142	}
143
144	#[test]
145	fn regression_tests_for_624() {
146	let input = r#"1---2---3
147
148	1--2--3
149
150	1 -- -- 3"#;
151	let output = r#"<p>1—2—3</p>
152	<p>1–2–3</p>
153	<p>1 – – 3</p>"#;
154	run(input, output);
155	}
156	// end of auto-generated module
157	}

crates/markdown-it/tests/markdown-it.rs created+828

...	@@ -0,0 +1,828 @@
1
2	fn run(input: &str, output: &str) {
3	let output = if output.is_empty() { "".to_owned() } else { output.to_owned() + "\n" };
4	let md = &mut markdown_it::MarkdownIt::new();
5	markdown_it::plugins::cmark::add(md);
6	markdown_it::plugins::html::add(md);
7	markdown_it::plugins::extra::typographer::add(md);
8	markdown_it::plugins::extra::tables::add(md);
9	let node = md.parse(&(input.to_owned() + "\n"));
10
11	// make sure we have sourcemaps for everything
12	node.walk(\|node, _\| assert!(node.srcmap.is_some()));
13
14	let result = node.render();
15	assert_eq!(result, output);
16
17	// make sure it doesn't crash without trailing \n
18	let _ = md.parse(input.trim_end());
19	}
20
21	///////////////////////////////////////////////////////////////////////////
22	// TESTGEN: fixtures/markdown-it/tables.txt
23	#[rustfmt::skip]
24	mod fixtures_markdown_it_tables_txt {
25	use super::run;
26	// this part of the file is auto-generated
27	// don't edit it, otherwise your changes might be lost
28	#[test]
29	fn simple() {
30	let input = r#"\| Heading 1 \| Heading 2
31	\| --------- \| ---------
32	\| Cell 1 \| Cell 2
33	\| Cell 3 \| Cell 4"#;
34	let output = r#"<table>
35	<thead>
36	<tr>
37	<th>Heading 1</th>
38	<th>Heading 2</th>
39	</tr>
40	</thead>
41	<tbody>
42	<tr>
43	<td>Cell 1</td>
44	<td>Cell 2</td>
45	</tr>
46	<tr>
47	<td>Cell 3</td>
48	<td>Cell 4</td>
49	</tr>
50	</tbody>
51	</table>"#;
52	run(input, output);
53	}
54
55	#[test]
56	fn column_alignment() {
57	let input = r#"\| Header 1 \| Header 2 \| Header 3 \| Header 4 \|
58	\| :------: \| -------: \| :------- \| -------- \|
59	\| Cell 1 \| Cell 2 \| Cell 3 \| Cell 4 \|
60	\| Cell 5 \| Cell 6 \| Cell 7 \| Cell 8 \|"#;
61	let output = r#"<table>
62	<thead>
63	<tr>
64	<th style="text-align:center">Header 1</th>
65	<th style="text-align:right">Header 2</th>
66	<th style="text-align:left">Header 3</th>
67	<th>Header 4</th>
68	</tr>
69	</thead>
70	<tbody>
71	<tr>
72	<td style="text-align:center">Cell 1</td>
73	<td style="text-align:right">Cell 2</td>
74	<td style="text-align:left">Cell 3</td>
75	<td>Cell 4</td>
76	</tr>
77	<tr>
78	<td style="text-align:center">Cell 5</td>
79	<td style="text-align:right">Cell 6</td>
80	<td style="text-align:left">Cell 7</td>
81	<td>Cell 8</td>
82	</tr>
83	</tbody>
84	</table>"#;
85	run(input, output);
86	}
87
88	#[test]
89	fn nested_emphases() {
90	let input = r#"Header 1\|Header 2\|Header 3\|Header 4
91	:-------\|:------:\|-------:\|--------
92	Cell 1 \|Cell 2 \|Cell 3 \|Cell 4
93	Cell 5\|Cell 6 \|Cell 7 \|Cell 8"#;
94	let output = r#"<table>
95	<thead>
96	<tr>
97	<th style="text-align:left">Header 1</th>
98	<th style="text-align:center">Header 2</th>
99	<th style="text-align:right">Header 3</th>
100	<th>Header 4</th>
101	</tr>
102	</thead>
103	<tbody>
104	<tr>
105	<td style="text-align:left">Cell 1</td>
106	<td style="text-align:center">Cell 2</td>
107	<td style="text-align:right">Cell 3</td>
108	<td>Cell 4</td>
109	</tr>
110	<tr>
111	<td style="text-align:left"><em>Cell 5</em></td>
112	<td style="text-align:center">Cell 6</td>
113	<td style="text-align:right">Cell 7</td>
114	<td>Cell 8</td>
115	</tr>
116	</tbody>
117	</table>"#;
118	run(input, output);
119	}
120
121	#[test]
122	fn nested_tables_inside_blockquotes() {
123	let input = r#"> foo\|foo
124	> ---\|---
125	> bar\|bar
126	baz\|baz"#;
127	let output = r#"<blockquote>
128	<table>
129	<thead>
130	<tr>
131	<th>foo</th>
132	<th>foo</th>
133	</tr>
134	</thead>
135	<tbody>
136	<tr>
137	<td>bar</td>
138	<td>bar</td>
139	</tr>
140	</tbody>
141	</table>
142	</blockquote>
143	<p>baz\|baz</p>"#;
144	run(input, output);
145	}
146
147	#[test]
148	fn minimal_one_column() {
149	let input = r#"\| foo
150	\|----
151	\| test2"#;
152	let output = r#"<table>
153	<thead>
154	<tr>
155	<th>foo</th>
156	</tr>
157	</thead>
158	<tbody>
159	<tr>
160	<td>test2</td>
161	</tr>
162	</tbody>
163	</table>"#;
164	run(input, output);
165	}
166
167	#[test]
168	fn this_is_parsed_as_one_big_table() {
169	let input = r#"- foo\|foo
170	---\|---
171	bar\|bar"#;
172	let output = r#"<table>
173	<thead>
174	<tr>
175	<th>- foo</th>
176	<th>foo</th>
177	</tr>
178	</thead>
179	<tbody>
180	<tr>
181	<td>bar</td>
182	<td>bar</td>
183	</tr>
184	</tbody>
185	</table>"#;
186	run(input, output);
187	}
188
189	#[test]
190	fn second_line_should_not_contain_symbols_except_and() {
191	let input = r#"foo\|foo
192	-----\|-----s
193	bar\|bar"#;
194	let output = r#"<p>foo\|foo
195	-----\|-----s
196	bar\|bar</p>"#;
197	run(input, output);
198	}
199
200	#[test]
201	fn second_line_should_contain_symbol() {
202	let input = r#"foo\|foo
203	-----:-----
204	bar\|bar"#;
205	let output = r#"<p>foo\|foo
206	-----:-----
207	bar\|bar</p>"#;
208	run(input, output);
209	}
210
211	#[test]
212	fn second_line_should_not_have_empty_columns_in_the_middle() {
213	let input = r#"foo\|foo
214	-----\|\|-----
215	bar\|bar"#;
216	let output = r#"<p>foo\|foo
217	-----\|\|-----
218	bar\|bar</p>"#;
219	run(input, output);
220	}
221
222	#[test]
223	fn wrong_alignment_symbol_position() {
224	let input = r#"foo\|foo
225	-----\|-::-
226	bar\|bar"#;
227	let output = r#"<p>foo\|foo
228	-----\|-::-
229	bar\|bar</p>"#;
230	run(input, output);
231	}
232
233	#[test]
234	fn title_line_should_contain_symbol() {
235	let input = r#"foo
236	-----\|-----
237	bar\|bar"#;
238	let output = r#"<p>foo
239	-----\|-----
240	bar\|bar</p>"#;
241	run(input, output);
242	}
243
244	#[test]
245	fn allow_tabs_as_a_separator_on_2nd_line() {
246	let input = "\|\tfoo\t\|\tbar\t\|
247	\|\t---\t\|\t---\t\|
248	\|\tbaz\t\|\tquux\t\|";
249	let output = r#"<table>
250	<thead>
251	<tr>
252	<th>foo</th>
253	<th>bar</th>
254	</tr>
255	</thead>
256	<tbody>
257	<tr>
258	<td>baz</td>
259	<td>quux</td>
260	</tr>
261	</tbody>
262	</table>"#;
263	run(input, output);
264	}
265
266	#[test]
267	fn should_terminate_paragraph() {
268	let input = r#"paragraph
269	foo\|foo
270	---\|---
271	bar\|bar"#;
272	let output = r#"<p>paragraph</p>
273	<table>
274	<thead>
275	<tr>
276	<th>foo</th>
277	<th>foo</th>
278	</tr>
279	</thead>
280	<tbody>
281	<tr>
282	<td>bar</td>
283	<td>bar</td>
284	</tr>
285	</tbody>
286	</table>"#;
287	run(input, output);
288	}
289
290	#[test]
291	fn another_complicated_backticks_case() {
292	let input = r#"\| Heading 1 \| Heading 2
293	\| --------- \| ---------
294	\| Cell 1 \| Cell 2
295	\| \\\`\|\\\`"#;
296	let output = r#"<table>
297	<thead>
298	<tr>
299	<th>Heading 1</th>
300	<th>Heading 2</th>
301	</tr>
302	</thead>
303	<tbody>
304	<tr>
305	<td>Cell 1</td>
306	<td>Cell 2</td>
307	</tr>
308	<tr>
309	<td>\`</td>
310	<td>\`</td>
311	</tr>
312	</tbody>
313	</table>"#;
314	run(input, output);
315	}
316
317	#[test]
318	fn in_tables_should_not_count_as_escaped_backtick() {
319	let input = r#"# \| 1 \| 2
320	--\|--\|--
321	x \| `\` \| `x`"#;
322	let output = r#"<table>
323	<thead>
324	<tr>
325	<th>#</th>
326	<th>1</th>
327	<th>2</th>
328	</tr>
329	</thead>
330	<tbody>
331	<tr>
332	<td>x</td>
333	<td><code>\</code></td>
334	<td><code>x</code></td>
335	</tr>
336	</tbody>
337	</table>"#;
338	run(input, output);
339	}
340
341	#[test]
342	fn tables_should_handle_escaped_backticks() {
343	let input = r#"# \| 1 \| 2
344	--\|--\|--
345	x \| \`\` \| `x`"#;
346	let output = r#"<table>
347	<thead>
348	<tr>
349	<th>#</th>
350	<th>1</th>
351	<th>2</th>
352	</tr>
353	</thead>
354	<tbody>
355	<tr>
356	<td>x</td>
357	<td>``</td>
358	<td><code>x</code></td>
359	</tr>
360	</tbody>
361	</table>"#;
362	run(input, output);
363	}
364
365	#[test]
366	fn an_amount_of_rows_might_be_different_across_the_table_issue_171() {
367	let input = r#"\| 1 \| 2 \|
368	\| :-----: \| :-----: \|
369	\| 3 \| 4 \| 5 \| 6 \|"#;
370	let output = r#"<table>
371	<thead>
372	<tr>
373	<th style="text-align:center">1</th>
374	<th style="text-align:center">2</th>
375	</tr>
376	</thead>
377	<tbody>
378	<tr>
379	<td style="text-align:center">3</td>
380	<td style="text-align:center">4</td>
381	</tr>
382	</tbody>
383	</table>"#;
384	run(input, output);
385	}
386
387	#[test]
388	fn an_amount_of_rows_might_be_different_across_the_table_2() {
389	let input = r#"\| 1 \| 2 \| 3 \| 4 \|
390	\| :-----: \| :-----: \| :-----: \| :-----: \|
391	\| 5 \| 6 \|"#;
392	let output = r#"<table>
393	<thead>
394	<tr>
395	<th style="text-align:center">1</th>
396	<th style="text-align:center">2</th>
397	<th style="text-align:center">3</th>
398	<th style="text-align:center">4</th>
399	</tr>
400	</thead>
401	<tbody>
402	<tr>
403	<td style="text-align:center">5</td>
404	<td style="text-align:center">6</td>
405	<td style="text-align:center"></td>
406	<td style="text-align:center"></td>
407	</tr>
408	</tbody>
409	</table>"#;
410	run(input, output);
411	}
412
413	#[test]
414	fn allow_one_column_tables_issue_171() {
415	let input = r#"\| foo \|
416	:-----:
417	\| bar \|"#;
418	let output = r#"<table>
419	<thead>
420	<tr>
421	<th style="text-align:center">foo</th>
422	</tr>
423	</thead>
424	<tbody>
425	<tr>
426	<td style="text-align:center">bar</td>
427	</tr>
428	</tbody>
429	</table>"#;
430	run(input, output);
431	}
432
433	#[test]
434	fn allow_indented_tables_issue_325() {
435	let input = r#" \| Col1a \| Col2a \|
436	\| ----- \| ----- \|
437	\| Col1b \| Col2b \|"#;
438	let output = r#"<table>
439	<thead>
440	<tr>
441	<th>Col1a</th>
442	<th>Col2a</th>
443	</tr>
444	</thead>
445	<tbody>
446	<tr>
447	<td>Col1b</td>
448	<td>Col2b</td>
449	</tr>
450	</tbody>
451	</table>"#;
452	run(input, output);
453	}
454
455	#[test]
456	fn tables_should_not_be_indented_more_than_4_spaces_1st_line() {
457	let input = r#" \| Col1a \| Col2a \|
458	\| ----- \| ----- \|
459	\| Col1b \| Col2b \|"#;
460	let output = r#"<pre><code>\| Col1a \| Col2a \|
461	</code></pre>
462	<p>\| ----- \| ----- \|
463	\| Col1b \| Col2b \|</p>"#;
464	run(input, output);
465	}
466
467	#[test]
468	fn tables_should_not_be_indented_more_than_4_spaces_2nd_line() {
469	let input = r#" \| Col1a \| Col2a \|
470	\| ----- \| ----- \|
471	\| Col1b \| Col2b \|"#;
472	let output = r#"<p>\| Col1a \| Col2a \|
473	\| ----- \| ----- \|
474	\| Col1b \| Col2b \|</p>"#;
475	run(input, output);
476	}
477
478	#[test]
479	fn tables_should_not_be_indented_more_than_4_spaces_3rd_line() {
480	let input = r#" \| Col1a \| Col2a \|
481	\| ----- \| ----- \|
482	\| Col1b \| Col2b \|"#;
483	let output = r#"<table>
484	<thead>
485	<tr>
486	<th>Col1a</th>
487	<th>Col2a</th>
488	</tr>
489	</thead>
490	</table>
491	<pre><code>\| Col1b \| Col2b \|
492	</code></pre>"#;
493	run(input, output);
494	}
495
496	#[test]
497	fn allow_tables_with_empty_body() {
498	let input = r#" \| Col1a \| Col2a \|
499	\| ----- \| ----- \|"#;
500	let output = r#"<table>
501	<thead>
502	<tr>
503	<th>Col1a</th>
504	<th>Col2a</th>
505	</tr>
506	</thead>
507	</table>"#;
508	run(input, output);
509	}
510
511	#[test]
512	fn align_row_should_be_at_least_as_large_as_any_actual_rows() {
513	let input = r#"Col1a \| Col1b \| Col1c
514	----- \| -----
515	Col2a \| Col2b \| Col2c"#;
516	let output = r#"<p>Col1a \| Col1b \| Col1c
517	----- \| -----
518	Col2a \| Col2b \| Col2c</p>"#;
519	run(input, output);
520	}
521
522	#[test]
523	fn escaped_pipes_inside_backticks_don_t_split_cells() {
524	let input = r#"\| Heading 1 \| Heading 2
525	\| --------- \| ---------
526	\| Cell 1 \| Cell 2
527	\| `Cell 3\\|` \| Cell 4"#;
528	let output = r#"<table>
529	<thead>
530	<tr>
531	<th>Heading 1</th>
532	<th>Heading 2</th>
533	</tr>
534	</thead>
535	<tbody>
536	<tr>
537	<td>Cell 1</td>
538	<td>Cell 2</td>
539	</tr>
540	<tr>
541	<td><code>Cell 3\|</code></td>
542	<td>Cell 4</td>
543	</tr>
544	</tbody>
545	</table>"#;
546	run(input, output);
547	}
548
549	#[test]
550	fn escape_before_escaped_pipes_inside_backticks_don_t_split_cells() {
551	let input = r#"\| Heading 1 \| Heading 2
552	\| --------- \| ---------
553	\| Cell 1 \| Cell 2
554	\| `Cell 3\\\|` \| Cell 4"#;
555	let output = r#"<table>
556	<thead>
557	<tr>
558	<th>Heading 1</th>
559	<th>Heading 2</th>
560	</tr>
561	</thead>
562	<tbody>
563	<tr>
564	<td>Cell 1</td>
565	<td>Cell 2</td>
566	</tr>
567	<tr>
568	<td><code>Cell 3\\|</code></td>
569	<td>Cell 4</td>
570	</tr>
571	</tbody>
572	</table>"#;
573	run(input, output);
574	}
575
576	#[test]
577	fn regression_test_for_721_table_in_a_list_indented_with_tabs() {
578	let input = "- Level 1
579
580	\t- Level 2
581
582	\t\t\| Column 1 \| Column 2 \|
583	\t\t\| -------- \| -------- \|
584	\t\t\| abcdefgh \| ijklmnop \|";
585	let output = r#"<ul>
586	<li>
587	<p>Level 1</p>
588	<ul>
589	<li>
590	<p>Level 2</p>
591	<table>
592	<thead>
593	<tr>
594	<th>Column 1</th>
595	<th>Column 2</th>
596	</tr>
597	</thead>
598	<tbody>
599	<tr>
600	<td>abcdefgh</td>
601	<td>ijklmnop</td>
602	</tr>
603	</tbody>
604	</table>
605	</li>
606	</ul>
607	</li>
608	</ul>"#;
609	run(input, output);
610	}
611
612	#[test]
613	fn table_without_any_columns_is_not_a_table_724() {
614	let input = r#"\|
615	\|
616	\|"#;
617	let output = r#"<p>\|
618	\|
619	\|</p>"#;
620	run(input, output);
621	}
622
623	#[test]
624	fn gfm_4_10_tables_extension_example_198() {
625	let input = r#"\| foo \| bar \|
626	\| --- \| --- \|
627	\| baz \| bim \|"#;
628	let output = r#"<table>
629	<thead>
630	<tr>
631	<th>foo</th>
632	<th>bar</th>
633	</tr>
634	</thead>
635	<tbody>
636	<tr>
637	<td>baz</td>
638	<td>bim</td>
639	</tr>
640	</tbody>
641	</table>"#;
642	run(input, output);
643	}
644
645	#[test]
646	fn gfm_4_10_tables_extension_example_199() {
647	let input = r#"\| abc \| defghi \|
648	:-: \| -----------:
649	bar \| baz"#;
650	let output = r#"<table>
651	<thead>
652	<tr>
653	<th style="text-align:center">abc</th>
654	<th style="text-align:right">defghi</th>
655	</tr>
656	</thead>
657	<tbody>
658	<tr>
659	<td style="text-align:center">bar</td>
660	<td style="text-align:right">baz</td>
661	</tr>
662	</tbody>
663	</table>"#;
664	run(input, output);
665	}
666
667	#[test]
668	fn gfm_4_10_tables_extension_example_200() {
669	let input = r#"\| f\\|oo \|
670	\| ------ \|
671	\| b `\\|` az \|
672	\| b \\| im \|"#;
673	let output = r#"<table>
674	<thead>
675	<tr>
676	<th>f\|oo</th>
677	</tr>
678	</thead>
679	<tbody>
680	<tr>
681	<td>b <code>\|</code> az</td>
682	</tr>
683	<tr>
684	<td>b <strong>\|</strong> im</td>
685	</tr>
686	</tbody>
687	</table>"#;
688	run(input, output);
689	}
690
691	#[test]
692	fn gfm_4_10_tables_extension_example_201() {
693	let input = r#"\| abc \| def \|
694	\| --- \| --- \|
695	\| bar \| baz \|
696	> bar"#;
697	let output = r#"<table>
698	<thead>
699	<tr>
700	<th>abc</th>
701	<th>def</th>
702	</tr>
703	</thead>
704	<tbody>
705	<tr>
706	<td>bar</td>
707	<td>baz</td>
708	</tr>
709	</tbody>
710	</table>
711	<blockquote>
712	<p>bar</p>
713	</blockquote>"#;
714	run(input, output);
715	}
716
717	#[test]
718	fn gfm_4_10_tables_extension_example_202() {
719	let input = r#"\| abc \| def \|
720	\| --- \| --- \|
721	\| bar \| baz \|
722	bar
723
724	bar"#;
725	let output = r#"<table>
726	<thead>
727	<tr>
728	<th>abc</th>
729	<th>def</th>
730	</tr>
731	</thead>
732	<tbody>
733	<tr>
734	<td>bar</td>
735	<td>baz</td>
736	</tr>
737	<tr>
738	<td>bar</td>
739	<td></td>
740	</tr>
741	</tbody>
742	</table>
743	<p>bar</p>"#;
744	run(input, output);
745	}
746
747	#[test]
748	fn gfm_4_10_tables_extension_example_203() {
749	let input = r#"\| abc \| def \|
750	\| --- \|
751	\| bar \|"#;
752	let output = r#"<p>\| abc \| def \|
753	\| — \|
754	\| bar \|</p>"#;
755	run(input, output);
756	}
757
758	#[test]
759	fn gfm_4_10_tables_extension_example_204() {
760	let input = r#"\| abc \| def \|
761	\| --- \| --- \|
762	\| bar \|
763	\| bar \| baz \| boo \|"#;
764	let output = r#"<table>
765	<thead>
766	<tr>
767	<th>abc</th>
768	<th>def</th>
769	</tr>
770	</thead>
771	<tbody>
772	<tr>
773	<td>bar</td>
774	<td></td>
775	</tr>
776	<tr>
777	<td>bar</td>
778	<td>baz</td>
779	</tr>
780	</tbody>
781	</table>"#;
782	run(input, output);
783	}
784
785	#[test]
786	fn gfm_4_10_tables_extension_example_205() {
787	let input = r#"\| abc \| def \|
788	\| --- \| --- \|"#;
789	let output = r#"<table>
790	<thead>
791	<tr>
792	<th>abc</th>
793	<th>def</th>
794	</tr>
795	</thead>
796	</table>"#;
797	run(input, output);
798	}
799
800	#[test]
801	fn a_list_takes_precedence_in_case_of_ambiguity() {
802	let input = r#"a \| b
803	- \| -
804	1 \| 2"#;
805	let output = r#"<p>a \| b</p>
806	<ul>
807	<li>\| -
808	1 \| 2</li>
809	</ul>"#;
810	run(input, output);
811	}
812	// end of auto-generated module
813	}
814	///////////////////////////////////////////////////////////////////////////
815	// TESTGEN: fixtures/markdown-it/markdown-it-rs.txt
816	#[rustfmt::skip]
817	mod fixtures_markdown_it_markdown_it_rs_txt {
818	use super::run;
819	// this part of the file is auto-generated
820	// don't edit it, otherwise your changes might be lost
821	#[test]
822	fn regression_test_for_panic_in_40() {
823	let input = r#"![hello'"`world](x)\"#;
824	let output = r#"<p><img src="x" alt="hello'"`world">\</p>"#;
825	run(input, output);
826	}
827	// end of auto-generated module
828	}

crates/markdown-it/tests/pathological.rs created+140

...	@@ -0,0 +1,140 @@
1	// run it like this:
2	// cargo test --test pathological --jobs 1 -- --nocapture --test-threads=1
3	use markdown_it::MarkdownIt;
4	use once_cell::sync::Lazy;
5	use std::time::SystemTime;
6
7	static MD : Lazy<MarkdownIt> = Lazy::new(\|\| {
8	let mut parser = markdown_it::MarkdownIt::new();
9	markdown_it::plugins::cmark::add(&mut parser);
10	markdown_it::plugins::html::add(&mut parser);
11	markdown_it::plugins::extra::add(&mut parser);
12	parser
13	});
14
15	fn run(src: &str) {
16	let now = SystemTime::now();
17	MD.parse(src);
18	dbg!(now.elapsed().ok().unwrap());
19	}
20
21
22	mod commonmark {
23	// Ported from cmark, https://github.com/commonmark/cmark/blob/master/test/pathological_tests.py
24	use super::run;
25
26	#[test]
27	fn nested_inlines() {
28	run(&format!("{}{}{}", "".repeat(100000), "a", "".repeat(100000)));
29	}
30
31	#[test]
32	fn nested_strong_emph() {
33	// suspiciously slow
34	run(&format!("{}{}{}", "a a".repeat(5000), "b", " a* a*".repeat(5000)));
35	}
36
37	#[test]
38	fn many_emph_closers_with_no_openers() {
39	run(&"a_ ".repeat(100000));
40	}
41
42	#[test]
43	fn many_emph_openers_with_no_closers() {
44	run(&"_a ".repeat(100000));
45	}
46
47	#[test]
48	fn many_link_closers_with_no_openers() {
49	run(&"a]".repeat(100000));
50	}
51
52	#[test]
53	fn many_link_openers_with_no_closers() {
54	run(&"[a".repeat(50000));
55	}
56
57	#[test]
58	fn mismatched_openers_and_closers() {
59	// most probably a bug
60	run(&"*a_ ".repeat(50000));
61	}
62
63	#[test]
64	fn commonmark_cmark_389() {
65	run(&format!("{}{}", "a ".repeat(2000), "_a_ ".repeat(2000)));
66	}
67
68	#[test]
69	fn openers_and_closers_multiple_of_3() {
70	run(&format!("{}{}", "a*b", "c ".repeat(50000)));
71	}
72
73	#[test]
74	fn link_openers_and_emph_closers() {
75	run(&"[ a_".repeat(50000));
76	}
77
78	#[test]
79	fn link_pattern_repeated() {
80	run(&"[ (](".repeat(100000));
81	}
82
83	#[test]
84	fn nested_brackets() {
85	run(&format!("{}{}{}", "[".repeat(50000), "a", "]".repeat(50000)));
86	}
87
88	#[test]
89	fn nested_block_quotes() {
90	run(&format!("{}{}", "> ".repeat(50000), "a"));
91	}
92
93	#[test]
94	fn deeply_nested_lists() {
95	let src = (0..5000).map(\|x\| format!("{}{}", " ".repeat(x), "* a\n")).collect::<Vec<_>>().join("");
96	run(&src);
97	}
98
99	#[test]
100	fn backticks() {
101	let src = (0..1000).map(\|x\| format!("{}{}", "e", "`".repeat(x))).collect::<Vec<_>>().join("");
102	run(&src);
103	}
104
105	#[test]
106	fn unclosed_links_a() {
107	run(&"[a](<b".repeat(30000));
108	}
109
110	#[test]
111	fn unclosed_links_b() {
112	run(&"[a](b".repeat(30000));
113	}
114	}
115
116	mod markdownit {
117	// Ported from markdown-it.js
118	use super::run;
119
120	#[test]
121	fn emphasis_pattern() {
122	run(&"*_ ".repeat(5000));
123	}
124
125	#[test]
126	fn backtick_pattern() {
127	run(&"``\\".repeat(50000));
128	}
129
130	#[test]
131	fn autolinks_pattern() {
132	run(&format!("{}{}", "<".repeat(100000), ">"));
133	}
134
135	#[test]
136	fn hardbreak_whitespaces_pattern() {
137	run(&format!("{}{}{}", "x", " ".repeat(100000), "x \nx"));
138	}
139	}
140

crates/markdown-it/tests/sourcemaps.rs created+376

...	@@ -0,0 +1,376 @@
1	use markdown_it::Node;
2	use markdown_it::common::sourcemap::SourceWithLineStarts;
3
4	fn run(input: &str, f: fn (&Node, SourceWithLineStarts)) {
5	let md = &mut markdown_it::MarkdownIt::new();
6	markdown_it::plugins::cmark::add(md);
7	markdown_it::plugins::html::add(md);
8	let node = md.parse(input);
9	node.walk(\|node, _\| assert!(node.srcmap.is_some()));
10	f(&node, SourceWithLineStarts::new(input));
11	}
12
13	fn getmap(node: &Node, map: &SourceWithLineStarts) -> ((u32, u32), (u32, u32)) {
14	node.srcmap.unwrap().get_positions(map)
15	}
16
17	#[test]
18	fn paragraph() {
19	// same as commonmark.js
20	run("foo \n \n \n\n barbaz\n\tquux \n", \|node, map\| {
21	assert_eq!(
22	getmap(&node.children[0], &map),
23	((1, 1), (1, 6)),
24	);
25	assert_eq!(
26	getmap(&node.children[1], &map),
27	((5, 3), (6, 8)),
28	);
29	});
30	}
31
32	#[test]
33	fn hr() {
34	// same as commonmark.js
35	run(" --- \n\n * * *\n", \|node, map\| {
36	assert_eq!(
37	getmap(&node.children[0], &map),
38	((1, 2), (1, 6)),
39	);
40	assert_eq!(
41	getmap(&node.children[1], &map),
42	((3, 3), (3, 7)),
43	);
44	});
45	}
46
47	#[test]
48	fn heading() {
49	// same as commonmark.js
50	run(" \n ### foo ### \n\n", \|node, map\| {
51	assert_eq!(
52	getmap(&node.children[0], &map),
53	((2, 3), (2, 15)),
54	);
55	});
56
57	run(" #\n", \|node, map\| {
58	assert_eq!(
59	getmap(&node.children[0], &map),
60	((1, 3), (1, 3)),
61	);
62	});
63	}
64
65	#[test]
66	fn lheading() {
67	// same as commonmark.js
68	run(" foo\n bar\n ----\n\n", \|node, map\| {
69	assert_eq!(
70	getmap(&node.children[0], &map),
71	((1, 3), (3, 5)),
72	);
73	});
74	}
75
76	#[test]
77	fn fence() {
78	// same as commonmark.js
79	run(" ~~~ foo ~~~\n", \|node, map\| {
80	assert_eq!(
81	getmap(&node.children[0], &map),
82	((1, 3), (1, 13)),
83	);
84	});
85
86	run(" ```\n 12\n", \|node, map\| {
87	assert_eq!(
88	getmap(&node.children[0], &map),
89	((1, 3), (2, 3)),
90	);
91	});
92
93	run("```\n\n\n\n", \|node, map\| {
94	assert_eq!(
95	getmap(&node.children[0], &map),
96	((1, 1), (4, 0)),
97	);
98	});
99
100	run("~~~\na\nb\n~~~ \nc\n", \|node, map\| {
101	assert_eq!(
102	getmap(&node.children[0], &map),
103	((1, 1), (4, 5)),
104	);
105	});
106	}
107
108	#[test]
109	fn html_block() {
110	// same as commonmark.js
111	run(" <div>\n", \|node, map\| {
112	assert_eq!(
113	getmap(&node.children[0], &map),
114	((1, 3), (1, 7)),
115	);
116	});
117
118	run("<div>\n</div> \n", \|node, map\| {
119	assert_eq!(
120	getmap(&node.children[0], &map),
121	((1, 1), (2, 8)),
122	);
123	});
124	}
125
126	#[test]
127	fn code_block() {
128	// this should be (1, 5), (1, 9)
129	// for simplicity, we point source maps for block tags to first
130	// nonspace character, but it isn't quite correct for code blocks
131	run(" foo\n", \|node, map\| {
132	assert_eq!(
133	getmap(&node.children[0], &map),
134	((1, 7), (1, 9)),
135	);
136	});
137
138	run(" a\n b\n c\n", \|node, map\| {
139	assert_eq!(
140	getmap(&node.children[0], &map),
141	((1, 4), (3, 6)),
142	);
143	});
144
145	// this I believe to be error in commonmark, code block
146	// only have 1 line as per spec, but cmark reports 3 lines
147	run(" foobar \n \n \n\nbar\n", \|node, map\| {
148	assert_eq!(
149	getmap(&node.children[0], &map),
150	((1, 5), (1, 12)),
151	);
152	});
153	}
154
155	#[test]
156	fn blockquotes() {
157	// same as commonmark.js
158	run(" > foo \n", \|node, map\| {
159	assert_eq!(
160	getmap(&node.children[0], &map),
161	((1, 3), (1, 9)),
162	);
163	});
164
165	run("> foo\nbar\n\n", \|node, map\| {
166	assert_eq!(
167	getmap(&node.children[0], &map),
168	((1, 1), (2, 3)),
169	);
170	});
171	}
172
173	#[test]
174	fn lists() {
175	// same as commonmark.js
176	run(" 1. foo\n 2. bar\n", \|node, map\| {
177	assert_eq!(
178	getmap(&node.children[0], &map),
179	((1, 2), (2, 7)),
180	);
181
182	assert_eq!(
183	getmap(&node.children[0].children[0], &map),
184	((1, 2), (1, 7)),
185	);
186	});
187
188	run(" - foo\n\n - bar\n", \|node, map\| {
189	assert_eq!(
190	getmap(&node.children[0], &map),
191	((1, 2), (3, 6)),
192	);
193
194	assert_eq!(
195	getmap(&node.children[0].children[0], &map),
196	((1, 2), (2, 0)),
197	);
198
199	assert_eq!(
200	getmap(&node.children[0].children[1], &map),
201	((3, 2), (3, 6)),
202	);
203	});
204	}
205
206	#[test]
207	fn autolinks() {
208	run("foo <http://google.com> bar", \|node, map\| {
209	assert_eq!(
210	getmap(&node.children[0].children[1], &map),
211	((1, 5), (1, 23)),
212	);
213
214	assert_eq!(
215	getmap(&node.children[0].children[1].children[0], &map),
216	((1, 6), (1, 22)),
217	);
218	});
219	}
220
221	#[test]
222	fn emphasis() {
223	run("*foo*", \|node, map\| {
224	assert_eq!(
225	getmap(&node.children[0].children[0], &map),
226	((1, 1), (1, 9)),
227	);
228
229	assert_eq!(
230	getmap(&node.children[0].children[0].children[0], &map),
231	((1, 2), (1, 8)),
232	);
233	});
234
235	run("aaa bb _cc_ dd eee", \|node, map\| {
236	assert_eq!(
237	getmap(&node.children[0].children[1], &map),
238	((1, 5), (1, 18)),
239	);
240
241	assert_eq!(
242	getmap(&node.children[0].children[1].children[1], &map),
243	((1, 10), (1, 13)),
244	);
245	});
246	}
247
248	#[test]
249	fn newline() {
250	run("foo \nbar \nbaz\nquux", \|node, map\| {
251	assert_eq!(
252	getmap(&node.children[0].children[1], &map),
253	((1, 4), (2, 0)),
254	);
255
256	assert_eq!(
257	getmap(&node.children[0].children[3], &map),
258	((2, 4), (3, 0)),
259	);
260
261	assert_eq!(
262	getmap(&node.children[0].children[5], &map),
263	((4, 0), (4, 0)),
264	);
265
266	/*let marks : Vec<_> = node.children[0].children.iter().map(\|x\| getmap(x, &map)).collect();
267	assert_eq!(marks, [
268	((1, 1), (1, 5)),
269	((2, 0), (2, 1)),
270	((2, 1), (2, 3)),
271	((3, 0), (3, 0)),
272	((3, 1), (3, 3)),
273	]);*/
274	});
275	}
276
277	#[test]
278	fn escapes() {
279	run("foo\\Δ\\*bar", \|node, map\| {
280	assert_eq!(
281	getmap(&node.children[0].children[1], &map),
282	((1, 4), (1, 5)),
283	);
284
285	assert_eq!(
286	getmap(&node.children[0].children[2], &map),
287	((1, 6), (1, 7)),
288	);
289	});
290
291	run(" foo \\\n bar ", \|node, map\| {
292	assert_eq!(
293	getmap(&node.children[0].children[1], &map),
294	((1, 8), (2, 2)),
295	);
296	});
297	}
298
299	#[test]
300	fn entities() {
301	run("aa   bb cc", \|node, map\| {
302	assert_eq!(
303	getmap(&node.children[0].children[1], &map),
304	((1, 4), (1, 9)),
305	);
306
307	assert_eq!(
308	getmap(&node.children[0].children[3], &map),
309	((1, 14), (1, 18)),
310	);
311
312	/*let marks : Vec<_> = node.children[0].children.iter().map(\|x\| getmap(x, &map)).collect();
313	assert_eq!(marks, [
314	((1, 1), (1, 5)),
315	((2, 0), (2, 1)),
316	((2, 1), (2, 3)),
317	((3, 0), (3, 0)),
318	((3, 1), (3, 3)),
319	]);*/
320	});
321	}
322
323	#[test]
324	fn html_inline() {
325	run("foo <bar> baz", \|node, map\| {
326	assert_eq!(
327	getmap(&node.children[0].children[1], &map),
328	((1, 5), (1, 9)),
329	);
330	});
331	}
332
333	#[test]
334	fn backticks() {
335	run("foo ```bar``` baz", \|node, map\| {
336	assert_eq!(
337	getmap(&node.children[0].children[1], &map),
338	((1, 5), (1, 13)),
339	);
340
341	assert_eq!(
342	getmap(&node.children[0].children[1].children[0], &map),
343	((1, 8), (1, 10)),
344	);
345	});
346
347	run("foo ` bar ` baz", \|node, map\| {
348	assert_eq!(
349	getmap(&node.children[0].children[1], &map),
350	((1, 5), (1, 11)),
351	);
352
353	assert_eq!(
354	getmap(&node.children[0].children[1].children[0], &map),
355	((1, 7), (1, 9)),
356	);
357	});
358	}
359
360	#[test]
361	fn imglink() {
362	run("foo [bar](baz) quux", \|node, map\| {
363	assert_eq!(
364	getmap(&node.children[0].children[1], &map),
365	((1, 5), (1, 14)),
366	);
367	});
368
369	run("foo ![bar](baz) quux", \|node, map\| {
370	assert_eq!(
371	getmap(&node.children[0].children[1], &map),
372	((1, 5), (1, 15)),
373	);
374	});
375	}
376

src/lib.rs+14

...	@@ -1099,6 +1099,20 @@ mod tests {	...	@@ -1099,6 +1099,20 @@ mod tests {
1099	);	1099	);
1100	}	1100	}
1101		1101
		1102	// Regression: EmphPairScanner panicked (subtract-with-overflow) when an
		1103	// emphasis span crossed multiple blockquote continuation lines because
		1104	// `token_len` was derived from srcmap file-byte offsets (inclusive of
		1105	// stripped `> ` bytes) instead of inline-text offsets.
		1106	#[test]
		1107	fn multiline_blockquote_emphasis_does_not_panic() {
		1108	let src = "> *bottom row left: the past like 4 times i've gone with akira to that\n\
		1109	> pizza place, besides last time in december, they've always seated us at that\n\
		1110	> exact same table. it's really cute.*";
		1111	let out = run(src);
		1112	assert!(out.contains("<em>"), "emphasis must be rendered");
		1113	assert!(out.contains("<blockquote>"), "blockquote must be rendered");
		1114	}
		1115
1102	// -------------------------------------------------------------------------	1116	// -------------------------------------------------------------------------
1103	// componentImports takes precedence over layout for the same element type	1117	// componentImports takes precedence over layout for the same element type
1104	// -------------------------------------------------------------------------	1118	// -------------------------------------------------------------------------