@openclaw/matrix 2026.7.2-beta.7 → 2026.7.34

package/node_modules/markdown-it/dist/{index.cjs.js → markdown-it.mjs}

@@ -1,10 +1,11 @@
+/*! markdown-it 15.0.2 https://github.com/markdown-it/markdown-it @license MIT */
+import * as mdurl from "mdurl";
+import * as ucmicro from "uc.micro";
+import { decodeHTMLStrict } from "entities";
+import { LinkifyIt } from "linkify-it";
+import punycode from "punycode.js";
 //#region \0rolldown/runtime.js
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -14,44 +15,24 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
 //#endregion
-let mdurl = require("mdurl");
-mdurl = __toESM(mdurl, 1);
-let uc_micro = require("uc.micro");
-uc_micro = __toESM(uc_micro, 1);
-let entities = require("entities");
-let linkify_it = require("linkify-it");
-linkify_it = __toESM(linkify_it, 1);
-let punycode_js = require("punycode.js");
-punycode_js = __toESM(punycode_js, 1);
-//#region lib/common/utils.mjs
+//#region src/common/utils.ts
+/**
+* Common utility functions exposed through `md.utils` for use by plugins.
+*
+* @module md.utils
+*/
 var utils_exports = /* @__PURE__ */ __exportAll({
 	arrayReplaceAt: () => arrayReplaceAt,
 	asciiTrim: () => asciiTrim,
-	assign: () => assign,
+	callable: () => callable,
 	escapeHtml: () => escapeHtml,
 	escapeRE: () => escapeRE,
 	fromCodePoint: () => fromCodePoint,
-	has: () => has,
 	isMdAsciiPunct: () => isMdAsciiPunct,
 	isPunctChar: () => isPunctChar,
 	isPunctCharCode: () => isPunctCharCode,
 	isSpace: () => isSpace,
-	isString: () => isString,
 	isValidEntityCode: () => isValidEntityCode,
 	isWhiteSpace: () => isWhiteSpace,
 	lib: () => lib,
@@ -59,29 +40,24 @@ var utils_exports = /* @__PURE__ */ __exportAll({
 	unescapeAll: () => unescapeAll,
 	unescapeMd: () => unescapeMd
 });
-function _class(obj) {
-	return Object.prototype.toString.call(obj);
-}
-function isString(obj) {
-	return _class(obj) === "[object String]";
-}
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-function has(object, key) {
-	return _hasOwnProperty.call(object, key);
-}
-function assign(obj) {
-	Array.prototype.slice.call(arguments, 1).forEach(function(source) {
-		if (!source) return;
-		if (typeof source !== "object") throw new TypeError(source + "must be object");
-		Object.keys(source).forEach(function(key) {
-			obj[key] = source[key];
-		});
-	});
-	return obj;
+function callable(cls) {
+	const wrapper = function(...args) {
+		return Reflect.construct(cls, args, new.target && new.target !== wrapper ? new.target : cls);
+	};
+	Object.defineProperty(wrapper, "name", { value: cls.name });
+	Object.setPrototypeOf(wrapper, cls);
+	wrapper.prototype = cls.prototype;
+	return wrapper;
 }
+/**
+* Returns a copy of a token array with the token at `pos` replaced by
+* `newElements`. Used to transform token streams without modifying the
+* original array.
+*/
 function arrayReplaceAt(src, pos, newElements) {
 	return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
 }
+/** Checks whether a code point can be decoded from a numeric HTML entity. */
 function isValidEntityCode(c) {
 	if (c >= 55296 && c <= 57343) return false;
 	if (c >= 64976 && c <= 65007) return false;
@@ -93,6 +69,10 @@ function isValidEntityCode(c) {
 	if (c > 1114111) return false;
 	return true;
 }
+/**
+* Converts a Unicode code point to a string, like `String.fromCodePoint()`,
+* but does not throw for invalid input.
+*/
 function fromCodePoint(c) {
 	if (c > 65535) {
 		c -= 65536;
@@ -103,7 +83,7 @@ function fromCodePoint(c) {
 	return String.fromCharCode(c);
 }
 var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
-var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + "|" + /&([a-z#][a-z0-9]{1,31});/gi.source, "gi");
+var UNESCAPE_ALL_RE = new RegExp(`${UNESCAPE_MD_RE.source}|${/&([a-z#][a-z0-9]{1,31});/gi.source}`, "gi");
 var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
 function replaceEntityPattern(match, name) {
 	if (name.charCodeAt(0) === 35 && DIGITAL_ENTITY_TEST_RE.test(name)) {
@@ -111,14 +91,19 @@ function replaceEntityPattern(match, name) {
 		if (isValidEntityCode(code)) return fromCodePoint(code);
 		return match;
 	}
-	const decoded = (0, entities.decodeHTML)(match);
+	const decoded = decodeHTMLStrict(match);
 	if (decoded !== match) return decoded;
 	return match;
 }
+/** Decodes Markdown backslash escapes. */
 function unescapeMd(str) {
 	if (str.indexOf("\\") < 0) return str;
 	return str.replace(UNESCAPE_MD_RE, "$1");
 }
+/**
+* Decodes Markdown backslash escapes and HTML character references in link
+* destinations, link titles, and fenced code info strings.
+*/
 function unescapeAll(str) {
 	if (str.indexOf("\\") < 0 && str.indexOf("&") < 0) return str;
 	return str.replace(UNESCAPE_ALL_RE, function(match, escaped, entity) {
@@ -137,14 +122,17 @@ var HTML_REPLACEMENTS = {
 function replaceUnsafeChar(ch) {
 	return HTML_REPLACEMENTS[ch];
 }
+/** Escapes HTML special characters in a string. */
 function escapeHtml(str) {
 	if (HTML_ESCAPE_TEST_RE.test(str)) return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
 	return str;
 }
 var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
+/** Escapes regular expression metacharacters in a string. */
 function escapeRE(str) {
 	return str.replace(REGEXP_ESCAPE_RE, "\\$&");
 }
+/** Checks whether a character code is an ASCII space or tab. */
 function isSpace(code) {
 	switch (code) {
 		case 9:
@@ -152,6 +140,11 @@ function isSpace(code) {
 	}
 	return false;
 }
+/**
+* Checks whether a character code is whitespace recognized by Markdown.
+*
+* Matches the Unicode `Zs` category or `\t`, `\f`, `\v`, `\r`, `\n`.
+*/
 function isWhiteSpace(code) {
 	if (code >= 8192 && code <= 8202) return true;
 	switch (code) {
@@ -169,12 +162,29 @@ function isWhiteSpace(code) {
 	}
 	return false;
 }
+/**
+* Checks whether a character is Unicode punctuation or a symbol.
+*
+* Does not support astral characters.
+*/
 function isPunctChar(ch) {
-	return uc_micro.P.test(ch) || uc_micro.S.test(ch);
+	return ucmicro.P.test(ch) || ucmicro.S.test(ch);
 }
+/** Checks whether a Unicode code point is punctuation or a symbol. */
 function isPunctCharCode(code) {
 	return isPunctChar(fromCodePoint(code));
 }
+/**
+* Markdown ASCII punctuation characters.
+*
+*     !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @,
+*     [, \, ], ^, _, `, {, |, }, or ~
+*
+* http://spec.commonmark.org/0.15/#ascii-punctuation-character
+*
+* Don't confuse with Unicode punctuation. It lacks some characters in the
+* ASCII range.
+*/
 function isMdAsciiPunct(ch) {
 	switch (ch) {
 		case 33:
@@ -212,16 +222,18 @@ function isMdAsciiPunct(ch) {
 		default: return false;
 	}
 }
+/** Normalizes `[reference labels]` for case-insensitive lookup. */
 function normalizeReference(str) {
 	str = str.trim().replace(/\s+/g, " ");
-	if ("ẞ".toLowerCase() === "Ṿ")
- /* c8 ignore next 2 */
-	str = str.replace(/ẞ/g, "ß");
 	return str.toLowerCase().toUpperCase();
 }
 function isAsciiTrimmable(c) {
 	return c === 32 || c === 9 || c === 10 || c === 13;
 }
+/**
+* "Light" `.trim()` for blocks (headings, paragraphs), where Unicode spaces
+* should be preserved.
+*/
 function asciiTrim(str) {
 	let start = 0;
 	for (; start < str.length; start++) if (!isAsciiTrimmable(str.charCodeAt(start))) break;
@@ -229,12 +241,17 @@ function asciiTrim(str) {
 	for (; end >= start; end--) if (!isAsciiTrimmable(str.charCodeAt(end))) break;
 	return str.slice(start, end + 1);
 }
+/**
+* Libraries commonly used by markdown-it and its plugins, re-exported to
+* reduce duplicate dependencies in browser bundles.
+*/
 var lib = {
 	mdurl,
-	ucmicro: uc_micro
+	ucmicro
 };
 //#endregion
-//#region lib/helpers/parse_link_label.mjs
+//#region src/helpers/parse_link_label.ts
+/** Finds the end of a link or image label (`[label]`). */
 function parseLinkLabel(state, start, disableNested) {
 	let level, found, marker, prevPos;
 	const max = state.posMax;
@@ -266,7 +283,8 @@ function parseLinkLabel(state, start, disableNested) {
 	return labelEnd;
 }
 //#endregion
-//#region lib/helpers/parse_link_destination.mjs
+//#region src/helpers/parse_link_destination.ts
+/** Parses the destination in `[label](destination "title")`. */
 function parseLinkDestination(str, start, max) {
 	let code;
 	let pos = start;
@@ -301,7 +319,10 @@ function parseLinkDestination(str, start, max) {
 		if (code === 32) break;
 		if (code < 32 || code === 127) break;
 		if (code === 92 && pos + 1 < max) {
-			if (str.charCodeAt(pos + 1) === 32) break;
+			if (str.charCodeAt(pos + 1) === 32) {
+				pos++;
+				continue;
+			}
 			pos += 2;
 			continue;
 		}
@@ -323,7 +344,13 @@ function parseLinkDestination(str, start, max) {
 	return result;
 }
 //#endregion
-//#region lib/helpers/parse_link_title.mjs
+//#region src/helpers/parse_link_title.ts
+/**
+* Parses the optional title in `[label](destination "title")` or
+* `[label]: destination "title"`.
+*
+* `prev_state` continues a reference title on the next source line.
+*/
 function parseLinkTitle(str, start, max, prev_state) {
 	let code;
 	let pos = start;
@@ -362,29 +389,418 @@ function parseLinkTitle(str, start, max, prev_state) {
 	return state;
 }
 //#endregion
-//#region lib/helpers/index.mjs
+//#region src/helpers/index.ts
+/**
+* Functions used to parse links and images, split out of parser rules because
+* of their size.
+*
+* @module md.helpers
+*/
 var helpers_exports = /* @__PURE__ */ __exportAll({
 	parseLinkDestination: () => parseLinkDestination,
 	parseLinkLabel: () => parseLinkLabel,
 	parseLinkTitle: () => parseLinkTitle
 });
 //#endregion
-//#region lib/renderer.mjs
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/token.ts
 /**
-* class Renderer
+* Represents one item in the parsed token stream, storing parsed data and
+* providing helpers for managing HTML attributes.
+*/
+var Token = class {
+	constructor(type, tag, nesting) {
+		_defineProperty(
+			this,
+			/**
+			* Source map info. Format: `[ line_begin, line_end ]`
+			*/
+			"map",
+			null
+		);
+		_defineProperty(
+			this,
+			/**
+			* nesting level, the same as `state.level`
+			*/
+			"level",
+			0
+		);
+		_defineProperty(
+			this,
+			/**
+			* An array of child nodes (inline and img tokens)
+			*/
+			"children",
+			null
+		);
+		_defineProperty(
+			this,
+			/**
+			* In a case of self-closing tag (code, html, fence, etc.),
+			* it has contents of this tag.
+			*/
+			"content",
+			""
+		);
+		_defineProperty(
+			this,
+			/**
+			* '*' or '_' for emphasis, fence string for fence, etc.
+			*/
+			"markup",
+			""
+		);
+		_defineProperty(
+			this,
+			/**
+			* Additional information:
+			*
+			* - Info string for "fence" tokens
+			* - The value "auto" for autolink "link_open" and "link_close" tokens
+			* - The string value of the item marker for ordered-list "list_item_open" tokens
+			*/
+			"info",
+			""
+		);
+		_defineProperty(
+			this,
+			/**
+			* True for block-level tokens, false for inline tokens.
+			* Used in renderer to calculate line breaks
+			*/
+			"block",
+			false
+		);
+		_defineProperty(
+			this,
+			/**
+			* If it's true, ignore this element when rendering. Used for tight lists
+			* to hide paragraphs.
+			*/
+			"hidden",
+			false
+		);
+		this.type = type;
+		this.tag = tag;
+		this.attrs = null;
+		this.nesting = nesting;
+		this.meta = null;
+	}
+	/**
+	* Search attribute index by name.
+	*/
+	attrIndex(name) {
+		if (!this.attrs) return -1;
+		const attrs = this.attrs;
+		for (let i = 0, len = attrs.length; i < len; i++) if (attrs[i][0] === name) return i;
+		return -1;
+	}
+	/**
+	* Add `[ name, value ]` attribute to list. Init attrs if necessary
+	*/
+	attrPush(attrData) {
+		if (this.attrs) this.attrs.push(attrData);
+		else this.attrs = [attrData];
+	}
+	/**
+	* Set `name` attribute to `value`. Override old value if exists.
+	*/
+	attrSet(name, value) {
+		const idx = this.attrIndex(name);
+		const attrData = [name, value];
+		if (idx < 0) this.attrPush(attrData);
+		else this.attrs[idx] = attrData;
+	}
+	/**
+	* Get the value of attribute `name`, or null if it does not exist.
+	*/
+	attrGet(name) {
+		const idx = this.attrIndex(name);
+		let value = null;
+		if (idx >= 0) value = this.attrs[idx][1];
+		return value;
+	}
+	/**
+	* Join value to existing attribute via space. Or create new attribute if not
+	* exists. Useful to operate with token classes.
+	*/
+	attrJoin(name, value) {
+		const idx = this.attrIndex(name);
+		if (idx < 0) this.attrPush([name, value]);
+		else this.attrs[idx][1] = `${this.attrs[idx][1]} ${value}`;
+	}
+};
+//#endregion
+//#region src/ruler.ts
+/**
+* Helper class, used by {@link MarkdownIt.core}, {@link MarkdownIt.block} and
+* {@link MarkdownIt.inline} to manage sequences of functions (rules):
 *
-* Generates HTML from parsed token stream. Each instance has independent
-* copy of rules. Those can be rewritten with ease. Also, you can add new
-* rules if you create plugin and adds new token types.
-**/
+* - keep rules in defined order
+* - assign the name to each rule
+* - enable/disable rules
+* - add/replace rules
+* - allow assign rules to additional named chains (in the same)
+* - cacheing lists of active rules
+*
+* You will not need use this class directly until write plugins. For simple
+* rules control use {@link MarkdownIt.disable}, {@link MarkdownIt.enable} and
+* {@link MarkdownIt.use}.
+*/
+var Ruler = class {
+	constructor() {
+		_defineProperty(
+			this,
+			/** @internal */
+			"__rules__",
+			[]
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__cache__",
+			null
+		);
+	}
+	/** @internal */
+	__find__(name) {
+		for (let i = 0; i < this.__rules__.length; i++) if (this.__rules__[i].name === name) return i;
+		return -1;
+	}
+	/** @internal */
+	__compile__() {
+		const chains = /* @__PURE__ */ new Set();
+		this.__rules__.forEach((rule) => {
+			if (!rule.enabled) return;
+			rule.alt.forEach((altName) => {
+				if (altName) chains.add(altName);
+			});
+		});
+		this.__cache__ = Object.create(null);
+		this.__cache__[""] = [];
+		this.__rules__.forEach((rule) => {
+			if (rule.enabled) this.__cache__[""].push(rule.fn);
+		});
+		chains.forEach((chain) => {
+			this.__cache__[chain] = [];
+			this.__rules__.forEach((rule) => {
+				if (rule.enabled && rule.alt.indexOf(chain) >= 0) this.__cache__[chain].push(rule.fn);
+			});
+		});
+	}
+	/**
+	* Replace rule by name with new function & options. Throws error if name not
+	* found.
+	*
+	* @example Replace existing typographer replacement rule with new one
+	* ```javascript
+	* import MarkdownIt from 'markdown-it'
+	* const md = new MarkdownIt()
+	*
+	* md.core.ruler.at('replacements', function replace(state) {
+	*   //...
+	* });
+	* ```
+	*/
+	at(name, fn, options = {}) {
+		const index = this.__find__(name);
+		if (index === -1) throw new Error(`Parser rule not found: ${name}`);
+		this.__rules__[index].fn = fn;
+		this.__rules__[index].alt = options.alt || [];
+		this.__cache__ = null;
+	}
+	/**
+	* Add new rule to chain before one with given name. See also
+	* {@link Ruler.after}, {@link Ruler.push}.
+	*
+	* @example
+	* ```javascript
+	* import MarkdownIt from 'markdown-it'
+	* const md = new MarkdownIt()
+	*
+	* md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
+	*   //...
+	* });
+	* ```
+	*/
+	before(beforeName, ruleName, fn, options = {}) {
+		const index = this.__find__(beforeName);
+		if (index === -1) throw new Error(`Parser rule not found: ${beforeName}`);
+		this.__rules__.splice(index, 0, {
+			name: ruleName,
+			enabled: true,
+			fn,
+			alt: options.alt || []
+		});
+		this.__cache__ = null;
+	}
+	/**
+	* Add new rule to chain after one with given name. See also
+	* {@link Ruler.before}, {@link Ruler.push}.
+	*
+	* @example
+	* ```javascript
+	* import MarkdownIt from 'markdown-it'
+	* const md = new MarkdownIt()
+	*
+	* md.inline.ruler.after('text', 'my_rule', function replace(state) {
+	*   //...
+	* });
+	* ```
+	*/
+	after(afterName, ruleName, fn, options = {}) {
+		const index = this.__find__(afterName);
+		if (index === -1) throw new Error(`Parser rule not found: ${afterName}`);
+		this.__rules__.splice(index + 1, 0, {
+			name: ruleName,
+			enabled: true,
+			fn,
+			alt: options.alt || []
+		});
+		this.__cache__ = null;
+	}
+	/**
+	* Push new rule to the end of chain. See also
+	* {@link Ruler.before}, {@link Ruler.after}.
+	*
+	* @example
+	* ```javascript
+	* import MarkdownIt from 'markdown-it'
+	* const md = new MarkdownIt()
+	*
+	* md.core.ruler.push('my_rule', function replace(state) {
+	*   //...
+	* });
+	* ```
+	*/
+	push(ruleName, fn, options = {}) {
+		this.__rules__.push({
+			name: ruleName,
+			enabled: true,
+			fn,
+			alt: options.alt || []
+		});
+		this.__cache__ = null;
+	}
+	/**
+	* Enable rules with given names. If any rule name not found - throw Error.
+	* Errors can be disabled by second param.
+	*
+	* See also {@link Ruler.disable}, {@link Ruler.enableOnly}.
+	*
+	* Returns list of found rule names (if no exception happened).
+	*/
+	enable(list, ignoreInvalid = false) {
+		if (!Array.isArray(list)) list = [list];
+		const result = [];
+		list.forEach((name) => {
+			const idx = this.__find__(name);
+			if (idx < 0) {
+				if (ignoreInvalid) return;
+				throw new Error(`Rules manager: invalid rule name ${name}`);
+			}
+			this.__rules__[idx].enabled = true;
+			result.push(name);
+		});
+		this.__cache__ = null;
+		return result;
+	}
+	/**
+	* Enable rules with given names, and disable everything else. If any rule name
+	* not found - throw Error. Errors can be disabled by second param.
+	*
+	* See also {@link Ruler.disable}, {@link Ruler.enable}.
+	*/
+	enableOnly(list, ignoreInvalid = false) {
+		if (!Array.isArray(list)) list = [list];
+		this.__rules__.forEach((rule) => {
+			rule.enabled = false;
+		});
+		this.enable(list, ignoreInvalid);
+	}
+	/**
+	* Disable rules with given names. If any rule name not found - throw Error.
+	* Errors can be disabled by second param.
+	*
+	* See also {@link Ruler.enable}, {@link Ruler.enableOnly}.
+	*
+	* Returns list of found rule names (if no exception happened).
+	*/
+	disable(list, ignoreInvalid = false) {
+		if (!Array.isArray(list)) list = [list];
+		const result = [];
+		list.forEach((name) => {
+			const idx = this.__find__(name);
+			if (idx < 0) {
+				if (ignoreInvalid) return;
+				throw new Error(`Rules manager: invalid rule name ${name}`);
+			}
+			this.__rules__[idx].enabled = false;
+			result.push(name);
+		});
+		this.__cache__ = null;
+		return result;
+	}
+	/**
+	* Return array of active functions (rules) for given chain name. It analyzes
+	* rules configuration, compiles caches if not exists and returns result.
+	*
+	* Default chain name is `''` (empty string). It can't be skipped. That's
+	* done intentionally, to keep signature monomorphic for high speed.
+	*/
+	getRules(chainName) {
+		if (!this.__cache__) this.__compile__();
+		return this.__cache__[chainName] || [];
+	}
+};
+//#endregion
+//#region src/renderer.ts
 var default_rules = {};
 default_rules.code_inline = function(tokens, idx, options, env, slf) {
 	const token = tokens[idx];
-	return "<code" + slf.renderAttrs(token) + ">" + escapeHtml(token.content) + "</code>";
+	return `<code${slf.renderAttrs(token)}>${escapeHtml(token.content)}</code>`;
 };
 default_rules.code_block = function(tokens, idx, options, env, slf) {
 	const token = tokens[idx];
-	return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml(tokens[idx].content) + "</code></pre>\n";
+	return `<pre${slf.renderAttrs(token)}><code>${escapeHtml(tokens[idx].content)}</code></pre>\n`;
 };
 default_rules.fence = function(tokens, idx, options, env, slf) {
 	const token = tokens[idx];
@@ -403,10 +819,10 @@ default_rules.fence = function(tokens, idx, options, env, slf) {
 	if (info) {
 		const i = token.attrIndex("class");
 		const tmpAttrs = token.attrs ? token.attrs.slice() : [];
-		if (i < 0) tmpAttrs.push(["class", options.langPrefix + langName]);
+		if (i < 0) tmpAttrs.push(["class", `${options.langPrefix}${langName}`]);
 		else {
-			tmpAttrs[i] = tmpAttrs[i].slice();
-			tmpAttrs[i][1] += " " + options.langPrefix + langName;
+			tmpAttrs[i] = [tmpAttrs[i][0], tmpAttrs[i][1]];
+			tmpAttrs[i][1] += ` ${options.langPrefix}${langName}`;
 		}
 		const tmpToken = { attrs: tmpAttrs };
 		return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`;
@@ -434,600 +850,163 @@ default_rules.html_inline = function(tokens, idx) {
 	return tokens[idx].content;
 };
 /**
-* new Renderer()
+* Generates HTML from parsed token stream. Each instance has independent
+* copy of rules. Those can be rewritten with ease. Also, you can add new
+* rules if you create plugin and adds new token types.
 *
-* Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
-**/
-function Renderer() {
+* Creates new renderer instance and fills {@link Renderer.rules} with defaults.
+*/
+var Renderer = class {
+	constructor() {
+		_defineProperty(
+			this,
+			/**
+			* Contains render rules for tokens. Can be updated and extended.
+			*
+			* See [source code](https://github.com/markdown-it/markdown-it/blob/master/src/renderer.ts)
+			* for more details and examples.
+			*
+			* @example Custom render rules
+			* ```javascript
+			* import MarkdownIt from 'markdown-it'
+			* const md = new MarkdownIt()
+			*
+			* md.renderer.rules.strong_open  = function () { return '<b>'; };
+			* md.renderer.rules.strong_close = function () { return '</b>'; };
+			*
+			* const result = md.renderInline(...);
+			* ```
+			*
+			* @example Each rule is called as independent static function with fixed signature
+			* ```javascript
+			* function my_token_render(tokens, idx, options, env, renderer) {
+			*   // ...
+			*   return renderedHTML;
+			* }
+			* ```
+			*/
+			"rules",
+			Object.assign({}, default_rules)
+		);
+	}
 	/**
-	* Renderer#rules -> Object
-	*
-	* Contains render rules for tokens. Can be updated and extended.
-	*
-	* ##### Example
-	*
-	* ```javascript
-	* var md = require('markdown-it')();
-	*
-	* md.renderer.rules.strong_open  = function () { return '<b>'; };
-	* md.renderer.rules.strong_close = function () { return '</b>'; };
-	*
-	* var result = md.renderInline(...);
-	* ```
-	*
-	* Each rule is called as independent static function with fixed signature:
-	*
-	* ```javascript
-	* function my_token_render(tokens, idx, options, env, renderer) {
-	*   // ...
-	*   return renderedHTML;
-	* }
-	* ```
-	*
-	* See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)
-	* for more details and examples.
-	**/
-	this.rules = assign({}, default_rules);
-}
-/**
-* Renderer.renderAttrs(token) -> String
-*
-* Render token attributes to string.
-**/
-Renderer.prototype.renderAttrs = function renderAttrs(token) {
-	let i, l, result;
-	if (!token.attrs) return "";
-	result = "";
-	for (i = 0, l = token.attrs.length; i < l; i++) result += " " + escapeHtml(token.attrs[i][0]) + "=\"" + escapeHtml(token.attrs[i][1]) + "\"";
-	return result;
-};
-/**
-* Renderer.renderToken(tokens, idx, options) -> String
-* - tokens (Array): list of tokens
-* - idx (Numbed): token index to render
-* - options (Object): params of parser instance
-*
-* Default token renderer. Can be overriden by custom function
-* in [[Renderer#rules]].
-**/
-Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
-	const token = tokens[idx];
-	let result = "";
-	if (token.hidden) return "";
-	if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) result += "\n";
-	result += (token.nesting === -1 ? "</" : "<") + token.tag;
-	result += this.renderAttrs(token);
-	if (token.nesting === 0 && options.xhtmlOut) result += " /";
-	let needLf = false;
-	if (token.block) {
-		needLf = true;
-		if (token.nesting === 1) {
-			if (idx + 1 < tokens.length) {
-				const nextToken = tokens[idx + 1];
-				if (nextToken.type === "inline" || nextToken.hidden) needLf = false;
-				else if (nextToken.nesting === -1 && nextToken.tag === token.tag) needLf = false;
+	* Render token attributes to string.
+	*/
+	renderAttrs(token) {
+		let i, l, result;
+		if (!token.attrs) return "";
+		result = "";
+		for (i = 0, l = token.attrs.length; i < l; i++) result += ` ${escapeHtml(token.attrs[i][0])}="${escapeHtml(String(token.attrs[i][1]))}"`;
+		return result;
+	}
+	/**
+	* Default token renderer. Can be overriden by custom function
+	* in {@link Renderer.rules}.
+	*/
+	renderToken(tokens, idx, options) {
+		const token = tokens[idx];
+		let result = "";
+		if (token.hidden) return "";
+		let prev = idx - 1;
+		while (prev >= 0 && tokens[prev].hidden && tokens[prev].nesting === 0) prev--;
+		if (token.block && token.nesting !== -1 && prev >= 0 && tokens[prev].hidden && tokens[prev].nesting === -1) result += "\n";
+		result += (token.nesting === -1 ? "</" : "<") + token.tag;
+		result += this.renderAttrs(token);
+		if (token.nesting === 0 && options.xhtmlOut) result += " /";
+		let needLf = false;
+		if (token.block) {
+			needLf = true;
+			if (token.nesting === 1) {
+				let next = idx + 1;
+				while (next < tokens.length && tokens[next].hidden && tokens[next].nesting === 0) next++;
+				if (next < tokens.length) {
+					const nextToken = tokens[next];
+					if (nextToken.type === "inline" || nextToken.hidden) needLf = false;
+					else if (nextToken.nesting === -1 && nextToken.tag === token.tag) needLf = false;
+				}
 			}
 		}
+		result += needLf ? ">\n" : ">";
+		return result;
 	}
-	result += needLf ? ">\n" : ">";
-	return result;
-};
-/**
-* Renderer.renderInline(tokens, options, env) -> String
-* - tokens (Array): list on block tokens to render
-* - options (Object): params of parser instance
-* - env (Object): additional data from parsed input (references, for example)
-*
-* The same as [[Renderer.render]], but for single token of `inline` type.
-**/
-Renderer.prototype.renderInline = function(tokens, options, env) {
-	let result = "";
-	const rules = this.rules;
-	for (let i = 0, len = tokens.length; i < len; i++) {
-		const type = tokens[i].type;
-		if (typeof rules[type] !== "undefined") result += rules[type](tokens, i, options, env, this);
-		else result += this.renderToken(tokens, i, options);
-	}
-	return result;
-};
-/** internal
-* Renderer.renderInlineAsText(tokens, options, env) -> String
-* - tokens (Array): list on block tokens to render
-* - options (Object): params of parser instance
-* - env (Object): additional data from parsed input (references, for example)
-*
-* Special kludge for image `alt` attributes to conform CommonMark spec.
-* Don't try to use it! Spec requires to show `alt` content with stripped markup,
-* instead of simple escaping.
-**/
-Renderer.prototype.renderInlineAsText = function(tokens, options, env) {
-	let result = "";
-	for (let i = 0, len = tokens.length; i < len; i++) switch (tokens[i].type) {
-		case "text":
-			result += tokens[i].content;
-			break;
-		case "image":
-			result += this.renderInlineAsText(tokens[i].children, options, env);
-			break;
-		case "html_inline":
-		case "html_block":
-			result += tokens[i].content;
-			break;
-		case "softbreak":
-		case "hardbreak":
-			result += "\n";
-			break;
-		default:
-	}
-	return result;
-};
-/**
-* Renderer.render(tokens, options, env) -> String
-* - tokens (Array): list on block tokens to render
-* - options (Object): params of parser instance
-* - env (Object): additional data from parsed input (references, for example)
-*
-* Takes token stream and generates HTML. Probably, you will never need to call
-* this method directly.
-**/
-Renderer.prototype.render = function(tokens, options, env) {
-	let result = "";
-	const rules = this.rules;
-	for (let i = 0, len = tokens.length; i < len; i++) {
-		const type = tokens[i].type;
-		if (type === "inline") result += this.renderInline(tokens[i].children, options, env);
-		else if (typeof rules[type] !== "undefined") result += rules[type](tokens, i, options, env, this);
-		else result += this.renderToken(tokens, i, options, env);
-	}
-	return result;
-};
-//#endregion
-//#region lib/ruler.mjs
-/**
-* class Ruler
-*
-* Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
-* [[MarkdownIt#inline]] to manage sequences of functions (rules):
-*
-* - keep rules in defined order
-* - assign the name to each rule
-* - enable/disable rules
-* - add/replace rules
-* - allow assign rules to additional named chains (in the same)
-* - cacheing lists of active rules
-*
-* You will not need use this class directly until write plugins. For simple
-* rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
-* [[MarkdownIt.use]].
-**/
-/**
-* new Ruler()
-**/
-function Ruler() {
-	this.__rules__ = [];
-	this.__cache__ = null;
-}
-Ruler.prototype.__find__ = function(name) {
-	for (let i = 0; i < this.__rules__.length; i++) if (this.__rules__[i].name === name) return i;
-	return -1;
-};
-Ruler.prototype.__compile__ = function() {
-	const self = this;
-	const chains = [""];
-	self.__rules__.forEach(function(rule) {
-		if (!rule.enabled) return;
-		rule.alt.forEach(function(altName) {
-			if (chains.indexOf(altName) < 0) chains.push(altName);
-		});
-	});
-	self.__cache__ = {};
-	chains.forEach(function(chain) {
-		self.__cache__[chain] = [];
-		self.__rules__.forEach(function(rule) {
-			if (!rule.enabled) return;
-			if (chain && rule.alt.indexOf(chain) < 0) return;
-			self.__cache__[chain].push(rule.fn);
-		});
-	});
-};
-/**
-* Ruler.at(name, fn [, options])
-* - name (String): rule name to replace.
-* - fn (Function): new rule function.
-* - options (Object): new rule options (not mandatory).
-*
-* Replace rule by name with new function & options. Throws error if name not
-* found.
-*
-* ##### Options:
-*
-* - __alt__ - array with names of "alternate" chains.
-*
-* ##### Example
-*
-* Replace existing typographer replacement rule with new one:
-*
-* ```javascript
-* var md = require('markdown-it')();
-*
-* md.core.ruler.at('replacements', function replace(state) {
-*   //...
-* });
-* ```
-**/
-Ruler.prototype.at = function(name, fn, options) {
-	const index = this.__find__(name);
-	const opt = options || {};
-	if (index === -1) throw new Error("Parser rule not found: " + name);
-	this.__rules__[index].fn = fn;
-	this.__rules__[index].alt = opt.alt || [];
-	this.__cache__ = null;
-};
-/**
-* Ruler.before(beforeName, ruleName, fn [, options])
-* - beforeName (String): new rule will be added before this one.
-* - ruleName (String): name of added rule.
-* - fn (Function): rule function.
-* - options (Object): rule options (not mandatory).
-*
-* Add new rule to chain before one with given name. See also
-* [[Ruler.after]], [[Ruler.push]].
-*
-* ##### Options:
-*
-* - __alt__ - array with names of "alternate" chains.
-*
-* ##### Example
-*
-* ```javascript
-* var md = require('markdown-it')();
-*
-* md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
-*   //...
-* });
-* ```
-**/
-Ruler.prototype.before = function(beforeName, ruleName, fn, options) {
-	const index = this.__find__(beforeName);
-	const opt = options || {};
-	if (index === -1) throw new Error("Parser rule not found: " + beforeName);
-	this.__rules__.splice(index, 0, {
-		name: ruleName,
-		enabled: true,
-		fn,
-		alt: opt.alt || []
-	});
-	this.__cache__ = null;
-};
-/**
-* Ruler.after(afterName, ruleName, fn [, options])
-* - afterName (String): new rule will be added after this one.
-* - ruleName (String): name of added rule.
-* - fn (Function): rule function.
-* - options (Object): rule options (not mandatory).
-*
-* Add new rule to chain after one with given name. See also
-* [[Ruler.before]], [[Ruler.push]].
-*
-* ##### Options:
-*
-* - __alt__ - array with names of "alternate" chains.
-*
-* ##### Example
-*
-* ```javascript
-* var md = require('markdown-it')();
-*
-* md.inline.ruler.after('text', 'my_rule', function replace(state) {
-*   //...
-* });
-* ```
-**/
-Ruler.prototype.after = function(afterName, ruleName, fn, options) {
-	const index = this.__find__(afterName);
-	const opt = options || {};
-	if (index === -1) throw new Error("Parser rule not found: " + afterName);
-	this.__rules__.splice(index + 1, 0, {
-		name: ruleName,
-		enabled: true,
-		fn,
-		alt: opt.alt || []
-	});
-	this.__cache__ = null;
-};
-/**
-* Ruler.push(ruleName, fn [, options])
-* - ruleName (String): name of added rule.
-* - fn (Function): rule function.
-* - options (Object): rule options (not mandatory).
-*
-* Push new rule to the end of chain. See also
-* [[Ruler.before]], [[Ruler.after]].
-*
-* ##### Options:
-*
-* - __alt__ - array with names of "alternate" chains.
-*
-* ##### Example
-*
-* ```javascript
-* var md = require('markdown-it')();
-*
-* md.core.ruler.push('my_rule', function replace(state) {
-*   //...
-* });
-* ```
-**/
-Ruler.prototype.push = function(ruleName, fn, options) {
-	const opt = options || {};
-	this.__rules__.push({
-		name: ruleName,
-		enabled: true,
-		fn,
-		alt: opt.alt || []
-	});
-	this.__cache__ = null;
-};
-/**
-* Ruler.enable(list [, ignoreInvalid]) -> Array
-* - list (String|Array): list of rule names to enable.
-* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
-*
-* Enable rules with given names. If any rule name not found - throw Error.
-* Errors can be disabled by second param.
-*
-* Returns list of found rule names (if no exception happened).
-*
-* See also [[Ruler.disable]], [[Ruler.enableOnly]].
-**/
-Ruler.prototype.enable = function(list, ignoreInvalid) {
-	if (!Array.isArray(list)) list = [list];
-	const result = [];
-	list.forEach(function(name) {
-		const idx = this.__find__(name);
-		if (idx < 0) {
-			if (ignoreInvalid) return;
-			throw new Error("Rules manager: invalid rule name " + name);
-		}
-		this.__rules__[idx].enabled = true;
-		result.push(name);
-	}, this);
-	this.__cache__ = null;
-	return result;
-};
-/**
-* Ruler.enableOnly(list [, ignoreInvalid])
-* - list (String|Array): list of rule names to enable (whitelist).
-* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
-*
-* Enable rules with given names, and disable everything else. If any rule name
-* not found - throw Error. Errors can be disabled by second param.
-*
-* See also [[Ruler.disable]], [[Ruler.enable]].
-**/
-Ruler.prototype.enableOnly = function(list, ignoreInvalid) {
-	if (!Array.isArray(list)) list = [list];
-	this.__rules__.forEach(function(rule) {
-		rule.enabled = false;
-	});
-	this.enable(list, ignoreInvalid);
-};
-/**
-* Ruler.disable(list [, ignoreInvalid]) -> Array
-* - list (String|Array): list of rule names to disable.
-* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
-*
-* Disable rules with given names. If any rule name not found - throw Error.
-* Errors can be disabled by second param.
-*
-* Returns list of found rule names (if no exception happened).
-*
-* See also [[Ruler.enable]], [[Ruler.enableOnly]].
-**/
-Ruler.prototype.disable = function(list, ignoreInvalid) {
-	if (!Array.isArray(list)) list = [list];
-	const result = [];
-	list.forEach(function(name) {
-		const idx = this.__find__(name);
-		if (idx < 0) {
-			if (ignoreInvalid) return;
-			throw new Error("Rules manager: invalid rule name " + name);
-		}
-		this.__rules__[idx].enabled = false;
-		result.push(name);
-	}, this);
-	this.__cache__ = null;
-	return result;
-};
-/**
-* Ruler.getRules(chainName) -> Array
-*
-* Return array of active functions (rules) for given chain name. It analyzes
-* rules configuration, compiles caches if not exists and returns result.
-*
-* Default chain name is `''` (empty string). It can't be skipped. That's
-* done intentionally, to keep signature monomorphic for high speed.
-**/
-Ruler.prototype.getRules = function(chainName) {
-	if (this.__cache__ === null) this.__compile__();
-	return this.__cache__[chainName] || [];
-};
-//#endregion
-//#region lib/token.mjs
-/**
-* class Token
-**/
-/**
-* new Token(type, tag, nesting)
-*
-* Create new token and fill passed properties.
-**/
-function Token(type, tag, nesting) {
-	/**
-	* Token#type -> String
-	*
-	* Type of the token (string, e.g. "paragraph_open")
-	**/
-	this.type = type;
-	/**
-	* Token#tag -> String
-	*
-	* html tag name, e.g. "p"
-	**/
-	this.tag = tag;
-	/**
-	* Token#attrs -> Array
-	*
-	* Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
-	**/
-	this.attrs = null;
-	/**
-	* Token#map -> Array
-	*
-	* Source map info. Format: `[ line_begin, line_end ]`
-	**/
-	this.map = null;
-	/**
-	* Token#nesting -> Number
-	*
-	* Level change (number in {-1, 0, 1} set), where:
-	*
-	* -  `1` means the tag is opening
-	* -  `0` means the tag is self-closing
-	* - `-1` means the tag is closing
-	**/
-	this.nesting = nesting;
-	/**
-	* Token#level -> Number
-	*
-	* nesting level, the same as `state.level`
-	**/
-	this.level = 0;
-	/**
-	* Token#children -> Array
-	*
-	* An array of child nodes (inline and img tokens)
-	**/
-	this.children = null;
-	/**
-	* Token#content -> String
-	*
-	* In a case of self-closing tag (code, html, fence, etc.),
-	* it has contents of this tag.
-	**/
-	this.content = "";
-	/**
-	* Token#markup -> String
-	*
-	* '*' or '_' for emphasis, fence string for fence, etc.
-	**/
-	this.markup = "";
-	/**
-	* Token#info -> String
-	*
-	* Additional information:
-	*
-	* - Info string for "fence" tokens
-	* - The value "auto" for autolink "link_open" and "link_close" tokens
-	* - The string value of the item marker for ordered-list "list_item_open" tokens
-	**/
-	this.info = "";
-	/**
-	* Token#meta -> Object
-	*
-	* A place for plugins to store an arbitrary data
-	**/
-	this.meta = null;
 	/**
-	* Token#block -> Boolean
-	*
-	* True for block-level tokens, false for inline tokens.
-	* Used in renderer to calculate line breaks
-	**/
-	this.block = false;
-	/**
-	* Token#hidden -> Boolean
-	*
-	* If it's true, ignore this element when rendering. Used for tight lists
-	* to hide paragraphs.
-	**/
-	this.hidden = false;
-}
-/**
-* Token.attrIndex(name) -> Number
-*
-* Search attribute index by name.
-**/
-Token.prototype.attrIndex = function attrIndex(name) {
-	if (!this.attrs) return -1;
-	const attrs = this.attrs;
-	for (let i = 0, len = attrs.length; i < len; i++) if (attrs[i][0] === name) return i;
-	return -1;
-};
-/**
-* Token.attrPush(attrData)
-*
-* Add `[ name, value ]` attribute to list. Init attrs if necessary
-**/
-Token.prototype.attrPush = function attrPush(attrData) {
-	if (this.attrs) this.attrs.push(attrData);
-	else this.attrs = [attrData];
-};
-/**
-* Token.attrSet(name, value)
-*
-* Set `name` attribute to `value`. Override old value if exists.
-**/
-Token.prototype.attrSet = function attrSet(name, value) {
-	const idx = this.attrIndex(name);
-	const attrData = [name, value];
-	if (idx < 0) this.attrPush(attrData);
-	else this.attrs[idx] = attrData;
-};
-/**
-* Token.attrGet(name)
-*
-* Get the value of attribute `name`, or null if it does not exist.
-**/
-Token.prototype.attrGet = function attrGet(name) {
-	const idx = this.attrIndex(name);
-	let value = null;
-	if (idx >= 0) value = this.attrs[idx][1];
-	return value;
-};
-/**
-* Token.attrJoin(name, value)
-*
-* Join value to existing attribute via space. Or create new attribute if not
-* exists. Useful to operate with token classes.
-**/
-Token.prototype.attrJoin = function attrJoin(name, value) {
-	const idx = this.attrIndex(name);
-	if (idx < 0) this.attrPush([name, value]);
-	else this.attrs[idx][1] = this.attrs[idx][1] + " " + value;
+	* The same as {@link Renderer.render}, but for single token of `inline` type.
+	*/
+	renderInline(tokens, options, env) {
+		let result = "";
+		const rules = this.rules;
+		for (let i = 0, len = tokens.length; i < len; i++) {
+			const type = tokens[i].type;
+			if (typeof rules[type] !== "undefined") result += rules[type](tokens, i, options, env, this);
+			else result += this.renderToken(tokens, i, options);
+		}
+		return result;
+	}
+	/**
+	* Special kludge for image `alt` attributes to conform CommonMark spec.
+	* Don't try to use it! Spec requires to show `alt` content with stripped markup,
+	* instead of simple escaping.
+	*/
+	renderInlineAsText(tokens, options, env) {
+		let result = "";
+		for (let i = 0, len = tokens.length; i < len; i++) switch (tokens[i].type) {
+			case "text":
+			case "code_inline":
+				result += tokens[i].content;
+				break;
+			case "image":
+				result += this.renderInlineAsText(tokens[i].children, options, env);
+				break;
+			case "html_inline":
+			case "html_block":
+				result += tokens[i].content;
+				break;
+			case "softbreak":
+			case "hardbreak": result += "\n";
+		}
+		return result;
+	}
+	/**
+	* Takes token stream and generates HTML. Probably, you will never need to call
+	* this method directly.
+	*/
+	render(tokens, options, env) {
+		let result = "";
+		const rules = this.rules;
+		for (let i = 0, len = tokens.length; i < len; i++) {
+			const type = tokens[i].type;
+			if (type === "inline") result += this.renderInline(tokens[i].children, options, env);
+			else if (typeof rules[type] !== "undefined") result += rules[type](tokens, i, options, env, this);
+			else result += this.renderToken(tokens, i, options);
+		}
+		return result;
+	}
 };
 //#endregion
-//#region lib/rules_core/state_core.mjs
-function StateCore(src, md, env) {
-	this.src = src;
-	this.env = env;
-	this.tokens = [];
-	this.inlineMode = false;
-	this.md = md;
-}
-StateCore.prototype.Token = Token;
+//#region src/rules_core/state_core.ts
+/** Mutable state passed through the core rules chain. */
+var StateCore = class {
+	constructor(src, md, env) {
+		_defineProperty(this, "tokens", []);
+		_defineProperty(this, "inlineMode", false);
+		_defineProperty(this, "Token", Token);
+		this.src = src;
+		this.env = env;
+		this.md = md;
+	}
+};
 //#endregion
-//#region lib/rules_core/normalize.mjs
-var NEWLINES_RE = /\r\n?|\n/g;
+//#region src/rules_core/normalize.ts
+var UNNORMALIZED_NEWLINE_RE = /\r\n?/g;
 var NULL_RE = /\0/g;
 function normalize(state) {
 	let str;
-	str = state.src.replace(NEWLINES_RE, "\n");
+	str = state.src.replace(UNNORMALIZED_NEWLINE_RE, "\n");
 	str = str.replace(NULL_RE, "�");
 	state.src = str;
 }
 //#endregion
-//#region lib/rules_core/block.mjs
+//#region src/rules_core/block.ts
 function block(state) {
 	let token;
 	if (state.inlineMode) {
@@ -1039,7 +1018,19 @@ function block(state) {
 	} else state.md.block.parse(state.src, state.md, state.env, state.tokens);
 }
 //#endregion
-//#region lib/rules_core/inline.mjs
+//#region src/rules_core/strip_references.ts
+function strip_references(state) {
+	const tokens = state.tokens;
+	let last = 0;
+	for (let curr = 0; curr < tokens.length; curr++) {
+		if (tokens[curr].type === "reference_definition") continue;
+		if (curr !== last) tokens[last] = tokens[curr];
+		last++;
+	}
+	if (tokens.length !== last) tokens.length = last;
+}
+//#endregion
+//#region src/rules_core/inline.ts
 function inline(state) {
 	const tokens = state.tokens;
 	for (let i = 0, l = tokens.length; i < l; i++) {
@@ -1048,7 +1039,7 @@ function inline(state) {
 	}
 }
 //#endregion
-//#region lib/rules_core/linkify.mjs
+//#region src/rules_core/linkify.ts
 function isLinkOpen$1(str) {
 	return /^<a[>\s]/i.test(str);
 }
@@ -1059,8 +1050,9 @@ function linkify$1(state) {
 	const blockTokens = state.tokens;
 	if (!state.md.options.linkify) return;
 	for (let j = 0, l = blockTokens.length; j < l; j++) {
-		if (blockTokens[j].type !== "inline" || !state.md.linkify.pretest(blockTokens[j].content)) continue;
-		let tokens = blockTokens[j].children;
+		if (blockTokens[j].type !== "inline" || !state.md.linkify.test(blockTokens[j].content)) continue;
+		const tokens = blockTokens[j].children;
+		const replacements = [];
 		let htmlLinkLevel = 0;
 		for (let i = tokens.length - 1; i >= 0; i--) {
 			const currentToken = tokens[i];
@@ -1086,8 +1078,8 @@ function linkify$1(state) {
 					const fullUrl = state.md.normalizeLink(url);
 					if (!state.md.validateLink(fullUrl)) continue;
 					let urlText = links[ln].text;
-					if (!links[ln].schema) urlText = state.md.normalizeLinkText("http://" + urlText).replace(/^http:\/\//, "");
-					else if (links[ln].schema === "mailto:" && !/^mailto:/i.test(urlText)) urlText = state.md.normalizeLinkText("mailto:" + urlText).replace(/^mailto:/, "");
+					if (!links[ln].schema) urlText = state.md.normalizeLinkText(`http://${urlText}`).replace(/^http:\/\//, "");
+					else if (links[ln].schema === "mailto:" && !/^mailto:/i.test(urlText)) urlText = state.md.normalizeLinkText(`mailto:${urlText}`).replace(/^mailto:/, "");
 					else urlText = state.md.normalizeLinkText(urlText);
 					const pos = links[ln].index;
 					if (pos > lastPos) {
@@ -1119,13 +1111,32 @@ function linkify$1(state) {
 					token.level = level;
 					nodes.push(token);
 				}
-				blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
+				replacements.push({
+					index: i,
+					nodes
+				});
 			}
 		}
+		if (replacements.length > 0) {
+			let newTokensLength = tokens.length;
+			for (const replacement of replacements) newTokensLength += replacement.nodes.length - 1;
+			const newTokens = new Array(newTokensLength);
+			let replacementIndex = 0;
+			let newTokenIndex = 0;
+			replacements.reverse();
+			for (let i = 0; i < tokens.length; i++) {
+				const replacement = replacements[replacementIndex];
+				if ((replacement === null || replacement === void 0 ? void 0 : replacement.index) === i) {
+					for (const node of replacement.nodes) newTokens[newTokenIndex++] = node;
+					replacementIndex++;
+				} else newTokens[newTokenIndex++] = tokens[i];
+			}
+			blockTokens[j].children = newTokens;
+		}
 	}
 }
 //#endregion
-//#region lib/rules_core/replacements.mjs
+//#region src/rules_core/replacements.ts
 var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
 var SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i;
 var SCOPED_ABBR_RE = /\((c|tm|r)\)/gi;
@@ -1167,10 +1178,18 @@ function replace(state) {
 	}
 }
 //#endregion
-//#region lib/rules_core/smartquotes.mjs
+//#region src/rules_core/smartquotes.ts
 var QUOTE_TEST_RE = /['"]/;
 var QUOTE_RE = /['"]/g;
 var APOSTROPHE = "’";
+var MAX_OPENERS = 1e3;
+function truncateStack(stack, heads, length) {
+	while (stack.length > length) {
+		const item = stack.pop();
+		if (item.isSingleQuote) heads.single = item.prevSameQuoteIdx;
+		else heads.double = item.prevSameQuoteIdx;
+	}
+}
 function addReplacement(replacements, tokenIdx, pos, ch) {
 	if (!replacements[tokenIdx]) replacements[tokenIdx] = [];
 	replacements[tokenIdx].push({
@@ -1192,12 +1211,16 @@ function applyReplacements(str, replacements) {
 function process_inlines(tokens, state) {
 	let j;
 	const stack = [];
+	const heads = {
+		single: -1,
+		double: -1
+	};
 	const replacements = {};
 	for (let i = 0; i < tokens.length; i++) {
 		const token = tokens[i];
 		const thisLevel = tokens[i].level;
 		for (j = stack.length - 1; j >= 0; j--) if (stack[j].level <= thisLevel) break;
-		stack.length = j + 1;
+		truncateStack(stack, heads, j + 1);
 		if (token.type !== "text") continue;
 		const text = token.content;
 		let pos = 0;
@@ -1249,11 +1272,10 @@ function process_inlines(tokens, state) {
 				if (isSingle) addReplacement(replacements, i, t.index, APOSTROPHE);
 				continue;
 			}
-			if (canClose) for (j = stack.length - 1; j >= 0; j--) {
-				let item = stack[j];
-				if (stack[j].level < thisLevel) break;
-				if (item.single === isSingle && stack[j].level === thisLevel) {
-					item = stack[j];
+			if (canClose) {
+				j = isSingle ? heads.single : heads.double;
+				if (j >= 0 && stack[j].level === thisLevel) {
+					const item = stack[j];
 					let openQuote;
 					let closeQuote;
 					if (isSingle) {
@@ -1264,22 +1286,28 @@ function process_inlines(tokens, state) {
 						closeQuote = state.md.options.quotes[1];
 					}
 					addReplacement(replacements, i, t.index, closeQuote);
-					addReplacement(replacements, item.token, item.pos, openQuote);
-					stack.length = j;
+					addReplacement(replacements, item.tokenIdx, item.contentPos, openQuote);
+					truncateStack(stack, heads, j);
 					continue OUTER;
 				}
 			}
-			if (canOpen) stack.push({
-				token: i,
-				pos: t.index,
-				single: isSingle,
-				level: thisLevel
-			});
-			else if (canClose && isSingle) addReplacement(replacements, i, t.index, APOSTROPHE);
+			if (canOpen) {
+				if (stack.length >= MAX_OPENERS) return;
+				stack.push({
+					tokenIdx: i,
+					contentPos: t.index,
+					isSingleQuote: isSingle,
+					level: thisLevel,
+					prevSameQuoteIdx: isSingle ? heads.single : heads.double
+				});
+				if (isSingle) heads.single = stack.length - 1;
+				else heads.double = stack.length - 1;
+			} else if (canClose && isSingle) addReplacement(replacements, i, t.index, APOSTROPHE);
 		}
 	}
 	Object.keys(replacements).forEach(function(tokenIdx) {
-		tokens[tokenIdx].content = applyReplacements(tokens[tokenIdx].content, replacements[tokenIdx]);
+		const idx = Number(tokenIdx);
+		tokens[idx].content = applyReplacements(tokens[idx].content, replacements[tokenIdx]);
 	});
 }
 function smartquotes(state) {
@@ -1290,7 +1318,18 @@ function smartquotes(state) {
 	}
 }
 //#endregion
-//#region lib/rules_core/text_join.mjs
+//#region src/rules_core/text_join.ts
+function join_alt(tokens) {
+	let curr, last;
+	const max = tokens.length;
+	for (curr = 0; curr < max; curr++) if (tokens[curr].type === "text_special") tokens[curr].type = "text";
+	for (curr = last = 0; curr < max; curr++) if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
+	else {
+		if (curr !== last) tokens[last] = tokens[curr];
+		last++;
+	}
+	if (curr !== last) tokens.length = last;
+}
 function text_join(state) {
 	let curr, last;
 	const blockTokens = state.tokens;
@@ -1299,7 +1338,10 @@ function text_join(state) {
 		if (blockTokens[j].type !== "inline") continue;
 		const tokens = blockTokens[j].children;
 		const max = tokens.length;
-		for (curr = 0; curr < max; curr++) if (tokens[curr].type === "text_special") tokens[curr].type = "text";
+		for (curr = 0; curr < max; curr++) {
+			if (tokens[curr].type === "text_special") tokens[curr].type = "text";
+			if (tokens[curr].children) join_alt(tokens[curr].children);
+		}
 		for (curr = last = 0; curr < max; curr++) if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
 		else {
 			if (curr !== last) tokens[last] = tokens[curr];
@@ -1309,16 +1351,11 @@ function text_join(state) {
 	}
 }
 //#endregion
-//#region lib/parser_core.mjs
-/** internal
-* class Core
-*
-* Top-level rules executor. Glues block/inline parsers and does intermediate
-* transformations.
-**/
+//#region src/parser_core.ts
 var _rules$2 = [
 	["normalize", normalize],
 	["block", block],
+	["strip_references", strip_references],
 	["inline", inline],
 	["linkify", linkify$1],
 	["replacements", replace],
@@ -1326,136 +1363,141 @@ var _rules$2 = [
 	["text_join", text_join]
 ];
 /**
-* new Core()
-**/
-function Core() {
+* Top-level rules executor. Glues block/inline parsers and does intermediate
+* transformations.
+*/
+var ParserCore = class {
+	constructor() {
+		_defineProperty(
+			this,
+			/**
+			* {@link Ruler} instance. Keep configuration of core rules.
+			*/
+			"ruler",
+			new Ruler()
+		);
+		_defineProperty(this, "State", StateCore);
+		for (let i = 0; i < _rules$2.length; i++) this.ruler.push(_rules$2[i][0], _rules$2[i][1]);
+	}
 	/**
-	* Core#ruler -> Ruler
-	*
-	* [[Ruler]] instance. Keep configuration of core rules.
-	**/
-	this.ruler = new Ruler();
-	for (let i = 0; i < _rules$2.length; i++) this.ruler.push(_rules$2[i][0], _rules$2[i][1]);
-}
-/**
-* Core.process(state)
-*
-* Executes core chain rules.
-**/
-Core.prototype.process = function(state) {
-	const rules = this.ruler.getRules("");
-	for (let i = 0, l = rules.length; i < l; i++) rules[i](state);
+	* Executes core chain rules.
+	*/
+	process(state) {
+		const rules = this.ruler.getRules("");
+		for (let i = 0, l = rules.length; i < l; i++) rules[i](state);
+	}
 };
-Core.prototype.State = StateCore;
 //#endregion
-//#region lib/rules_block/state_block.mjs
-function StateBlock(src, md, env, tokens) {
-	this.src = src;
-	this.md = md;
-	this.env = env;
-	this.tokens = tokens;
-	this.bMarks = [];
-	this.eMarks = [];
-	this.tShift = [];
-	this.sCount = [];
-	this.bsCount = [];
-	this.blkIndent = 0;
-	this.line = 0;
-	this.lineMax = 0;
-	this.tight = false;
-	this.ddIndent = -1;
-	this.listIndent = -1;
-	this.parentType = "root";
-	this.level = 0;
-	const s = this.src;
-	for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
-		const ch = s.charCodeAt(pos);
-		if (!indent_found) if (isSpace(ch)) {
-			indent++;
-			if (ch === 9) offset += 4 - offset % 4;
-			else offset++;
-			continue;
-		} else indent_found = true;
-		if (ch === 10 || pos === len - 1) {
-			if (ch !== 10) pos++;
-			this.bMarks.push(start);
-			this.eMarks.push(pos);
-			this.tShift.push(indent);
-			this.sCount.push(offset);
-			this.bsCount.push(0);
-			indent_found = false;
-			indent = 0;
-			offset = 0;
-			start = pos + 1;
+//#region src/rules_block/state_block.ts
+/** Mutable state passed to block rules while tokenizing a source document. */
+var StateBlock = class {
+	constructor(src, md, env, tokens) {
+		_defineProperty(this, "bMarks", []);
+		_defineProperty(this, "eMarks", []);
+		_defineProperty(this, "tShift", []);
+		_defineProperty(this, "sCount", []);
+		_defineProperty(this, "bsCount", []);
+		_defineProperty(this, "blkIndent", 0);
+		_defineProperty(this, "line", 0);
+		_defineProperty(this, "lineMax", 0);
+		_defineProperty(this, "tight", false);
+		_defineProperty(this, "listIndent", -1);
+		_defineProperty(this, "parentType", "root");
+		_defineProperty(this, "level", 0);
+		_defineProperty(this, "Token", Token);
+		this.src = src;
+		this.md = md;
+		this.env = env;
+		this.tokens = tokens;
+		const s = this.src;
+		for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
+			const ch = s.charCodeAt(pos);
+			if (!indent_found) if (isSpace(ch)) {
+				indent++;
+				if (ch === 9) offset += 4 - offset % 4;
+				else offset++;
+				continue;
+			} else indent_found = true;
+			if (ch === 10 || pos === len - 1) {
+				if (ch !== 10) pos++;
+				this.bMarks.push(start);
+				this.eMarks.push(pos);
+				this.tShift.push(indent);
+				this.sCount.push(offset);
+				this.bsCount.push(0);
+				indent_found = false;
+				indent = 0;
+				offset = 0;
+				start = pos + 1;
+			}
 		}
-	}
-	this.bMarks.push(s.length);
-	this.eMarks.push(s.length);
-	this.tShift.push(0);
-	this.sCount.push(0);
-	this.bsCount.push(0);
-	this.lineMax = this.bMarks.length - 1;
-}
-StateBlock.prototype.push = function(type, tag, nesting) {
-	const token = new Token(type, tag, nesting);
-	token.block = true;
-	if (nesting < 0) this.level--;
-	token.level = this.level;
-	if (nesting > 0) this.level++;
-	this.tokens.push(token);
-	return token;
-};
-StateBlock.prototype.isEmpty = function isEmpty(line) {
-	return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
-};
-StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
-	for (let max = this.lineMax; from < max; from++) if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) break;
-	return from;
-};
-StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
-	for (let max = this.src.length; pos < max; pos++) if (!isSpace(this.src.charCodeAt(pos))) break;
-	return pos;
-};
-StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
-	if (pos <= min) return pos;
-	while (pos > min) if (!isSpace(this.src.charCodeAt(--pos))) return pos + 1;
-	return pos;
-};
-StateBlock.prototype.skipChars = function skipChars(pos, code) {
-	for (let max = this.src.length; pos < max; pos++) if (this.src.charCodeAt(pos) !== code) break;
-	return pos;
-};
-StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {
-	if (pos <= min) return pos;
-	while (pos > min) if (code !== this.src.charCodeAt(--pos)) return pos + 1;
-	return pos;
-};
-StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
-	if (begin >= end) return "";
-	const queue = new Array(end - begin);
-	for (let i = 0, line = begin; line < end; line++, i++) {
-		let lineIndent = 0;
-		const lineStart = this.bMarks[line];
-		let first = lineStart;
-		let last;
-		if (line + 1 < end || keepLastLF) last = this.eMarks[line] + 1;
-		else last = this.eMarks[line];
-		while (first < last && lineIndent < indent) {
-			const ch = this.src.charCodeAt(first);
-			if (isSpace(ch)) if (ch === 9) lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
-			else lineIndent++;
-			else if (first - lineStart < this.tShift[line]) lineIndent++;
-			else break;
-			first++;
+		this.bMarks.push(s.length);
+		this.eMarks.push(s.length);
+		this.tShift.push(0);
+		this.sCount.push(0);
+		this.bsCount.push(0);
+		this.lineMax = this.bMarks.length - 1;
+	}
+	push(type, tag, nesting) {
+		const token = new Token(type, tag, nesting);
+		token.block = true;
+		if (nesting < 0) this.level--;
+		token.level = this.level;
+		if (nesting > 0) this.level++;
+		this.tokens.push(token);
+		return token;
+	}
+	isEmpty(line) {
+		return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
+	}
+	skipEmptyLines(from) {
+		for (let max = this.lineMax; from < max; from++) if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) break;
+		return from;
+	}
+	skipSpaces(pos) {
+		for (let max = this.src.length; pos < max; pos++) if (!isSpace(this.src.charCodeAt(pos))) break;
+		return pos;
+	}
+	skipSpacesBack(pos, min) {
+		if (pos <= min) return pos;
+		while (pos > min) if (!isSpace(this.src.charCodeAt(--pos))) return pos + 1;
+		return pos;
+	}
+	skipChars(pos, code) {
+		for (let max = this.src.length; pos < max; pos++) if (this.src.charCodeAt(pos) !== code) break;
+		return pos;
+	}
+	skipCharsBack(pos, code, min) {
+		if (pos <= min) return pos;
+		while (pos > min) if (code !== this.src.charCodeAt(--pos)) return pos + 1;
+		return pos;
+	}
+	getLines(begin, end, indent, keepLastLF) {
+		if (begin >= end) return "";
+		const queue = new Array(end - begin);
+		for (let i = 0, line = begin; line < end; line++, i++) {
+			let lineIndent = 0;
+			const lineStart = this.bMarks[line];
+			let first = lineStart;
+			let last;
+			if (line + 1 < end || keepLastLF) last = this.eMarks[line] + 1;
+			else last = this.eMarks[line];
+			while (first < last && lineIndent < indent) {
+				const ch = this.src.charCodeAt(first);
+				if (isSpace(ch)) if (ch === 9) lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
+				else lineIndent++;
+				else if (first - lineStart < this.tShift[line]) lineIndent++;
+				else break;
+				first++;
+			}
+			if (lineIndent > indent) queue[i] = new Array(lineIndent - indent + 1).join(" ") + this.src.slice(first, last);
+			else queue[i] = this.src.slice(first, last);
 		}
-		if (lineIndent > indent) queue[i] = new Array(lineIndent - indent + 1).join(" ") + this.src.slice(first, last);
-		else queue[i] = this.src.slice(first, last);
+		return queue.join("");
 	}
-	return queue.join("");
 };
-StateBlock.prototype.Token = Token;
 //#endregion
-//#region lib/rules_block/table.mjs
+//#region src/rules_block/table.ts
 var MAX_AUTOCOMPLETED_CELLS = 65536;
 function getLine(state, line) {
 	const pos = state.bMarks[line] + state.tShift[line];
@@ -1537,7 +1579,7 @@ function table(state, startLine, endLine, silent) {
 	token_htro.map = [startLine, startLine + 1];
 	for (let i = 0; i < columns.length; i++) {
 		const token_ho = state.push("th_open", "th", 1);
-		if (aligns[i]) token_ho.attrs = [["style", "text-align:" + aligns[i]]];
+		if (aligns[i]) token_ho.attrs = [["style", `text-align:${aligns[i]}`]];
 		const token_il = state.push("inline", "", 0);
 		token_il.content = columns[i].trim();
 		token_il.children = [];
@@ -1571,7 +1613,7 @@ function table(state, startLine, endLine, silent) {
 		token_tro.map = [nextLine, nextLine + 1];
 		for (let i = 0; i < columnCount; i++) {
 			const token_tdo = state.push("td_open", "td", 1);
-			if (aligns[i]) token_tdo.attrs = [["style", "text-align:" + aligns[i]]];
+			if (aligns[i]) token_tdo.attrs = [["style", `text-align:${aligns[i]}`]];
 			const token_il = state.push("inline", "", 0);
 			token_il.content = columns[i] ? columns[i].trim() : "";
 			token_il.children = [];
@@ -1590,7 +1632,7 @@ function table(state, startLine, endLine, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_block/code.mjs
+//#region src/rules_block/code.ts
 function code(state, startLine, endLine) {
 	if (state.sCount[startLine] - state.blkIndent < 4) return false;
 	let nextLine = startLine + 1;
@@ -1614,7 +1656,7 @@ function code(state, startLine, endLine) {
 	return true;
 }
 //#endregion
-//#region lib/rules_block/fence.mjs
+//#region src/rules_block/fence.ts
 function fence(state, startLine, endLine, silent) {
 	let pos = state.bMarks[startLine] + state.tShift[startLine];
 	let max = state.eMarks[startLine];
@@ -1659,7 +1701,7 @@ function fence(state, startLine, endLine, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_block/blockquote.mjs
+//#region src/rules_block/blockquote.ts
 function blockquote(state, startLine, endLine, silent) {
 	let pos = state.bMarks[startLine] + state.tShift[startLine];
 	let max = state.eMarks[startLine];
@@ -1762,7 +1804,7 @@ function blockquote(state, startLine, endLine, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_block/hr.mjs
+//#region src/rules_block/hr.ts
 function hr(state, startLine, endLine, silent) {
 	const max = state.eMarks[startLine];
 	if (state.sCount[startLine] - state.blkIndent >= 4) return false;
@@ -1784,7 +1826,7 @@ function hr(state, startLine, endLine, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_block/list.mjs
+//#region src/rules_block/list.ts
 function skipBulletListMarker(state, startLine) {
 	const max = state.eMarks[startLine];
 	let pos = state.bMarks[startLine] + state.tShift[startLine];
@@ -1896,7 +1938,7 @@ function list(state, startLine, endLine, silent) {
 		state.tShift[nextLine] = contentStart - state.bMarks[nextLine];
 		state.sCount[nextLine] = offset;
 		if (contentStart >= max && state.isEmpty(nextLine + 1)) state.line = Math.min(state.line + 2, endLine);
-		else state.md.block.tokenize(state, nextLine, endLine, true);
+		else state.md.block.tokenize(state, nextLine, endLine);
 		if (!state.tight || prevEmptyEnd) tight = false;
 		prevEmptyEnd = state.line - nextLine > 1 && state.isEmpty(state.line - 1);
 		state.blkIndent = state.listIndent;
@@ -1937,7 +1979,7 @@ function list(state, startLine, endLine, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_block/reference.mjs
+//#region src/rules_block/reference.ts
 function reference(state, startLine, _endLine, silent) {
 	let pos = state.bMarks[startLine] + state.tShift[startLine];
 	let max = state.eMarks[startLine];
@@ -2069,11 +2111,17 @@ function reference(state, startLine, _endLine, silent) {
 		title,
 		href
 	};
+	const token = state.push("reference_definition", "", 0);
+	token.map = [startLine, nextLine];
+	token.hidden = true;
+	const meta = Object.create(null);
+	meta.label = label;
+	token.meta = meta;
 	state.line = nextLine;
 	return true;
 }
 //#endregion
-//#region lib/common/html_blocks.mjs
+//#region src/common/html_blocks.ts
 var html_blocks_default = [
 	"address",
 	"article",
@@ -2139,11 +2187,13 @@ var html_blocks_default = [
 	"ul"
 ];
 //#endregion
-//#region lib/common/html_re.mjs
-var HTML_TAG_RE = /* @__PURE__ */ new RegExp("^(?:<[A-Za-z][A-Za-z0-9\\-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*\\/?>|<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>|<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->|<[?][\\s\\S]*?[?]>|<![A-Za-z][^>]*>|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>)");
-var HTML_OPEN_CLOSE_TAG_RE = /* @__PURE__ */ new RegExp("^(?:<[A-Za-z][A-Za-z0-9\\-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*\\/?>|<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>)");
+//#region src/common/html_re.ts
+var open_tag = `<[A-Za-z][A-Za-z0-9\\-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^"'=<>\`\\x00-\\x20]+|'[^']*'|"[^"]*"))?)*\\s*\\/?>`;
+var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
+var HTML_TAG_RE = new RegExp(`^(?:${open_tag}|${close_tag}|<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->|<[?][\\s\\S]*?[?]>|<![A-Za-z][^>]*>|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>)`);
+var HTML_OPEN_CLOSE_TAG_RE = new RegExp(`^(?:${open_tag}|${close_tag})`);
 //#endregion
-//#region lib/rules_block/html_block.mjs
+//#region src/rules_block/html_block.ts
 var HTML_SEQUENCES = [
 	[
 		/^<(script|pre|style|textarea)(?=(\s|>|$))/i,
@@ -2161,7 +2211,7 @@ var HTML_SEQUENCES = [
 		true
 	],
 	[
-		/^<![A-Z]/,
+		/^<![A-Za-z]/,
 		/>/,
 		true
 	],
@@ -2171,12 +2221,12 @@ var HTML_SEQUENCES = [
 		true
 	],
 	[
-		new RegExp("^</?(" + html_blocks_default.join("|") + ")(?=(\\s|/?>|$))", "i"),
+		new RegExp(`^</?(${html_blocks_default.join("|")})(?=(\\s|/?>|$))`, "i"),
 		/^$/,
 		true
 	],
 	[
-		new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + "\\s*$"),
+		new RegExp(`${HTML_OPEN_CLOSE_TAG_RE.source}\\s*$`),
 		/^$/,
 		false
 	]
@@ -2213,7 +2263,7 @@ function html_block(state, startLine, endLine, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_block/heading.mjs
+//#region src/rules_block/heading.ts
 function heading(state, startLine, endLine, silent) {
 	let pos = state.bMarks[startLine] + state.tShift[startLine];
 	let max = state.eMarks[startLine];
@@ -2232,19 +2282,19 @@ function heading(state, startLine, endLine, silent) {
 	const tmp = state.skipCharsBack(max, 35, pos);
 	if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) max = tmp;
 	state.line = startLine + 1;
-	const token_o = state.push("heading_open", "h" + String(level), 1);
+	const token_o = state.push("heading_open", `h${level}`, 1);
 	token_o.markup = "########".slice(0, level);
 	token_o.map = [startLine, state.line];
 	const token_i = state.push("inline", "", 0);
 	token_i.content = asciiTrim(state.src.slice(pos, max));
 	token_i.map = [startLine, state.line];
 	token_i.children = [];
-	const token_c = state.push("heading_close", "h" + String(level), -1);
+	const token_c = state.push("heading_close", `h${level}`, -1);
 	token_c.markup = "########".slice(0, level);
 	return true;
 }
 //#endregion
-//#region lib/rules_block/lheading.mjs
+//#region src/rules_block/lheading.ts
 function lheading(state, startLine, endLine) {
 	const terminatorRules = state.md.block.ruler.getRules("paragraph");
 	if (state.sCount[startLine] - state.blkIndent >= 4) return false;
@@ -2284,20 +2334,20 @@ function lheading(state, startLine, endLine) {
 	}
 	const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false));
 	state.line = nextLine + 1;
-	const token_o = state.push("heading_open", "h" + String(level), 1);
+	const token_o = state.push("heading_open", `h${level}`, 1);
 	token_o.markup = String.fromCharCode(marker);
 	token_o.map = [startLine, state.line];
 	const token_i = state.push("inline", "", 0);
 	token_i.content = content;
 	token_i.map = [startLine, state.line - 1];
 	token_i.children = [];
-	const token_c = state.push("heading_close", "h" + String(level), -1);
+	const token_c = state.push("heading_close", `h${level}`, -1);
 	token_c.markup = String.fromCharCode(marker);
 	state.parentType = oldParentType;
 	return true;
 }
 //#endregion
-//#region lib/rules_block/paragraph.mjs
+//#region src/rules_block/paragraph.ts
 function paragraph(state, startLine, endLine) {
 	const terminatorRules = state.md.block.ruler.getRules("paragraph");
 	const oldParentType = state.parentType;
@@ -2326,12 +2376,7 @@ function paragraph(state, startLine, endLine) {
 	return true;
 }
 //#endregion
-//#region lib/parser_block.mjs
-/** internal
-* class ParserBlock
-*
-* Block-level tokenizer.
-**/
+//#region src/parser_block.ts
 var _rules$1 = [
 	[
 		"table",
@@ -2401,148 +2446,153 @@ var _rules$1 = [
 	["paragraph", paragraph]
 ];
 /**
-* new ParserBlock()
-**/
-function ParserBlock() {
-	/**
-	* ParserBlock#ruler -> Ruler
-	*
-	* [[Ruler]] instance. Keep configuration of block rules.
-	**/
-	this.ruler = new Ruler();
-	for (let i = 0; i < _rules$1.length; i++) this.ruler.push(_rules$1[i][0], _rules$1[i][1], { alt: (_rules$1[i][2] || []).slice() });
-}
-ParserBlock.prototype.tokenize = function(state, startLine, endLine) {
-	const rules = this.ruler.getRules("");
-	const len = rules.length;
-	const maxNesting = state.md.options.maxNesting;
-	let line = startLine;
-	let hasEmptyLines = false;
-	while (line < endLine) {
-		state.line = line = state.skipEmptyLines(line);
-		if (line >= endLine) break;
-		if (state.sCount[line] < state.blkIndent) break;
-		if (state.level >= maxNesting) {
-			state.line = endLine;
-			break;
-		}
-		const prevLine = state.line;
-		let ok = false;
-		for (let i = 0; i < len; i++) {
-			ok = rules[i](state, line, endLine, false);
-			if (ok) {
-				if (prevLine >= state.line) throw new Error("block rule didn't increment state.line");
+* Block-level tokenizer.
+*/
+var ParserBlock = class {
+	constructor() {
+		_defineProperty(
+			this,
+			/**
+			* {@link Ruler} instance. Keep configuration of block rules.
+			*/
+			"ruler",
+			new Ruler()
+		);
+		_defineProperty(this, "State", StateBlock);
+		for (let i = 0; i < _rules$1.length; i++) this.ruler.push(_rules$1[i][0], _rules$1[i][1], { alt: (_rules$1[i][2] || []).slice() });
+	}
+	tokenize(state, startLine, endLine) {
+		const rules = this.ruler.getRules("");
+		const len = rules.length;
+		const maxNesting = state.md.options.maxNesting;
+		let line = startLine;
+		let hasEmptyLines = false;
+		while (line < endLine) {
+			state.line = line = state.skipEmptyLines(line);
+			if (line >= endLine) break;
+			if (state.sCount[line] < state.blkIndent) break;
+			if (state.level >= maxNesting) {
+				state.line = endLine;
 				break;
 			}
-		}
-		if (!ok) throw new Error("none of the block rules matched");
-		state.tight = !hasEmptyLines;
-		if (state.isEmpty(state.line - 1)) hasEmptyLines = true;
-		line = state.line;
-		if (line < endLine && state.isEmpty(line)) {
-			hasEmptyLines = true;
-			line++;
-			state.line = line;
+			const prevLine = state.line;
+			let ok = false;
+			for (let i = 0; i < len; i++) {
+				ok = rules[i](state, line, endLine, false);
+				if (ok) {
+					if (prevLine >= state.line) throw new Error("block rule didn't increment state.line");
+					break;
+				}
+			}
+			if (!ok) throw new Error("none of the block rules matched");
+			state.tight = !hasEmptyLines;
+			if (state.isEmpty(state.line - 1)) hasEmptyLines = true;
+			line = state.line;
+			if (line < endLine && state.isEmpty(line)) {
+				hasEmptyLines = true;
+				line++;
+				state.line = line;
+			}
 		}
 	}
+	/**
+	* Process input string and push block tokens into `outTokens`
+	*/
+	parse(src, md, env, outTokens) {
+		if (!src) return;
+		const state = new this.State(src, md, env, outTokens);
+		this.tokenize(state, state.line, state.lineMax);
+	}
 };
-/**
-* ParserBlock.parse(str, md, env, outTokens)
-*
-* Process input string and push block tokens into `outTokens`
-**/
-ParserBlock.prototype.parse = function(src, md, env, outTokens) {
-	if (!src) return;
-	const state = new this.State(src, md, env, outTokens);
-	this.tokenize(state, state.line, state.lineMax);
-};
-ParserBlock.prototype.State = StateBlock;
 //#endregion
-//#region lib/rules_inline/state_inline.mjs
-function StateInline(src, md, env, outTokens) {
-	this.src = src;
-	this.env = env;
-	this.md = md;
-	this.tokens = outTokens;
-	this.tokens_meta = Array(outTokens.length);
-	this.pos = 0;
-	this.posMax = this.src.length;
-	this.level = 0;
-	this.pending = "";
-	this.pendingLevel = 0;
-	this.cache = {};
-	this.delimiters = [];
-	this._prev_delimiters = [];
-	this.backticks = {};
-	this.backticksScanned = false;
-	this.linkLevel = 0;
-}
-StateInline.prototype.pushPending = function() {
-	const token = new Token("text", "", 0);
-	token.content = this.pending;
-	token.level = this.pendingLevel;
-	this.tokens.push(token);
-	this.pending = "";
-	return token;
-};
-StateInline.prototype.push = function(type, tag, nesting) {
-	if (this.pending) this.pushPending();
-	const token = new Token(type, tag, nesting);
-	let token_meta = null;
-	if (nesting < 0) {
-		this.level--;
-		this.delimiters = this._prev_delimiters.pop();
-	}
-	token.level = this.level;
-	if (nesting > 0) {
-		this.level++;
-		this._prev_delimiters.push(this.delimiters);
-		this.delimiters = [];
-		token_meta = { delimiters: this.delimiters };
-	}
-	this.pendingLevel = this.level;
-	this.tokens.push(token);
-	this.tokens_meta.push(token_meta);
-	return token;
-};
-StateInline.prototype.scanDelims = function(start, canSplitWord) {
-	const max = this.posMax;
-	const marker = this.src.charCodeAt(start);
-	let lastChar;
-	if (start === 0) lastChar = 32;
-	else if (start === 1) {
-		lastChar = this.src.charCodeAt(0);
-		if ((lastChar & 63488) === 55296) lastChar = 65533;
-	} else {
-		lastChar = this.src.charCodeAt(start - 1);
-		if ((lastChar & 64512) === 56320) {
-			const highSurr = this.src.charCodeAt(start - 2);
-			lastChar = (highSurr & 64512) === 55296 ? 65536 + (highSurr - 55296 << 10) + (lastChar - 56320) : 65533;
-		} else if ((lastChar & 64512) === 55296) lastChar = 65533;
+//#region src/rules_inline/state_inline.ts
+/** Mutable state passed to inline rules while tokenizing inline content. */
+var StateInline = class {
+	constructor(src, md, env, outTokens) {
+		_defineProperty(this, "pos", 0);
+		_defineProperty(this, "level", 0);
+		_defineProperty(this, "pending", "");
+		_defineProperty(this, "pendingLevel", 0);
+		_defineProperty(this, "cache", {});
+		_defineProperty(this, "backticks", {});
+		_defineProperty(this, "backticksScanned", false);
+		_defineProperty(this, "linkLevel", 0);
+		_defineProperty(this, "delimiters", []);
+		_defineProperty(this, "_prev_delimiters", []);
+		_defineProperty(this, "Token", Token);
+		this.src = src;
+		this.env = env;
+		this.md = md;
+		this.tokens = outTokens;
+		this.tokens_meta = Array(outTokens.length);
+		this.posMax = this.src.length;
+	}
+	pushPending() {
+		const token = new Token("text", "", 0);
+		token.content = this.pending;
+		token.level = this.pendingLevel;
+		this.tokens.push(token);
+		this.pending = "";
+		return token;
+	}
+	push(type, tag, nesting) {
+		if (this.pending) this.pushPending();
+		const token = new Token(type, tag, nesting);
+		let token_meta = void 0;
+		if (nesting < 0) {
+			this.level--;
+			this.delimiters = this._prev_delimiters.pop();
+		}
+		token.level = this.level;
+		if (nesting > 0) {
+			this.level++;
+			this._prev_delimiters.push(this.delimiters);
+			this.delimiters = [];
+			token_meta = { delimiters: this.delimiters };
+		}
+		this.pendingLevel = this.level;
+		this.tokens.push(token);
+		this.tokens_meta.push(token_meta);
+		return token;
+	}
+	scanDelims(start, canSplitWord) {
+		const max = this.posMax;
+		const marker = this.src.charCodeAt(start);
+		let lastChar;
+		if (start === 0) lastChar = 32;
+		else if (start === 1) {
+			lastChar = this.src.charCodeAt(0);
+			if ((lastChar & 63488) === 55296) lastChar = 65533;
+		} else {
+			lastChar = this.src.charCodeAt(start - 1);
+			if ((lastChar & 64512) === 56320) {
+				const highSurr = this.src.charCodeAt(start - 2);
+				lastChar = (highSurr & 64512) === 55296 ? 65536 + (highSurr - 55296 << 10) + (lastChar - 56320) : 65533;
+			} else if ((lastChar & 64512) === 55296) lastChar = 65533;
+		}
+		let pos = start;
+		while (pos < max && this.src.charCodeAt(pos) === marker) pos++;
+		const count = pos - start;
+		let nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
+		if ((nextChar & 64512) === 55296) {
+			const lowSurr = this.src.charCodeAt(pos + 1);
+			nextChar = (lowSurr & 64512) === 56320 ? 65536 + (nextChar - 55296 << 10) + (lowSurr - 56320) : 65533;
+		} else if ((nextChar & 64512) === 56320) nextChar = 65533;
+		const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar);
+		const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar);
+		const isLastWhiteSpace = isWhiteSpace(lastChar);
+		const isNextWhiteSpace = isWhiteSpace(nextChar);
+		const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
+		const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
+		return {
+			can_open: left_flanking && (canSplitWord || !right_flanking || isLastPunctChar),
+			can_close: right_flanking && (canSplitWord || !left_flanking || isNextPunctChar),
+			length: count
+		};
 	}
-	let pos = start;
-	while (pos < max && this.src.charCodeAt(pos) === marker) pos++;
-	const count = pos - start;
-	let nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
-	if ((nextChar & 64512) === 55296) {
-		const lowSurr = this.src.charCodeAt(pos + 1);
-		nextChar = (lowSurr & 64512) === 56320 ? 65536 + (nextChar - 55296 << 10) + (lowSurr - 56320) : 65533;
-	} else if ((nextChar & 64512) === 56320) nextChar = 65533;
-	const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar);
-	const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar);
-	const isLastWhiteSpace = isWhiteSpace(lastChar);
-	const isNextWhiteSpace = isWhiteSpace(nextChar);
-	const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
-	const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
-	return {
-		can_open: left_flanking && (canSplitWord || !right_flanking || isLastPunctChar),
-		can_close: right_flanking && (canSplitWord || !left_flanking || isNextPunctChar),
-		length: count
-	};
 };
-StateInline.prototype.Token = Token;
 //#endregion
-//#region lib/rules_inline/text.mjs
+//#region src/rules_inline/text.ts
 function isTerminatorChar(ch) {
 	switch (ch) {
 		case 10:
@@ -2580,8 +2630,13 @@ function text(state, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/linkify.mjs
-var SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
+//#region src/rules_inline/linkify.ts
+function isAsciiAlpha(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isSchemeChar(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 45 || code === 46;
+}
 function linkify(state, silent) {
 	if (!state.md.options.linkify) return false;
 	if (state.linkLevel > 0) return false;
@@ -2591,20 +2646,22 @@ function linkify(state, silent) {
 	if (state.src.charCodeAt(pos) !== 58) return false;
 	if (state.src.charCodeAt(pos + 1) !== 47) return false;
 	if (state.src.charCodeAt(pos + 2) !== 47) return false;
-	const match = state.pending.match(SCHEME_RE);
-	if (!match) return false;
-	const proto = match[1];
-	const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
+	const protoMin = pos - Math.min(10, state.pending.length, pos);
+	let protoStart = pos;
+	while (protoStart > protoMin && isSchemeChar(state.src.charCodeAt(protoStart - 1))) protoStart--;
+	if (protoStart === pos || !isAsciiAlpha(state.src.charCodeAt(protoStart))) return false;
+	const protoLength = pos - protoStart;
+	const link = state.md.linkify.matchAtStart(state.src.slice(protoStart));
 	if (!link) return false;
 	let url = link.url;
-	if (url.length <= proto.length) return false;
+	if (url.length <= protoLength) return false;
 	let urlEnd = url.length;
 	while (urlEnd > 0 && url.charCodeAt(urlEnd - 1) === 42) urlEnd--;
 	if (urlEnd !== url.length) url = url.slice(0, urlEnd);
 	const fullUrl = state.md.normalizeLink(url);
 	if (!state.md.validateLink(fullUrl)) return false;
 	if (!silent) {
-		state.pending = state.pending.slice(0, -proto.length);
+		state.pending = state.pending.slice(0, -protoLength);
 		const token_o = state.push("link_open", "a", 1);
 		token_o.attrs = [["href", fullUrl]];
 		token_o.markup = "linkify";
@@ -2615,11 +2672,11 @@ function linkify(state, silent) {
 		token_c.markup = "linkify";
 		token_c.info = "auto";
 	}
-	state.pos += url.length - proto.length;
+	state.pos += url.length - protoLength;
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/newline.mjs
+//#region src/rules_inline/newline.ts
 function newline(state, silent) {
 	let pos = state.pos;
 	if (state.src.charCodeAt(pos) !== 10) return false;
@@ -2641,7 +2698,7 @@ function newline(state, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/escape.mjs
+//#region src/rules_inline/escape.ts
 var ESCAPED = [];
 for (let i = 0; i < 256; i++) ESCAPED.push(0);
 "\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function(ch) {
@@ -2695,45 +2752,56 @@ function escape(state, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/backticks.mjs
+//#region src/rules_inline/backticks.ts
+function buildLastRuns(src) {
+	const lastRuns = {};
+	let pos = 0;
+	while ((pos = src.indexOf("`", pos)) !== -1) {
+		const start = pos;
+		while (src.charCodeAt(++pos) === 96);
+		lastRuns[pos - start] = start;
+	}
+	return lastRuns;
+}
 function backtick(state, silent) {
-	let pos = state.pos;
-	if (state.src.charCodeAt(pos) !== 96) return false;
-	const start = pos;
-	pos++;
+	var _state$backticks$open;
+	const start = state.pos;
+	if (state.src.charCodeAt(start) !== 96) return false;
 	const max = state.posMax;
+	let pos = start + 1;
 	while (pos < max && state.src.charCodeAt(pos) === 96) pos++;
 	const marker = state.src.slice(start, pos);
 	const openerLength = marker.length;
-	if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
-		if (!silent) state.pending += marker;
-		state.pos += openerLength;
-		return true;
-	}
-	let matchEnd = pos;
-	let matchStart;
-	while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1) {
-		matchEnd = matchStart + 1;
-		while (matchEnd < max && state.src.charCodeAt(matchEnd) === 96) matchEnd++;
-		const closerLength = matchEnd - matchStart;
-		if (closerLength === openerLength) {
-			if (!silent) {
-				const token = state.push("code_inline", "code", 0);
-				token.markup = marker;
-				token.content = state.src.slice(pos, matchStart).replace(/\n/g, " ").replace(/^ (.+) $/, "$1");
+	if (!state.backticksScanned) {
+		state.backticks = buildLastRuns(state.src);
+		state.backticksScanned = true;
+	}
+	if (((_state$backticks$open = state.backticks[openerLength]) !== null && _state$backticks$open !== void 0 ? _state$backticks$open : -1) >= pos) {
+		let matchEnd = pos;
+		let matchStart;
+		while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1 && matchStart < max) {
+			matchEnd = matchStart + 1;
+			while (state.src.charCodeAt(matchEnd) === 96) matchEnd++;
+			if (matchEnd > max) break;
+			if (matchEnd - matchStart === openerLength) {
+				if (!silent) {
+					const token = state.push("code_inline", "code", 0);
+					token.markup = marker;
+					let content = state.src.slice(pos, matchStart).replace(/\n/g, " ");
+					if (content.startsWith(" ") && content.endsWith(" ") && /[^ ]/.test(content)) content = content.slice(1, -1);
+					token.content = content;
+				}
+				state.pos = matchEnd;
+				return true;
 			}
-			state.pos = matchEnd;
-			return true;
 		}
-		state.backticks[closerLength] = matchStart;
 	}
-	state.backticksScanned = true;
 	if (!silent) state.pending += marker;
-	state.pos += openerLength;
+	state.pos = pos;
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/strikethrough.mjs
+//#region src/rules_inline/strikethrough.ts
 function strikethrough_tokenize(state, silent) {
 	const start = state.pos;
 	const marker = state.src.charCodeAt(start);
@@ -2803,14 +2871,18 @@ function strikethrough_postProcess(state) {
 	const tokens_meta = state.tokens_meta;
 	const max = state.tokens_meta.length;
 	postProcess$1(state, state.delimiters);
-	for (let curr = 0; curr < max; curr++) if (tokens_meta[curr] && tokens_meta[curr].delimiters) postProcess$1(state, tokens_meta[curr].delimiters);
+	for (let curr = 0; curr < max; curr++) {
+		var _tokens_meta$curr;
+		const delimiters = (_tokens_meta$curr = tokens_meta[curr]) === null || _tokens_meta$curr === void 0 ? void 0 : _tokens_meta$curr.delimiters;
+		if (delimiters) postProcess$1(state, delimiters);
+	}
 }
 var strikethrough_default = {
 	tokenize: strikethrough_tokenize,
 	postProcess: strikethrough_postProcess
 };
 //#endregion
-//#region lib/rules_inline/emphasis.mjs
+//#region src/rules_inline/emphasis.ts
 function emphasis_tokenize(state, silent) {
 	const start = state.pos;
 	const marker = state.src.charCodeAt(start);
@@ -2864,14 +2936,18 @@ function emphasis_post_process(state) {
 	const tokens_meta = state.tokens_meta;
 	const max = state.tokens_meta.length;
 	postProcess(state, state.delimiters);
-	for (let curr = 0; curr < max; curr++) if (tokens_meta[curr] && tokens_meta[curr].delimiters) postProcess(state, tokens_meta[curr].delimiters);
+	for (let curr = 0; curr < max; curr++) {
+		var _tokens_meta$curr;
+		const delimiters = (_tokens_meta$curr = tokens_meta[curr]) === null || _tokens_meta$curr === void 0 ? void 0 : _tokens_meta$curr.delimiters;
+		if (delimiters) postProcess(state, delimiters);
+	}
 }
 var emphasis_default = {
 	tokenize: emphasis_tokenize,
 	postProcess: emphasis_post_process
 };
 //#endregion
-//#region lib/rules_inline/link.mjs
+//#region src/rules_inline/link.ts
 function link(state, silent) {
 	let code, label, res, ref;
 	let href = "";
@@ -2926,7 +3002,8 @@ function link(state, silent) {
 			else pos = labelEnd + 1;
 		} else pos = labelEnd + 1;
 		if (!label) label = state.src.slice(labelStart, labelEnd);
-		ref = state.env.references[normalizeReference(label)];
+		label = normalizeReference(label);
+		ref = state.env.references[label];
 		if (!ref) {
 			state.pos = oldPos;
 			return false;
@@ -2941,6 +3018,11 @@ function link(state, silent) {
 		const attrs = [["href", href]];
 		token_o.attrs = attrs;
 		if (title) attrs.push(["title", title]);
+		if (label) {
+			const meta = Object.create(null);
+			meta.label = label;
+			token_o.meta = meta;
+		}
 		state.linkLevel++;
 		state.md.inline.tokenize(state);
 		state.linkLevel--;
@@ -2951,7 +3033,7 @@ function link(state, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/image.mjs
+//#region src/rules_inline/image.ts
 function image(state, silent) {
 	let code, content, label, pos, ref, res, title, start;
 	let href = "";
@@ -3005,7 +3087,8 @@ function image(state, silent) {
 			else pos = labelEnd + 1;
 		} else pos = labelEnd + 1;
 		if (!label) label = state.src.slice(labelStart, labelEnd);
-		ref = state.env.references[normalizeReference(label)];
+		label = normalizeReference(label);
+		ref = state.env.references[label];
 		if (!ref) {
 			state.pos = oldPos;
 			return false;
@@ -3023,13 +3106,18 @@ function image(state, silent) {
 		token.children = tokens;
 		token.content = content;
 		if (title) attrs.push(["title", title]);
+		if (label) {
+			const meta = Object.create(null);
+			meta.label = label;
+			token.meta = meta;
+		}
 	}
 	state.pos = pos;
 	state.posMax = max;
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/autolink.mjs
+//#region src/rules_inline/autolink.ts
 var EMAIL_RE = /^([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])?)*)$/;
 var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/;
 function autolink(state, silent) {
@@ -3062,7 +3150,7 @@ function autolink(state, silent) {
 		return true;
 	}
 	if (EMAIL_RE.test(url)) {
-		const fullUrl = state.md.normalizeLink("mailto:" + url);
+		const fullUrl = state.md.normalizeLink(`mailto:${url}`);
 		if (!state.md.validateLink(fullUrl)) return false;
 		if (!silent) {
 			const token_o = state.push("link_open", "a", 1);
@@ -3081,7 +3169,7 @@ function autolink(state, silent) {
 	return false;
 }
 //#endregion
-//#region lib/rules_inline/html_inline.mjs
+//#region src/rules_inline/html_inline.ts
 function isLinkOpen(str) {
 	return /^<a[>\s]/i.test(str);
 }
@@ -3111,7 +3199,7 @@ function html_inline(state, silent) {
 	return true;
 }
 //#endregion
-//#region lib/rules_inline/entity.mjs
+//#region src/rules_inline/entity.ts
 var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
 var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
 function entity(state, silent) {
@@ -3135,7 +3223,7 @@ function entity(state, silent) {
 	} else {
 		const match = state.src.slice(pos).match(NAMED_RE);
 		if (match) {
-			const decoded = (0, entities.decodeHTMLStrict)(match[0]);
+			const decoded = decodeHTMLStrict(match[0]);
 			if (decoded !== match[0]) {
 				if (!silent) {
 					const token = state.push("text_special", "", 0);
@@ -3151,7 +3239,7 @@ function entity(state, silent) {
 	return false;
 }
 //#endregion
-//#region lib/rules_inline/balance_pairs.mjs
+//#region src/rules_inline/balance_pairs.ts
 function processDelimiters(delimiters) {
 	const openersBottom = {};
 	const max = delimiters.length;
@@ -3207,10 +3295,14 @@ function link_pairs(state) {
 	const tokens_meta = state.tokens_meta;
 	const max = state.tokens_meta.length;
 	processDelimiters(state.delimiters);
-	for (let curr = 0; curr < max; curr++) if (tokens_meta[curr] && tokens_meta[curr].delimiters) processDelimiters(tokens_meta[curr].delimiters);
+	for (let curr = 0; curr < max; curr++) {
+		var _tokens_meta$curr;
+		const delimiters = (_tokens_meta$curr = tokens_meta[curr]) === null || _tokens_meta$curr === void 0 ? void 0 : _tokens_meta$curr.delimiters;
+		if (delimiters) processDelimiters(delimiters);
+	}
 }
 //#endregion
-//#region lib/rules_inline/fragments_join.mjs
+//#region src/rules_inline/fragments_join.ts
 function fragments_join(state) {
 	let curr, last;
 	let level = 0;
@@ -3229,12 +3321,7 @@ function fragments_join(state) {
 	if (curr !== last) tokens.length = last;
 }
 //#endregion
-//#region lib/parser_inline.mjs
-/** internal
-* class ParserInline
-*
-* Tokenizes paragraph content.
-**/
+//#region src/parser_inline.ts
 var _rules = [
 	["text", text],
 	["linkify", linkify],
@@ -3256,87 +3343,91 @@ var _rules2 = [
 	["fragments_join", fragments_join]
 ];
 /**
-* new ParserInline()
-**/
-function ParserInline() {
-	/**
-	* ParserInline#ruler -> Ruler
-	*
-	* [[Ruler]] instance. Keep configuration of inline rules.
-	**/
-	this.ruler = new Ruler();
-	for (let i = 0; i < _rules.length; i++) this.ruler.push(_rules[i][0], _rules[i][1]);
-	/**
-	* ParserInline#ruler2 -> Ruler
-	*
-	* [[Ruler]] instance. Second ruler used for post-processing
-	* (e.g. in emphasis-like rules).
-	**/
-	this.ruler2 = new Ruler();
-	for (let i = 0; i < _rules2.length; i++) this.ruler2.push(_rules2[i][0], _rules2[i][1]);
-}
-ParserInline.prototype.skipToken = function(state) {
-	const pos = state.pos;
-	const rules = this.ruler.getRules("");
-	const len = rules.length;
-	const maxNesting = state.md.options.maxNesting;
-	const cache = state.cache;
-	if (typeof cache[pos] !== "undefined") {
-		state.pos = cache[pos];
-		return;
-	}
-	let ok = false;
-	if (state.level < maxNesting) for (let i = 0; i < len; i++) {
-		state.level++;
-		ok = rules[i](state, true);
-		state.level--;
-		if (ok) {
-			if (pos >= state.pos) throw new Error("inline rule didn't increment state.pos");
-			break;
+* Tokenizes paragraph content.
+*/
+var ParserInline = class {
+	constructor() {
+		_defineProperty(
+			this,
+			/**
+			* {@link Ruler} instance. Keep configuration of inline rules.
+			*/
+			"ruler",
+			new Ruler()
+		);
+		_defineProperty(
+			this,
+			/**
+			* {@link Ruler} instance. Second ruler used for post-processing
+			* (e.g. in emphasis-like rules).
+			*/
+			"ruler2",
+			new Ruler()
+		);
+		_defineProperty(this, "State", StateInline);
+		for (let i = 0; i < _rules.length; i++) this.ruler.push(_rules[i][0], _rules[i][1]);
+		for (let i = 0; i < _rules2.length; i++) this.ruler2.push(_rules2[i][0], _rules2[i][1]);
+	}
+	skipToken(state) {
+		const pos = state.pos;
+		const rules = this.ruler.getRules("");
+		const len = rules.length;
+		const maxNesting = state.md.options.maxNesting;
+		const cache = state.cache;
+		if (typeof cache[pos] !== "undefined") {
+			state.pos = cache[pos];
+			return;
 		}
-	}
-	else state.pos = state.posMax;
-	if (!ok) state.pos++;
-	cache[pos] = state.pos;
-};
-ParserInline.prototype.tokenize = function(state) {
-	const rules = this.ruler.getRules("");
-	const len = rules.length;
-	const end = state.posMax;
-	const maxNesting = state.md.options.maxNesting;
-	while (state.pos < end) {
-		const prevPos = state.pos;
 		let ok = false;
 		if (state.level < maxNesting) for (let i = 0; i < len; i++) {
-			ok = rules[i](state, false);
+			state.level++;
+			ok = rules[i](state, true);
+			state.level--;
 			if (ok) {
-				if (prevPos >= state.pos) throw new Error("inline rule didn't increment state.pos");
+				if (pos >= state.pos) throw new Error("inline rule didn't increment state.pos");
 				break;
 			}
 		}
-		if (ok) {
-			if (state.pos >= end) break;
-			continue;
+		else state.pos = state.posMax;
+		if (!ok) state.pos++;
+		cache[pos] = state.pos;
+	}
+	tokenize(state) {
+		const rules = this.ruler.getRules("");
+		const len = rules.length;
+		const end = state.posMax;
+		const maxNesting = state.md.options.maxNesting;
+		while (state.pos < end) {
+			const prevPos = state.pos;
+			let ok = false;
+			if (state.level < maxNesting) for (let i = 0; i < len; i++) {
+				ok = rules[i](state, false);
+				if (ok) {
+					if (prevPos >= state.pos) throw new Error("inline rule didn't increment state.pos");
+					break;
+				}
+			}
+			if (ok) {
+				if (state.pos >= end) break;
+				continue;
+			}
+			state.pending += state.src[state.pos++];
 		}
-		state.pending += state.src[state.pos++];
+		if (state.pending) state.pushPending();
+	}
+	/**
+	* Process input string and push inline tokens into `outTokens`
+	*/
+	parse(str, md, env, outTokens) {
+		const state = new this.State(str, md, env, outTokens);
+		this.tokenize(state);
+		const rules = this.ruler2.getRules("");
+		const len = rules.length;
+		for (let i = 0; i < len; i++) rules[i](state);
 	}
-	if (state.pending) state.pushPending();
-};
-/**
-* ParserInline.parse(str, md, env, outTokens)
-*
-* Process input string and push inline tokens into `outTokens`
-**/
-ParserInline.prototype.parse = function(str, md, env, outTokens) {
-	const state = new this.State(str, md, env, outTokens);
-	this.tokenize(state);
-	const rules = this.ruler2.getRules("");
-	const len = rules.length;
-	for (let i = 0; i < len; i++) rules[i](state);
 };
-ParserInline.prototype.State = StateInline;
 //#endregion
-//#region lib/index.mjs
+//#region src/markdownit.ts
 var config = {
 	default: {
 		options: {
@@ -3372,6 +3463,7 @@ var config = {
 			core: { rules: [
 				"normalize",
 				"block",
+				"strip_references",
 				"inline",
 				"text_join"
 			] },
@@ -3398,6 +3490,7 @@ var config = {
 			core: { rules: [
 				"normalize",
 				"block",
+				"strip_references",
 				"inline",
 				"text_join"
 			] },
@@ -3437,465 +3530,351 @@ var config = {
 };
 var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
 var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
-function validateLink(url) {
-	const str = url.trim().toLowerCase();
-	return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true;
-}
 var RECODE_HOSTNAME_FOR = [
 	"http:",
 	"https:",
 	"mailto:"
 ];
-function normalizeLink(url) {
-	const parsed = mdurl.parse(url, true);
-	if (parsed.hostname) {
-		if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) try {
-			parsed.hostname = punycode_js.default.toASCII(parsed.hostname);
-		} catch (er) {}
-	}
-	return mdurl.encode(mdurl.format(parsed));
-}
-function normalizeLinkText(url) {
-	const parsed = mdurl.parse(url, true);
-	if (parsed.hostname) {
-		if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) try {
-			parsed.hostname = punycode_js.default.toUnicode(parsed.hostname);
-		} catch (er) {}
-	}
-	return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + "%");
-}
-/**
-* class MarkdownIt
-*
-* Main parser/renderer class.
-*
-* ##### Usage
-*
-* ```javascript
-* // node.js, "classic" way:
-* var MarkdownIt = require('markdown-it'),
-*     md = new MarkdownIt();
-* var result = md.render('# markdown-it rulezz!');
-*
-* // node.js, the same, but with sugar:
-* var md = require('markdown-it')();
-* var result = md.render('# markdown-it rulezz!');
-*
-* // browser without AMD, added to "window" on script load
-* // Note, there are no dash.
-* var md = window.markdownit();
-* var result = md.render('# markdown-it rulezz!');
-* ```
-*
-* Single line rendering, without paragraph wrap:
-*
-* ```javascript
-* var md = require('markdown-it')();
-* var result = md.renderInline('__markdown-it__ rulezz!');
-* ```
-**/
 /**
-* new MarkdownIt([presetName, options])
-* - presetName (String): optional, `commonmark` / `zero`
-* - options (Object)
-*
-* Creates parser instanse with given config. Can be called without `new`.
-*
-* ##### presetName
-*
-* MarkdownIt provides named presets as a convenience to quickly
-* enable/disable active syntax rules and options for common use cases.
-*
-* - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -
-*   configures parser to strict [CommonMark](http://commonmark.org/) mode.
-* - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -
-*   similar to GFM, used when no preset name given. Enables all available rules,
-*   but still without html, typographer & autolinker.
-* - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -
-*   all rules disabled. Useful to quickly setup your config via `.enable()`.
-*   For example, when you need only `bold` and `italic` markup and nothing else.
-*
-* ##### options:
-*
-* - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!
-*   That's not safe! You may need external sanitizer to protect output from XSS.
-*   It's better to extend features via plugins, instead of enabling HTML.
-* - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags
-*   (`<br />`). This is needed only for full CommonMark compatibility. In real
-*   world you will need HTML output.
-* - __breaks__ - `false`. Set `true` to convert `\n` in paragraphs into `<br>`.
-* - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.
-*   Can be useful for external highlighters.
-* - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.
-* - __typographer__  - `false`. Set `true` to enable [some language-neutral
-*   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +
-*   quotes beautification (smartquotes).
-* - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement
-*   pairs, when typographer enabled and smartquotes on. For example, you can
-*   use `'«»„“'` for Russian, `'„“‚‘'` for German, and
-*   `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
-* - __highlight__ - `null`. Highlighter function for fenced code blocks.
-*   Highlighter `function (str, lang)` should return escaped HTML. It can also
-*   return empty string if the source was not changed and should be escaped
-*   externaly. If result starts with <pre... internal wrapper is skipped.
-*
-* ##### Example
-*
-* ```javascript
-* // commonmark mode
-* var md = require('markdown-it')('commonmark');
-*
-* // default mode
-* var md = require('markdown-it')();
-*
-* // enable everything
-* var md = require('markdown-it')({
-*   html: true,
-*   linkify: true,
-*   typographer: true
-* });
-* ```
-*
-* ##### Syntax highlighting
-*
-* ```js
-* var hljs = require('highlight.js') // https://highlightjs.org/
+* Parses Markdown into tokens and renders them to HTML.
 *
-* var md = require('markdown-it')({
-*   highlight: function (str, lang) {
-*     if (lang && hljs.getLanguage(lang)) {
-*       try {
-*         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;
-*       } catch (__) {}
-*     }
-*
-*     return ''; // use external default escaping
-*   }
-* });
-* ```
-*
-* Or with full wrapper override (if you need assign class to `<pre>` or `<code>`):
-*
-* ```javascript
-* var hljs = require('highlight.js') // https://highlightjs.org/
-*
-* // Actual default values
-* var md = require('markdown-it')({
-*   highlight: function (str, lang) {
-*     if (lang && hljs.getLanguage(lang)) {
-*       try {
-*         return '<pre><code class="hljs">' +
-*                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +
-*                '</code></pre>';
-*       } catch (__) {}
-*     }
-*
-*     return '<pre><code class="hljs">' + md.utils.escapeHtml(str) + '</code></pre>';
-*   }
-* });
-* ```
-*
-**/
-function MarkdownIt(presetName, options) {
-	if (!(this instanceof MarkdownIt)) return new MarkdownIt(presetName, options);
-	if (!options) {
-		if (!isString(presetName)) {
-			options = presetName || {};
-			presetName = "default";
-		}
-	}
+* @category Main
+*/
+var MarkdownIt = class {
 	/**
-	* MarkdownIt#inline -> ParserInline
+	* Link validation function. CommonMark allows too much in links. By default
+	* we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
+	* except some embedded image types.
 	*
-	* Instance of [[ParserInline]]. You may need it to add new rules when
-	* writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-	* [[MarkdownIt.enable]].
-	**/
-	this.inline = new ParserInline();
-	/**
-	* MarkdownIt#block -> ParserBlock
+	* You can change this behaviour:
 	*
-	* Instance of [[ParserBlock]]. You may need it to add new rules when
-	* writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-	* [[MarkdownIt.enable]].
-	**/
-	this.block = new ParserBlock();
-	/**
-	* MarkdownIt#core -> Core
+	* @example
+	* ```javascript
+	* import MarkdownIt from 'markdown-it'
+	* const md = new MarkdownIt()
 	*
-	* Instance of [[Core]] chain executor. You may need it to add new rules when
-	* writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-	* [[MarkdownIt.enable]].
-	**/
-	this.core = new Core();
+	* // enable everything
+	* md.validateLink = function () { return true; }
+	* ```
+	*/
+	validateLink(url) {
+		const str = url.trim().toLowerCase();
+		return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true;
+	}
 	/**
-	* MarkdownIt#renderer -> Renderer
-	*
-	* Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
-	* rules for new token types, generated by plugins.
+	* Function used to encode link url to a machine-readable format,
+	* which includes url-encoding, punycode, etc.
+	*/
+	normalizeLink(url) {
+		const parsed = mdurl.parse(url, true);
+		if (parsed.hostname) {
+			if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) try {
+				parsed.hostname = punycode.toASCII(parsed.hostname);
+			} catch (er) {}
+		}
+		if (parsed.auth) parsed.auth = mdurl.encode(parsed.auth);
+		if (parsed.hostname) parsed.hostname = mdurl.encode(parsed.hostname);
+		if (parsed.pathname) parsed.pathname = mdurl.encode(parsed.pathname);
+		if (parsed.search) parsed.search = mdurl.encode(parsed.search);
+		if (parsed.hash) parsed.hash = mdurl.encode(parsed.hash);
+		return mdurl.format(parsed);
+	}
+	/**
+	* Function used to decode link url to a human-readable format`
+	*/
+	normalizeLinkText(url) {
+		const parsed = mdurl.parse(url, true);
+		if (parsed.hostname) {
+			if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) try {
+				parsed.hostname = punycode.toUnicode(parsed.hostname);
+			} catch (er) {}
+		}
+		return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + "%");
+	}
+	constructor(...args) {
+		_defineProperty(
+			this,
+			/**
+			* Instance of {@link ParserInline}. You may need it to add new rules when
+			* writing plugins. For simple rules control use {@link MarkdownIt.disable}
+			* and {@link MarkdownIt.enable}.
+			*/
+			"inline",
+			new ParserInline()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Instance of {@link ParserBlock}. You may need it to add new rules when
+			* writing plugins. For simple rules control use {@link MarkdownIt.disable}
+			* and {@link MarkdownIt.enable}.
+			*/
+			"block",
+			new ParserBlock()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Instance of {@link ParserCore} chain executor. You may need it to add new
+			* rules when writing plugins. For simple rules control use
+			* {@link MarkdownIt.disable} and {@link MarkdownIt.enable}.
+			*/
+			"core",
+			new ParserCore()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Instance of {@link Renderer}. Use it to modify output look. Or to add rendering
+			* rules for new token types, generated by plugins.
+			*
+			* See {@link Renderer} docs and
+			* [source code](https://github.com/markdown-it/markdown-it/blob/master/src/renderer.ts).
+			*
+			* @example
+			* ```javascript
+			* import MarkdownIt from 'markdown-it'
+			* const md = new MarkdownIt()
+			*
+			* function myToken(tokens, idx, options, env, self) {
+			*   //...
+			*   return result;
+			* };
+			*
+			* md.renderer.rules['my_token'] = myToken
+			* ```
+			*/
+			"renderer",
+			new Renderer()
+		);
+		_defineProperty(
+			this,
+			/**
+			* [linkify-it](https://github.com/markdown-it/linkify-it) instance.
+			* Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/src/rules_core/linkify.ts)
+			* rule.
+			*/
+			"linkify",
+			new LinkifyIt()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Assorted utility functions, useful to write plugins. See details
+			* [here](https://github.com/markdown-it/markdown-it/blob/master/src/common/utils.ts).
+			*/
+			"utils",
+			utils_exports
+		);
+		_defineProperty(
+			this,
+			/**
+			* Link components parser functions, useful to write plugins. See details
+			* [here](https://github.com/markdown-it/markdown-it/blob/master/src/helpers).
+			*/
+			"helpers",
+			Object.assign({}, helpers_exports)
+		);
+		const [presetNameOrOptions, options] = args;
+		if (typeof presetNameOrOptions === "string") {
+			this.configure(presetNameOrOptions);
+			if (options) this.set(options);
+		} else {
+			this.configure("default");
+			this.set(presetNameOrOptions || {});
+		}
+	}
+	/**
+	* Set parser options (in the same format as in constructor). Probably, you
+	* will never need it, but you can change options after constructor call.
 	*
-	* ##### Example
+	* __Note:__ To achieve the best possible performance, don't modify a
+	* `markdown-it` instance options on the fly. If you need multiple configurations
+	* it's best to create multiple instances and initialize each with separate
+	* config.
 	*
+	* @example
 	* ```javascript
-	* var md = require('markdown-it')();
-	*
-	* function myToken(tokens, idx, options, env, self) {
-	*   //...
-	*   return result;
-	* };
+	* import MarkdownIt from 'markdown-it'
 	*
-	* md.renderer.rules['my_token'] = myToken
+	* const md = new MarkdownIt()
+	*   .set({ html: true, breaks: true })
+	*   .set({ typographer: true })
 	* ```
-	*
-	* See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).
-	**/
-	this.renderer = new Renderer();
+	*/
+	set(options) {
+		Object.assign(this.options, options);
+		return this;
+	}
 	/**
-	* MarkdownIt#linkify -> LinkifyIt
+	* Batch load of all options and compenent settings. This is internal method,
+	* and you probably will not need it. But if you will - see available presets
+	* and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/src/presets)
 	*
-	* [linkify-it](https://github.com/markdown-it/linkify-it) instance.
-	* Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)
-	* rule.
-	**/
-	this.linkify = new linkify_it.default();
+	* We strongly recommend to use presets instead of direct config loads. That
+	* will give better compatibility with next versions.
+	*/
+	configure(presets) {
+		let p;
+		if (typeof presets === "string") {
+			const presetName = presets;
+			p = config[presetName];
+			if (!p) throw new Error(`Wrong 'markdown-it' preset "${presetName}", check name`);
+		} else p = presets;
+		if (!p) throw new Error("Wrong `markdown-it` preset, can't be empty");
+		if (p.options) this.options = { ...p.options };
+		const components = p.components;
+		if (components) {
+			var _components$inline;
+			[
+				"core",
+				"block",
+				"inline"
+			].forEach((name) => {
+				var _components$name;
+				const rules = (_components$name = components[name]) === null || _components$name === void 0 ? void 0 : _components$name.rules;
+				if (rules) this[name].ruler.enableOnly(rules);
+			});
+			const rules2 = (_components$inline = components.inline) === null || _components$inline === void 0 ? void 0 : _components$inline.rules2;
+			if (rules2) this.inline.ruler2.enableOnly(rules2);
+		}
+		return this;
+	}
 	/**
-	* MarkdownIt#validateLink(url) -> Boolean
+	* Enable list or rules. It will automatically find appropriate components,
+	* containing rules with given names. If rule not found, and `ignoreInvalid`
+	* not set - throws exception.
 	*
-	* Link validation function. CommonMark allows too much in links. By default
-	* we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
-	* except some embedded image types.
+	* @example
+	* ```javascript
+	* import MarkdownIt from 'markdown-it'
 	*
-	* You can change this behaviour:
+	* const md = new MarkdownIt()
+	*   .enable(['sub', 'sup'])
+	*   .disable('smartquotes')
+	* ```
+	*/
+	enable(list, ignoreInvalid = false) {
+		let result = [];
+		if (!Array.isArray(list)) list = [list];
+		[
+			"core",
+			"block",
+			"inline"
+		].forEach((chain) => {
+			result = result.concat(this[chain].ruler.enable(list, true));
+		});
+		result = result.concat(this.inline.ruler2.enable(list, true));
+		const missed = list.filter((name) => result.indexOf(name) < 0);
+		if (missed.length && !ignoreInvalid) throw new Error(`MarkdownIt. Failed to enable unknown rule(s): ${missed}`);
+		return this;
+	}
+	/**
+	* The same as {@link MarkdownIt.enable}, but turn specified rules off.
+	*/
+	disable(list, ignoreInvalid = false) {
+		let result = [];
+		if (!Array.isArray(list)) list = [list];
+		[
+			"core",
+			"block",
+			"inline"
+		].forEach((chain) => {
+			result = result.concat(this[chain].ruler.disable(list, true));
+		});
+		result = result.concat(this.inline.ruler2.disable(list, true));
+		const missed = list.filter((name) => result.indexOf(name) < 0);
+		if (missed.length && !ignoreInvalid) throw new Error(`MarkdownIt. Failed to disable unknown rule(s): ${missed}`);
+		return this;
+	}
+	/**
+	* Load specified plugin with given params into current parser instance.
+	* It's just a sugar to call `plugin(md, params)` with curring.
 	*
+	* @example
 	* ```javascript
-	* var md = require('markdown-it')();
-	* // enable everything
-	* md.validateLink = function () { return true; }
+	* import MarkdownIt from 'markdown-it'
+	* import iterator from 'markdown-it-for-inline'
+	*
+	* const md = new MarkdownIt()
+	*   .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
+	*     tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar')
+	*   })
 	* ```
-	**/
-	this.validateLink = validateLink;
+	*/
+	use(plugin, ...params) {
+		plugin.apply(plugin, [this, ...params]);
+		return this;
+	}
 	/**
-	* MarkdownIt#normalizeLink(url) -> String
+	* Parse input string and return list of block tokens (special token type
+	* "inline" will contain list of inline tokens). You should not call this
+	* method directly, until you write custom renderer (for example, to produce
+	* AST).
 	*
-	* Function used to encode link url to a machine-readable format,
-	* which includes url-encoding, punycode, etc.
-	**/
-	this.normalizeLink = normalizeLink;
+	* `env` is used to pass data between "distributed" rules and return additional
+	* metadata like reference info, needed for the renderer. It also can be used to
+	* inject data in specific cases. Usually, you will be ok to pass `{}`,
+	* and then pass updated object to renderer.
+	*/
+	parse(src, env) {
+		if (typeof src !== "string") throw new Error("Input data should be a String");
+		const state = new this.core.State(src, this, env);
+		this.core.process(state);
+		return state.tokens;
+	}
 	/**
-	* MarkdownIt#normalizeLinkText(url) -> String
+	* Render markdown string into html. It does all magic for you :).
 	*
-	* Function used to decode link url to a human-readable format`
-	**/
-	this.normalizeLinkText = normalizeLinkText;
+	* `env` can be used to inject additional metadata (`{}` by default).
+	* But you will not need it with high probability. See also comment
+	* in {@link MarkdownIt.parse}.
+	*/
+	render(src, env = {}) {
+		return this.renderer.render(this.parse(src, env), this.options, env);
+	}
 	/**
-	* MarkdownIt#utils -> utils
-	*
-	* Assorted utility functions, useful to write plugins. See details
-	* [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).
-	**/
-	this.utils = utils_exports;
+	* The same as {@link MarkdownIt.parse} but skip all block rules. It returns
+	* the block tokens list with the single `inline` element, containing parsed
+	* inline tokens in `children` property. Also updates `env` object.
+	*/
+	parseInline(src, env) {
+		const state = new this.core.State(src, this, env);
+		state.inlineMode = true;
+		this.core.process(state);
+		return state.tokens;
+	}
 	/**
-	* MarkdownIt#helpers -> helpers
-	*
-	* Link components parser functions, useful to write plugins. See details
-	* [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).
-	**/
-	this.helpers = assign({}, helpers_exports);
-	this.options = {};
-	this.configure(presetName);
-	if (options) this.set(options);
-}
-/** chainable
-* MarkdownIt.set(options)
-*
-* Set parser options (in the same format as in constructor). Probably, you
-* will never need it, but you can change options after constructor call.
-*
-* ##### Example
-*
-* ```javascript
-* var md = require('markdown-it')()
-*             .set({ html: true, breaks: true })
-*             .set({ typographer: true });
-* ```
-*
-* __Note:__ To achieve the best possible performance, don't modify a
-* `markdown-it` instance options on the fly. If you need multiple configurations
-* it's best to create multiple instances and initialize each with separate
-* config.
-**/
-MarkdownIt.prototype.set = function(options) {
-	assign(this.options, options);
-	return this;
-};
-/** chainable, internal
-* MarkdownIt.configure(presets)
-*
-* Batch load of all options and compenent settings. This is internal method,
-* and you probably will not need it. But if you will - see available presets
-* and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
-*
-* We strongly recommend to use presets instead of direct config loads. That
-* will give better compatibility with next versions.
-**/
-MarkdownIt.prototype.configure = function(presets) {
-	const self = this;
-	if (isString(presets)) {
-		const presetName = presets;
-		presets = config[presetName];
-		if (!presets) throw new Error("Wrong `markdown-it` preset \"" + presetName + "\", check name");
-	}
-	if (!presets) throw new Error("Wrong `markdown-it` preset, can't be empty");
-	if (presets.options) self.set(presets.options);
-	if (presets.components) Object.keys(presets.components).forEach(function(name) {
-		if (presets.components[name].rules) self[name].ruler.enableOnly(presets.components[name].rules);
-		if (presets.components[name].rules2) self[name].ruler2.enableOnly(presets.components[name].rules2);
-	});
-	return this;
-};
-/** chainable
-* MarkdownIt.enable(list, ignoreInvalid)
-* - list (String|Array): rule name or list of rule names to enable
-* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
-*
-* Enable list or rules. It will automatically find appropriate components,
-* containing rules with given names. If rule not found, and `ignoreInvalid`
-* not set - throws exception.
-*
-* ##### Example
-*
-* ```javascript
-* var md = require('markdown-it')()
-*             .enable(['sub', 'sup'])
-*             .disable('smartquotes');
-* ```
-**/
-MarkdownIt.prototype.enable = function(list, ignoreInvalid) {
-	let result = [];
-	if (!Array.isArray(list)) list = [list];
-	[
-		"core",
-		"block",
-		"inline"
-	].forEach(function(chain) {
-		result = result.concat(this[chain].ruler.enable(list, true));
-	}, this);
-	result = result.concat(this.inline.ruler2.enable(list, true));
-	const missed = list.filter(function(name) {
-		return result.indexOf(name) < 0;
-	});
-	if (missed.length && !ignoreInvalid) throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + missed);
-	return this;
-};
-/** chainable
-* MarkdownIt.disable(list, ignoreInvalid)
-* - list (String|Array): rule name or list of rule names to disable.
-* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
-*
-* The same as [[MarkdownIt.enable]], but turn specified rules off.
-**/
-MarkdownIt.prototype.disable = function(list, ignoreInvalid) {
-	let result = [];
-	if (!Array.isArray(list)) list = [list];
-	[
-		"core",
-		"block",
-		"inline"
-	].forEach(function(chain) {
-		result = result.concat(this[chain].ruler.disable(list, true));
-	}, this);
-	result = result.concat(this.inline.ruler2.disable(list, true));
-	const missed = list.filter(function(name) {
-		return result.indexOf(name) < 0;
-	});
-	if (missed.length && !ignoreInvalid) throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + missed);
-	return this;
-};
-/** chainable
-* MarkdownIt.use(plugin, params)
-*
-* Load specified plugin with given params into current parser instance.
-* It's just a sugar to call `plugin(md, params)` with curring.
-*
-* ##### Example
-*
-* ```javascript
-* var iterator = require('markdown-it-for-inline');
-* var md = require('markdown-it')()
-*             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
-*               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
-*             });
-* ```
-**/
-MarkdownIt.prototype.use = function(plugin) {
-	const args = [this].concat(Array.prototype.slice.call(arguments, 1));
-	plugin.apply(plugin, args);
-	return this;
-};
-/** internal
-* MarkdownIt.parse(src, env) -> Array
-* - src (String): source string
-* - env (Object): environment sandbox
-*
-* Parse input string and return list of block tokens (special token type
-* "inline" will contain list of inline tokens). You should not call this
-* method directly, until you write custom renderer (for example, to produce
-* AST).
-*
-* `env` is used to pass data between "distributed" rules and return additional
-* metadata like reference info, needed for the renderer. It also can be used to
-* inject data in specific cases. Usually, you will be ok to pass `{}`,
-* and then pass updated object to renderer.
-**/
-MarkdownIt.prototype.parse = function(src, env) {
-	if (typeof src !== "string") throw new Error("Input data should be a String");
-	const state = new this.core.State(src, this, env);
-	this.core.process(state);
-	return state.tokens;
+	* Similar to {@link MarkdownIt.render} but for single paragraph content.
+	* Result will NOT be wrapped into `<p>` tags.
+	*/
+	renderInline(src, env = {}) {
+		return this.renderer.render(this.parseInline(src, env), this.options, env);
+	}
 };
+_defineProperty(MarkdownIt, "Token", Token);
+_defineProperty(MarkdownIt, "Ruler", Ruler);
+_defineProperty(MarkdownIt, "Renderer", Renderer);
+_defineProperty(MarkdownIt, "ParserCore", ParserCore);
+_defineProperty(MarkdownIt, "StateCore", StateCore);
+_defineProperty(MarkdownIt, "ParserBlock", ParserBlock);
+_defineProperty(MarkdownIt, "StateBlock", StateBlock);
+_defineProperty(MarkdownIt, "ParserInline", ParserInline);
+_defineProperty(MarkdownIt, "StateInline", StateInline);
+//#endregion
+//#region src/index.ts
 /**
-* MarkdownIt.render(src [, env]) -> String
-* - src (String): source string
-* - env (Object): environment sandbox
-*
-* Render markdown string into html. It does all magic for you :).
-*
-* `env` can be used to inject additional metadata (`{}` by default).
-* But you will not need it with high probability. See also comment
-* in [[MarkdownIt.parse]].
-**/
-MarkdownIt.prototype.render = function(src, env) {
-	env = env || {};
-	return this.renderer.render(this.parse(src, env), this.options, env);
-};
-/** internal
-* MarkdownIt.parseInline(src, env) -> Array
-* - src (String): source string
-* - env (Object): environment sandbox
+* Default package export.
 *
-* The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
-* block tokens list with the single `inline` element, containing parsed inline
-* tokens in `children` property. Also updates `env` object.
-**/
-MarkdownIt.prototype.parseInline = function(src, env) {
-	const state = new this.core.State(src, this, env);
-	state.inlineMode = true;
-	this.core.process(state);
-	return state.tokens;
-};
-/**
-* MarkdownIt.renderInline(src [, env]) -> String
-* - src (String): source string
-* - env (Object): environment sandbox
+* For backward compatibility, the {@link MarkdownIt} class is wrapped so
+* legacy code can call it without `new`. New code should instantiate it as a
+* regular class with `new`. The compatibility wrapper may be removed in a
+* future release.
 *
-* Similar to [[MarkdownIt.render]] but for single paragraph content. Result
-* will NOT be wrapped into `<p>` tags.
-**/
-MarkdownIt.prototype.renderInline = function(src, env) {
-	env = env || {};
-	return this.renderer.render(this.parseInline(src, env), this.options, env);
-};
+* @category Main
+*/
+var MarkdownItCallable = callable(MarkdownIt);
 //#endregion
-module.exports = MarkdownIt;
+export { MarkdownItCallable as default };
 
-//# sourceMappingURL=index.cjs.js.map
+//# sourceMappingURL=markdown-it.mjs.map