@shell-shock/preset-cli 0.9.11 → 0.9.13

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_block.mjs

@@ -0,0 +1,149 @@
+import Ruler from "./ruler.mjs";
+import StateBlock from "./rules_block/state_block.mjs";
+import table from "./rules_block/table.mjs";
+import code from "./rules_block/code.mjs";
+import fence from "./rules_block/fence.mjs";
+import blockquote from "./rules_block/blockquote.mjs";
+import hr from "./rules_block/hr.mjs";
+import list from "./rules_block/list.mjs";
+import reference from "./rules_block/reference.mjs";
+import html_block from "./rules_block/html_block.mjs";
+import heading from "./rules_block/heading.mjs";
+import lheading from "./rules_block/lheading.mjs";
+import paragraph from "./rules_block/paragraph.mjs";
+
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_block.mjs
+/** internal
+* class ParserBlock
+*
+* Block-level tokenizer.
+**/
+const _rules = [
+	[
+		"table",
+		table,
+		["paragraph", "reference"]
+	],
+	["code", code],
+	[
+		"fence",
+		fence,
+		[
+			"paragraph",
+			"reference",
+			"blockquote",
+			"list"
+		]
+	],
+	[
+		"blockquote",
+		blockquote,
+		[
+			"paragraph",
+			"reference",
+			"blockquote",
+			"list"
+		]
+	],
+	[
+		"hr",
+		hr,
+		[
+			"paragraph",
+			"reference",
+			"blockquote",
+			"list"
+		]
+	],
+	[
+		"list",
+		list,
+		[
+			"paragraph",
+			"reference",
+			"blockquote"
+		]
+	],
+	["reference", reference],
+	[
+		"html_block",
+		html_block,
+		[
+			"paragraph",
+			"reference",
+			"blockquote"
+		]
+	],
+	[
+		"heading",
+		heading,
+		[
+			"paragraph",
+			"reference",
+			"blockquote"
+		]
+	],
+	["lheading", lheading],
+	["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.length; i++) this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[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");
+				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;
+		}
+	}
+};
+/**
+* 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
+export { ParserBlock as default };
+//# sourceMappingURL=parser_block.mjs.map

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_block.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser_block.mjs","names":["r_table","r_code","r_fence","r_blockquote","r_hr","r_list","r_reference","r_html_block","r_heading","r_lheading","r_paragraph"],"sources":["../../../../../../../../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_block.mjs"],"sourcesContent":["/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n\nimport Ruler from './ruler.mjs'\nimport StateBlock from './rules_block/state_block.mjs'\n\nimport r_table from './rules_block/table.mjs'\nimport r_code from './rules_block/code.mjs'\nimport r_fence from './rules_block/fence.mjs'\nimport r_blockquote from './rules_block/blockquote.mjs'\nimport r_hr from './rules_block/hr.mjs'\nimport r_list from './rules_block/list.mjs'\nimport r_reference from './rules_block/reference.mjs'\nimport r_html_block from './rules_block/html_block.mjs'\nimport r_heading from './rules_block/heading.mjs'\nimport r_lheading from './rules_block/lheading.mjs'\nimport r_paragraph from './rules_block/paragraph.mjs'\n\nconst _rules = [\n  // First 2 params - rule name & source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  ['table',      r_table,      ['paragraph', 'reference']],\n  ['code',       r_code],\n  ['fence',      r_fence,      ['paragraph', 'reference', 'blockquote', 'list']],\n  ['blockquote', r_blockquote, ['paragraph', 'reference', 'blockquote', 'list']],\n  ['hr',         r_hr,         ['paragraph', 'reference', 'blockquote', 'list']],\n  ['list',       r_list,       ['paragraph', 'reference', 'blockquote']],\n  ['reference',  r_reference],\n  ['html_block', r_html_block, ['paragraph', 'reference', 'blockquote']],\n  ['heading',    r_heading,    ['paragraph', 'reference', 'blockquote']],\n  ['lheading',   r_lheading],\n  ['paragraph',  r_paragraph]\n]\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock () {\n  /**\n   * ParserBlock#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() })\n  }\n}\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  const rules = this.ruler.getRules('')\n  const len = rules.length\n  const maxNesting = state.md.options.maxNesting\n  let line = startLine\n  let hasEmptyLines = false\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line)\n    if (line >= endLine) { break }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.sCount[line] < state.blkIndent) { break }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level >= maxNesting) {\n      state.line = endLine\n      break\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n    const prevLine = state.line\n    let ok = false\n\n    for (let i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false)\n      if (ok) {\n        if (prevLine >= state.line) {\n          throw new Error(\"block rule didn't increment state.line\")\n        }\n        break\n      }\n    }\n\n    // this can only happen if user disables paragraph rule\n    if (!ok) throw new Error('none of the block rules matched')\n\n    // set state.tight if we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true\n    }\n\n    line = state.line\n\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true\n      line++\n      state.line = line\n    }\n  }\n}\n\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  if (!src) { return }\n\n  const state = new this.State(src, md, env, outTokens)\n\n  this.tokenize(state, state.line, state.lineMax)\n}\n\nParserBlock.prototype.State = StateBlock\n\nexport default ParserBlock\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,SAAS;CAGb;EAAC;EAAcA;EAAc,CAAC,aAAa,YAAY;EAAC;CACxD,CAAC,QAAcC,KAAO;CACtB;EAAC;EAAcC;EAAc;GAAC;GAAa;GAAa;GAAc;GAAO;EAAC;CAC9E;EAAC;EAAcC;EAAc;GAAC;GAAa;GAAa;GAAc;GAAO;EAAC;CAC9E;EAAC;EAAcC;EAAc;GAAC;GAAa;GAAa;GAAc;GAAO;EAAC;CAC9E;EAAC;EAAcC;EAAc;GAAC;GAAa;GAAa;GAAa;EAAC;CACtE,CAAC,aAAcC,UAAY;CAC3B;EAAC;EAAcC;EAAc;GAAC;GAAa;GAAa;GAAa;EAAC;CACtE;EAAC;EAAcC;EAAc;GAAC;GAAa;GAAa;GAAa;EAAC;CACtE,CAAC,YAAcC,SAAW;CAC1B,CAAC,aAAcC,UAAY;CAC5B;;;;AAKD,SAAS,cAAe;;;;;;AAMtB,MAAK,QAAQ,IAAI,OAAO;AAExB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,MAAK,MAAM,KAAK,OAAO,GAAG,IAAI,OAAO,GAAG,IAAI,EAAE,MAAM,OAAO,GAAG,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC;;AAMtF,YAAY,UAAU,WAAW,SAAU,OAAO,WAAW,SAAS;CACpE,MAAM,QAAQ,KAAK,MAAM,SAAS,GAAG;CACrC,MAAM,MAAM,MAAM;CAClB,MAAM,aAAa,MAAM,GAAG,QAAQ;CACpC,IAAI,OAAO;CACX,IAAI,gBAAgB;AAEpB,QAAO,OAAO,SAAS;AACrB,QAAM,OAAO,OAAO,MAAM,eAAe,KAAK;AAC9C,MAAI,QAAQ,QAAW;AAIvB,MAAI,MAAM,OAAO,QAAQ,MAAM,UAAa;AAI5C,MAAI,MAAM,SAAS,YAAY;AAC7B,SAAM,OAAO;AACb;;EASF,MAAM,WAAW,MAAM;EACvB,IAAI,KAAK;AAET,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,QAAK,MAAM,GAAG,OAAO,MAAM,SAAS,MAAM;AAC1C,OAAI,IAAI;AACN,QAAI,YAAY,MAAM,KACpB,OAAM,IAAI,MAAM,yCAAyC;AAE3D;;;AAKJ,MAAI,CAAC,GAAI,OAAM,IAAI,MAAM,kCAAkC;AAI3D,QAAM,QAAQ,CAAC;AAGf,MAAI,MAAM,QAAQ,MAAM,OAAO,EAAE,CAC/B,iBAAgB;AAGlB,SAAO,MAAM;AAEb,MAAI,OAAO,WAAW,MAAM,QAAQ,KAAK,EAAE;AACzC,mBAAgB;AAChB;AACA,SAAM,OAAO;;;;;;;;;AAUnB,YAAY,UAAU,QAAQ,SAAU,KAAK,IAAI,KAAK,WAAW;AAC/D,KAAI,CAAC,IAAO;CAEZ,MAAM,QAAQ,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,UAAU;AAErD,MAAK,SAAS,OAAO,MAAM,MAAM,MAAM,QAAQ;;AAGjD,YAAY,UAAU,QAAQ"}

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_core.cjs

@@ -0,0 +1,51 @@
+const require_ruler = require('./ruler.cjs');
+const require_state_core = require('./rules_core/state_core.cjs');
+const require_normalize = require('./rules_core/normalize.cjs');
+const require_block = require('./rules_core/block.cjs');
+const require_inline = require('./rules_core/inline.cjs');
+const require_linkify = require('./rules_core/linkify.cjs');
+const require_replacements = require('./rules_core/replacements.cjs');
+const require_smartquotes = require('./rules_core/smartquotes.cjs');
+const require_text_join = require('./rules_core/text_join.cjs');
+
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_core.mjs
+/** internal
+* class Core
+*
+* Top-level rules executor. Glues block/inline parsers and does intermediate
+* transformations.
+**/
+const _rules = [
+	["normalize", require_normalize.default],
+	["block", require_block.default],
+	["inline", require_inline.default],
+	["linkify", require_linkify.default],
+	["replacements", require_replacements.default],
+	["smartquotes", require_smartquotes.default],
+	["text_join", require_text_join.default]
+];
+/**
+* new Core()
+**/
+function Core() {
+	/**
+	* Core#ruler -> Ruler
+	*
+	* [[Ruler]] instance. Keep configuration of core rules.
+	**/
+	this.ruler = new require_ruler.default();
+	for (let i = 0; i < _rules.length; i++) this.ruler.push(_rules[i][0], _rules[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);
+};
+Core.prototype.State = require_state_core.default;
+
+//#endregion
+exports.default = Core;

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_core.mjs

@@ -0,0 +1,52 @@
+import Ruler from "./ruler.mjs";
+import StateCore from "./rules_core/state_core.mjs";
+import normalize from "./rules_core/normalize.mjs";
+import block from "./rules_core/block.mjs";
+import inline from "./rules_core/inline.mjs";
+import linkify from "./rules_core/linkify.mjs";
+import replace from "./rules_core/replacements.mjs";
+import smartquotes from "./rules_core/smartquotes.mjs";
+import text_join from "./rules_core/text_join.mjs";
+
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_core.mjs
+/** internal
+* class Core
+*
+* Top-level rules executor. Glues block/inline parsers and does intermediate
+* transformations.
+**/
+const _rules = [
+	["normalize", normalize],
+	["block", block],
+	["inline", inline],
+	["linkify", linkify],
+	["replacements", replace],
+	["smartquotes", smartquotes],
+	["text_join", text_join]
+];
+/**
+* new Core()
+**/
+function Core() {
+	/**
+	* Core#ruler -> Ruler
+	*
+	* [[Ruler]] instance. Keep configuration of core rules.
+	**/
+	this.ruler = new Ruler();
+	for (let i = 0; i < _rules.length; i++) this.ruler.push(_rules[i][0], _rules[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);
+};
+Core.prototype.State = StateCore;
+
+//#endregion
+export { Core as default };
+//# sourceMappingURL=parser_core.mjs.map

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_core.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser_core.mjs","names":["r_normalize","r_block","r_inline","r_linkify","r_replacements","r_smartquotes","r_text_join"],"sources":["../../../../../../../../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_core.mjs"],"sourcesContent":["/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n\nimport Ruler from './ruler.mjs'\nimport StateCore from './rules_core/state_core.mjs'\n\nimport r_normalize from './rules_core/normalize.mjs'\nimport r_block from './rules_core/block.mjs'\nimport r_inline from './rules_core/inline.mjs'\nimport r_linkify from './rules_core/linkify.mjs'\nimport r_replacements from './rules_core/replacements.mjs'\nimport r_smartquotes from './rules_core/smartquotes.mjs'\nimport r_text_join from './rules_core/text_join.mjs'\n\nconst _rules = [\n  ['normalize',      r_normalize],\n  ['block',          r_block],\n  ['inline',         r_inline],\n  ['linkify',        r_linkify],\n  ['replacements',   r_replacements],\n  ['smartquotes',    r_smartquotes],\n  // `text_join` finds `text_special` tokens (for escape sequences)\n  // and joins them with the rest of the text\n  ['text_join',      r_text_join]\n]\n\n/**\n * new Core()\n **/\nfunction Core () {\n  /**\n   * Core#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1])\n  }\n}\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  const rules = this.ruler.getRules('')\n\n  for (let i = 0, l = rules.length; i < l; i++) {\n    rules[i](state)\n  }\n}\n\nCore.prototype.State = StateCore\n\nexport default Core\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;AAkBA,MAAM,SAAS;CACb,CAAC,aAAkBA,UAAY;CAC/B,CAAC,SAAkBC,MAAQ;CAC3B,CAAC,UAAkBC,OAAS;CAC5B,CAAC,WAAkBC,QAAU;CAC7B,CAAC,gBAAkBC,QAAe;CAClC,CAAC,eAAkBC,YAAc;CAGjC,CAAC,aAAkBC,UAAY;CAChC;;;;AAKD,SAAS,OAAQ;;;;;;AAMf,MAAK,QAAQ,IAAI,OAAO;AAExB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,MAAK,MAAM,KAAK,OAAO,GAAG,IAAI,OAAO,GAAG,GAAG;;;;;;;AAS/C,KAAK,UAAU,UAAU,SAAU,OAAO;CACxC,MAAM,QAAQ,KAAK,MAAM,SAAS,GAAG;AAErC,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,IAAI,GAAG,IACvC,OAAM,GAAG,MAAM;;AAInB,KAAK,UAAU,QAAQ"}

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_inline.cjs

@@ -0,0 +1,126 @@
+const require_ruler = require('./ruler.cjs');
+const require_state_inline = require('./rules_inline/state_inline.cjs');
+const require_text = require('./rules_inline/text.cjs');
+const require_linkify = require('./rules_inline/linkify.cjs');
+const require_newline = require('./rules_inline/newline.cjs');
+const require_escape = require('./rules_inline/escape.cjs');
+const require_backticks = require('./rules_inline/backticks.cjs');
+const require_strikethrough = require('./rules_inline/strikethrough.cjs');
+const require_emphasis = require('./rules_inline/emphasis.cjs');
+const require_link = require('./rules_inline/link.cjs');
+const require_image = require('./rules_inline/image.cjs');
+const require_autolink = require('./rules_inline/autolink.cjs');
+const require_html_inline = require('./rules_inline/html_inline.cjs');
+const require_entity = require('./rules_inline/entity.cjs');
+const require_balance_pairs = require('./rules_inline/balance_pairs.cjs');
+const require_fragments_join = require('./rules_inline/fragments_join.cjs');
+
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_inline.mjs
+/** internal
+* class ParserInline
+*
+* Tokenizes paragraph content.
+**/
+const _rules = [
+	["text", require_text.default],
+	["linkify", require_linkify.default],
+	["newline", require_newline.default],
+	["escape", require_escape.default],
+	["backticks", require_backticks.default],
+	["strikethrough", require_strikethrough.default.tokenize],
+	["emphasis", require_emphasis.default.tokenize],
+	["link", require_link.default],
+	["image", require_image.default],
+	["autolink", require_autolink.default],
+	["html_inline", require_html_inline.default],
+	["entity", require_entity.default]
+];
+const _rules2 = [
+	["balance_pairs", require_balance_pairs.default],
+	["strikethrough", require_strikethrough.default.postProcess],
+	["emphasis", require_emphasis.default.postProcess],
+	["fragments_join", require_fragments_join.default]
+];
+/**
+* new ParserInline()
+**/
+function ParserInline() {
+	/**
+	* ParserInline#ruler -> Ruler
+	*
+	* [[Ruler]] instance. Keep configuration of inline rules.
+	**/
+	this.ruler = new require_ruler.default();
+	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 require_ruler.default();
+	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;
+		}
+	}
+	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);
+			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++];
+	}
+	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 = require_state_inline.default;
+
+//#endregion
+exports.default = ParserInline;

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_inline.mjs

@@ -0,0 +1,127 @@
+import Ruler from "./ruler.mjs";
+import StateInline from "./rules_inline/state_inline.mjs";
+import text from "./rules_inline/text.mjs";
+import linkify from "./rules_inline/linkify.mjs";
+import newline from "./rules_inline/newline.mjs";
+import escape from "./rules_inline/escape.mjs";
+import backtick from "./rules_inline/backticks.mjs";
+import strikethrough_default from "./rules_inline/strikethrough.mjs";
+import emphasis_default from "./rules_inline/emphasis.mjs";
+import link from "./rules_inline/link.mjs";
+import image from "./rules_inline/image.mjs";
+import autolink from "./rules_inline/autolink.mjs";
+import html_inline from "./rules_inline/html_inline.mjs";
+import entity from "./rules_inline/entity.mjs";
+import link_pairs from "./rules_inline/balance_pairs.mjs";
+import fragments_join from "./rules_inline/fragments_join.mjs";
+
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_inline.mjs
+/** internal
+* class ParserInline
+*
+* Tokenizes paragraph content.
+**/
+const _rules = [
+	["text", text],
+	["linkify", linkify],
+	["newline", newline],
+	["escape", escape],
+	["backticks", backtick],
+	["strikethrough", strikethrough_default.tokenize],
+	["emphasis", emphasis_default.tokenize],
+	["link", link],
+	["image", image],
+	["autolink", autolink],
+	["html_inline", html_inline],
+	["entity", entity]
+];
+const _rules2 = [
+	["balance_pairs", link_pairs],
+	["strikethrough", strikethrough_default.postProcess],
+	["emphasis", emphasis_default.postProcess],
+	["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;
+		}
+	}
+	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);
+			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++];
+	}
+	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
+export { ParserInline as default };
+//# sourceMappingURL=parser_inline.mjs.map

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_inline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser_inline.mjs","names":["r_text","r_linkify","r_newline","r_escape","r_backticks","r_strikethrough","r_emphasis","r_link","r_image","r_autolink","r_html_inline","r_entity","r_balance_pairs","r_fragments_join"],"sources":["../../../../../../../../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/parser_inline.mjs"],"sourcesContent":["/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n\nimport Ruler from './ruler.mjs'\nimport StateInline from './rules_inline/state_inline.mjs'\n\nimport r_text from './rules_inline/text.mjs'\nimport r_linkify from './rules_inline/linkify.mjs'\nimport r_newline from './rules_inline/newline.mjs'\nimport r_escape from './rules_inline/escape.mjs'\nimport r_backticks from './rules_inline/backticks.mjs'\nimport r_strikethrough from './rules_inline/strikethrough.mjs'\nimport r_emphasis from './rules_inline/emphasis.mjs'\nimport r_link from './rules_inline/link.mjs'\nimport r_image from './rules_inline/image.mjs'\nimport r_autolink from './rules_inline/autolink.mjs'\nimport r_html_inline from './rules_inline/html_inline.mjs'\nimport r_entity from './rules_inline/entity.mjs'\n\nimport r_balance_pairs from './rules_inline/balance_pairs.mjs'\nimport r_fragments_join from './rules_inline/fragments_join.mjs'\n\n// Parser rules\n\nconst _rules = [\n  ['text',            r_text],\n  ['linkify',         r_linkify],\n  ['newline',         r_newline],\n  ['escape',          r_escape],\n  ['backticks',       r_backticks],\n  ['strikethrough',   r_strikethrough.tokenize],\n  ['emphasis',        r_emphasis.tokenize],\n  ['link',            r_link],\n  ['image',           r_image],\n  ['autolink',        r_autolink],\n  ['html_inline',     r_html_inline],\n  ['entity',          r_entity]\n]\n\n// `rule2` ruleset was created specifically for emphasis/strikethrough\n// post-processing and may be changed in the future.\n//\n// Don't use this for anything except pairs (plugins working with `balance_pairs`).\n//\nconst _rules2 = [\n  ['balance_pairs',   r_balance_pairs],\n  ['strikethrough',   r_strikethrough.postProcess],\n  ['emphasis',        r_emphasis.postProcess],\n  // rules for pairs separate '**' into its own text tokens, which may be left unused,\n  // rule below merges unused segments back with the rest of the text\n  ['fragments_join',  r_fragments_join]\n]\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline () {\n  /**\n   * ParserInline#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1])\n  }\n\n  /**\n   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler()\n\n  for (let i = 0; i < _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1])\n  }\n}\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  const pos = state.pos\n  const rules = this.ruler.getRules('')\n  const len = rules.length\n  const maxNesting = state.md.options.maxNesting\n  const cache = state.cache\n\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos]\n    return\n  }\n\n  let ok = false\n\n  if (state.level < maxNesting) {\n    for (let i = 0; i < len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++\n      ok = rules[i](state, true)\n      state.level--\n\n      if (ok) {\n        if (pos >= state.pos) { throw new Error(\"inline rule didn't increment state.pos\") }\n        break\n      }\n    }\n  } else {\n    // Too much nesting, just skip until the end of the paragraph.\n    //\n    // NOTE: this will cause links to behave incorrectly in the following case,\n    //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n    //\n    //       [[[[[[[[[[[[[[[[[[[[[foo]()\n    //\n    // TODO: remove this workaround when CM standard will allow nested links\n    //       (we can replace it by preventing links from being parsed in\n    //       validation mode)\n    //\n    state.pos = state.posMax\n  }\n\n  if (!ok) { state.pos++ }\n  cache[pos] = state.pos\n}\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  const rules = this.ruler.getRules('')\n  const len = rules.length\n  const end = state.posMax\n  const maxNesting = state.md.options.maxNesting\n\n  while (state.pos < end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n    const prevPos = state.pos\n    let ok = false\n\n    if (state.level < maxNesting) {\n      for (let i = 0; i < len; i++) {\n        ok = rules[i](state, false)\n        if (ok) {\n          if (prevPos >= state.pos) { throw new Error(\"inline rule didn't increment state.pos\") }\n          break\n        }\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) { break }\n      continue\n    }\n\n    state.pending += state.src[state.pos++]\n  }\n\n  if (state.pending) {\n    state.pushPending()\n  }\n}\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  const state = new this.State(str, md, env, outTokens)\n\n  this.tokenize(state)\n\n  const rules = this.ruler2.getRules('')\n  const len = rules.length\n\n  for (let i = 0; i < len; i++) {\n    rules[i](state)\n  }\n}\n\nParserInline.prototype.State = StateInline\n\nexport default ParserInline\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAM,SAAS;CACb,CAAC,QAAmBA,KAAO;CAC3B,CAAC,WAAmBC,QAAU;CAC9B,CAAC,WAAmBC,QAAU;CAC9B,CAAC,UAAmBC,OAAS;CAC7B,CAAC,aAAmBC,SAAY;CAChC,CAAC,iBAAmBC,sBAAgB,SAAS;CAC7C,CAAC,YAAmBC,iBAAW,SAAS;CACxC,CAAC,QAAmBC,KAAO;CAC3B,CAAC,SAAmBC,MAAQ;CAC5B,CAAC,YAAmBC,SAAW;CAC/B,CAAC,eAAmBC,YAAc;CAClC,CAAC,UAAmBC,OAAS;CAC9B;AAOD,MAAM,UAAU;CACd,CAAC,iBAAmBC,WAAgB;CACpC,CAAC,iBAAmBP,sBAAgB,YAAY;CAChD,CAAC,YAAmBC,iBAAW,YAAY;CAG3C,CAAC,kBAAmBO,eAAiB;CACtC;;;;AAKD,SAAS,eAAgB;;;;;;AAMvB,MAAK,QAAQ,IAAI,OAAO;AAExB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,MAAK,MAAM,KAAK,OAAO,GAAG,IAAI,OAAO,GAAG,GAAG;;;;;;;AAS7C,MAAK,SAAS,IAAI,OAAO;AAEzB,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAClC,MAAK,OAAO,KAAK,QAAQ,GAAG,IAAI,QAAQ,GAAG,GAAG;;AAOlD,aAAa,UAAU,YAAY,SAAU,OAAO;CAClD,MAAM,MAAM,MAAM;CAClB,MAAM,QAAQ,KAAK,MAAM,SAAS,GAAG;CACrC,MAAM,MAAM,MAAM;CAClB,MAAM,aAAa,MAAM,GAAG,QAAQ;CACpC,MAAM,QAAQ,MAAM;AAEpB,KAAI,OAAO,MAAM,SAAS,aAAa;AACrC,QAAM,MAAM,MAAM;AAClB;;CAGF,IAAI,KAAK;AAET,KAAI,MAAM,QAAQ,WAChB,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;AAK5B,QAAM;AACN,OAAK,MAAM,GAAG,OAAO,KAAK;AAC1B,QAAM;AAEN,MAAI,IAAI;AACN,OAAI,OAAO,MAAM,IAAO,OAAM,IAAI,MAAM,yCAAyC;AACjF;;;KAeJ,OAAM,MAAM,MAAM;AAGpB,KAAI,CAAC,GAAM,OAAM;AACjB,OAAM,OAAO,MAAM;;AAKrB,aAAa,UAAU,WAAW,SAAU,OAAO;CACjD,MAAM,QAAQ,KAAK,MAAM,SAAS,GAAG;CACrC,MAAM,MAAM,MAAM;CAClB,MAAM,MAAM,MAAM;CAClB,MAAM,aAAa,MAAM,GAAG,QAAQ;AAEpC,QAAO,MAAM,MAAM,KAAK;EAOtB,MAAM,UAAU,MAAM;EACtB,IAAI,KAAK;AAET,MAAI,MAAM,QAAQ,WAChB,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,QAAK,MAAM,GAAG,OAAO,MAAM;AAC3B,OAAI,IAAI;AACN,QAAI,WAAW,MAAM,IAAO,OAAM,IAAI,MAAM,yCAAyC;AACrF;;;AAKN,MAAI,IAAI;AACN,OAAI,MAAM,OAAO,IAAO;AACxB;;AAGF,QAAM,WAAW,MAAM,IAAI,MAAM;;AAGnC,KAAI,MAAM,QACR,OAAM,aAAa;;;;;;;AASvB,aAAa,UAAU,QAAQ,SAAU,KAAK,IAAI,KAAK,WAAW;CAChE,MAAM,QAAQ,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,UAAU;AAErD,MAAK,SAAS,MAAM;CAEpB,MAAM,QAAQ,KAAK,OAAO,SAAS,GAAG;CACtC,MAAM,MAAM,MAAM;AAElB,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,OAAM,GAAG,MAAM;;AAInB,aAAa,UAAU,QAAQ"}

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/presets/commonmark.cjs

@@ -0,0 +1,57 @@
+
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/presets/commonmark.mjs
+var commonmark_default = {
+	options: {
+		html: true,
+		xhtmlOut: true,
+		breaks: false,
+		langPrefix: "language-",
+		linkify: false,
+		typographer: false,
+		quotes: "“”‘’",
+		highlight: null,
+		maxNesting: 20
+	},
+	components: {
+		core: { rules: [
+			"normalize",
+			"block",
+			"inline",
+			"text_join"
+		] },
+		block: { rules: [
+			"blockquote",
+			"code",
+			"fence",
+			"heading",
+			"hr",
+			"html_block",
+			"lheading",
+			"list",
+			"reference",
+			"paragraph"
+		] },
+		inline: {
+			rules: [
+				"autolink",
+				"backticks",
+				"emphasis",
+				"entity",
+				"escape",
+				"html_inline",
+				"image",
+				"link",
+				"newline",
+				"text"
+			],
+			rules2: [
+				"balance_pairs",
+				"emphasis",
+				"fragments_join"
+			]
+		}
+	}
+};
+
+//#endregion
+exports.default = commonmark_default;

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/presets/commonmark.mjs

@@ -0,0 +1,57 @@
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/presets/commonmark.mjs
+var commonmark_default = {
+	options: {
+		html: true,
+		xhtmlOut: true,
+		breaks: false,
+		langPrefix: "language-",
+		linkify: false,
+		typographer: false,
+		quotes: "“”‘’",
+		highlight: null,
+		maxNesting: 20
+	},
+	components: {
+		core: { rules: [
+			"normalize",
+			"block",
+			"inline",
+			"text_join"
+		] },
+		block: { rules: [
+			"blockquote",
+			"code",
+			"fence",
+			"heading",
+			"hr",
+			"html_block",
+			"lheading",
+			"list",
+			"reference",
+			"paragraph"
+		] },
+		inline: {
+			rules: [
+				"autolink",
+				"backticks",
+				"emphasis",
+				"entity",
+				"escape",
+				"html_inline",
+				"image",
+				"link",
+				"newline",
+				"text"
+			],
+			rules2: [
+				"balance_pairs",
+				"emphasis",
+				"fragments_join"
+			]
+		}
+	}
+};
+
+//#endregion
+export { commonmark_default as default };
+//# sourceMappingURL=commonmark.mjs.map

package/dist/node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/presets/commonmark.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commonmark.mjs","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/presets/commonmark.mjs"],"sourcesContent":["// Commonmark default options\n\nexport default {\n  options: {\n    // Enable HTML tags in source\n    html: true,\n\n    // Use '/' to close single tags (<br />)\n    xhtmlOut: true,\n\n    // Convert '\\n' in paragraphs into <br>\n    breaks: false,\n\n    // CSS language prefix for fenced blocks\n    langPrefix: 'language-',\n\n    // autoconvert URL-like texts to links\n    linkify: false,\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    // Internal protection, recursion limit\n    maxNesting: 20\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'fragments_join'\n      ]\n    }\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":";AAEA,yBAAe;CACb,SAAS;EAEP,MAAM;EAGN,UAAU;EAGV,QAAQ;EAGR,YAAY;EAGZ,SAAS;EAGT,aAAa;EAOb,QAAQ;EAQR,WAAW;EAGX,YAAY;EACb;CAED,YAAY;EAEV,MAAM,EACJ,OAAO;GACL;GACA;GACA;GACA;GACD,EACF;EAED,OAAO,EACL,OAAO;GACL;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD,EACF;EAED,QAAQ;GACN,OAAO;IACL;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACD;GACD,QAAQ;IACN;IACA;IACA;IACD;GACF;EACF;CACF"}