@shell-shock/preset-cli 0.9.10 → 0.9.12

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

@@ -0,0 +1,489 @@
+import { __toESM } from "../../../../../../_virtual/_rolldown/runtime.mjs";
+import decode from "../../../../mdurl@2.0.0/node_modules/mdurl/lib/decode.mjs";
+import encode from "../../../../mdurl@2.0.0/node_modules/mdurl/lib/encode.mjs";
+import format from "../../../../mdurl@2.0.0/node_modules/mdurl/lib/format.mjs";
+import urlParse from "../../../../mdurl@2.0.0/node_modules/mdurl/lib/parse.mjs";
+import "../../../../mdurl@2.0.0/node_modules/mdurl/index.mjs";
+import { assign, isString, utils_exports } from "./common/utils.mjs";
+import { helpers_exports } from "./helpers/index.mjs";
+import Renderer from "./renderer.mjs";
+import Core from "./parser_core.mjs";
+import ParserBlock from "./parser_block.mjs";
+import ParserInline from "./parser_inline.mjs";
+import LinkifyIt from "../../../../linkify-it@5.0.0/node_modules/linkify-it/index.mjs";
+import { require_punycode } from "../../../../punycode.js@2.3.1/node_modules/punycode.js/punycode.mjs";
+import default_default from "./presets/default.mjs";
+import zero_default from "./presets/zero.mjs";
+import commonmark_default from "./presets/commonmark.mjs";
+
+//#region ../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/index.mjs
+var import_punycode = /* @__PURE__ */ __toESM(require_punycode(), 1);
+const config = {
+	default: default_default,
+	zero: zero_default,
+	commonmark: commonmark_default
+};
+const BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
+const 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;
+}
+const RECODE_HOSTNAME_FOR = [
+	"http:",
+	"https:",
+	"mailto:"
+];
+function normalizeLink(url) {
+	const parsed = urlParse(url, true);
+	if (parsed.hostname) {
+		if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) try {
+			parsed.hostname = import_punycode.default.toASCII(parsed.hostname);
+		} catch (er) {}
+	}
+	return encode(format(parsed));
+}
+function normalizeLinkText(url) {
+	const parsed = urlParse(url, true);
+	if (parsed.hostname) {
+		if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) try {
+			parsed.hostname = import_punycode.default.toUnicode(parsed.hostname);
+		} catch (er) {}
+	}
+	return decode(format(parsed), 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/
+*
+* 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";
+		}
+	}
+	/**
+	* MarkdownIt#inline -> ParserInline
+	*
+	* 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
+	*
+	* 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
+	*
+	* 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();
+	/**
+	* MarkdownIt#renderer -> Renderer
+	*
+	* Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
+	* rules for new token types, generated by plugins.
+	*
+	* ##### Example
+	*
+	* ```javascript
+	* var md = require('markdown-it')();
+	*
+	* function myToken(tokens, idx, options, env, self) {
+	*   //...
+	*   return result;
+	* };
+	*
+	* md.renderer.rules['my_token'] = myToken
+	* ```
+	*
+	* See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).
+	**/
+	this.renderer = new Renderer();
+	/**
+	* MarkdownIt#linkify -> LinkifyIt
+	*
+	* [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 LinkifyIt();
+	/**
+	* MarkdownIt#validateLink(url) -> Boolean
+	*
+	* 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.
+	*
+	* You can change this behaviour:
+	*
+	* ```javascript
+	* var md = require('markdown-it')();
+	* // enable everything
+	* md.validateLink = function () { return true; }
+	* ```
+	**/
+	this.validateLink = validateLink;
+	/**
+	* MarkdownIt#normalizeLink(url) -> String
+	*
+	* Function used to encode link url to a machine-readable format,
+	* which includes url-encoding, punycode, etc.
+	**/
+	this.normalizeLink = normalizeLink;
+	/**
+	* MarkdownIt#normalizeLinkText(url) -> String
+	*
+	* Function used to decode link url to a human-readable format`
+	**/
+	this.normalizeLinkText = normalizeLinkText;
+	/**
+	* 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;
+	/**
+	* 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;
+};
+/**
+* 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
+*
+* 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
+*
+* 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);
+};
+
+//#endregion
+export { MarkdownIt as default };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["cfg_default","cfg_zero","cfg_commonmark","mdurl.parse","punycode","mdurl.encode","mdurl.format","mdurl.decode","utils.isString","ParserCore","utils","utils.assign","helpers"],"sources":["../../../../../../../../../node_modules/.pnpm/markdown-it@14.1.1/node_modules/markdown-it/lib/index.mjs"],"sourcesContent":["// Main parser class\n\nimport * as utils from './common/utils.mjs'\nimport * as helpers from './helpers/index.mjs'\nimport Renderer from './renderer.mjs'\nimport ParserCore from './parser_core.mjs'\nimport ParserBlock from './parser_block.mjs'\nimport ParserInline from './parser_inline.mjs'\nimport LinkifyIt from 'linkify-it'\nimport * as mdurl from 'mdurl'\nimport punycode from 'punycode.js'\n\nimport cfg_default from './presets/default.mjs'\nimport cfg_zero from './presets/zero.mjs'\nimport cfg_commonmark from './presets/commonmark.mjs'\n\nconst config = {\n  default: cfg_default,\n  zero: cfg_zero,\n  commonmark: cfg_commonmark\n}\n\n//\n// This validator can prohibit more than really needed to prevent XSS. It's a\n// tradeoff to keep code simple and to be secure by default.\n//\n// If you need different setup - override validator method as you wish. Or\n// replace it with dummy function and use external sanitizer.\n//\n\nconst BAD_PROTO_RE = /^(vbscript|javascript|file|data):/\nconst GOOD_DATA_RE = /^data:image\\/(gif|png|jpeg|webp);/\n\nfunction validateLink (url) {\n  // url should be normalized at this point, and existing entities are decoded\n  const str = url.trim().toLowerCase()\n\n  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true\n}\n\nconst RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:']\n\nfunction normalizeLink (url) {\n  const parsed = mdurl.parse(url, true)\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toASCII(parsed.hostname)\n      } catch (er) { /**/ }\n    }\n  }\n\n  return mdurl.encode(mdurl.format(parsed))\n}\n\nfunction normalizeLinkText (url) {\n  const parsed = mdurl.parse(url, true)\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toUnicode(parsed.hostname)\n      } catch (er) { /**/ }\n    }\n  }\n\n  // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720\n  return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%')\n}\n\n/**\n * class MarkdownIt\n *\n * Main parser/renderer class.\n *\n * ##### Usage\n *\n * ```javascript\n * // node.js, \"classic\" way:\n * var MarkdownIt = require('markdown-it'),\n *     md = new MarkdownIt();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // node.js, the same, but with sugar:\n * var md = require('markdown-it')();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // browser without AMD, added to \"window\" on script load\n * // Note, there are no dash.\n * var md = window.markdownit();\n * var result = md.render('# markdown-it rulezz!');\n * ```\n *\n * Single line rendering, without paragraph wrap:\n *\n * ```javascript\n * var md = require('markdown-it')();\n * var result = md.renderInline('__markdown-it__ rulezz!');\n * ```\n **/\n\n/**\n * new MarkdownIt([presetName, options])\n * - presetName (String): optional, `commonmark` / `zero`\n * - options (Object)\n *\n * Creates parser instanse with given config. Can be called without `new`.\n *\n * ##### presetName\n *\n * MarkdownIt provides named presets as a convenience to quickly\n * enable/disable active syntax rules and options for common use cases.\n *\n * - [\"commonmark\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -\n *   configures parser to strict [CommonMark](http://commonmark.org/) mode.\n * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -\n *   similar to GFM, used when no preset name given. Enables all available rules,\n *   but still without html, typographer & autolinker.\n * - [\"zero\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -\n *   all rules disabled. Useful to quickly setup your config via `.enable()`.\n *   For example, when you need only `bold` and `italic` markup and nothing else.\n *\n * ##### options:\n *\n * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!\n *   That's not safe! You may need external sanitizer to protect output from XSS.\n *   It's better to extend features via plugins, instead of enabling HTML.\n * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags\n *   (`<br />`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `<br>`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +\n *   quotes beautification (smartquotes).\n * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement\n *   pairs, when typographer enabled and smartquotes on. For example, you can\n *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and\n *   `['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›']` for French (including nbsp).\n * - __highlight__ - `null`. Highlighter function for fenced code blocks.\n *   Highlighter `function (str, lang)` should return escaped HTML. It can also\n *   return empty string if the source was not changed and should be escaped\n *   externaly. If result starts with <pre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `<pre>` or `<code>`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return '<pre><code class=\"hljs\">' +\n *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n *                '</code></pre>';\n *       } catch (__) {}\n *     }\n *\n *     return '<pre><code class=\"hljs\">' + md.utils.escapeHtml(str) + '</code></pre>';\n *   }\n * });\n * ```\n *\n **/\nfunction MarkdownIt (presetName, options) {\n  if (!(this instanceof MarkdownIt)) {\n    return new MarkdownIt(presetName, options)\n  }\n\n  if (!options) {\n    if (!utils.isString(presetName)) {\n      options = presetName || {}\n      presetName = 'default'\n    }\n  }\n\n  /**\n   * MarkdownIt#inline -> ParserInline\n   *\n   * Instance of [[ParserInline]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.inline = new ParserInline()\n\n  /**\n   * MarkdownIt#block -> ParserBlock\n   *\n   * Instance of [[ParserBlock]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.block = new ParserBlock()\n\n  /**\n   * MarkdownIt#core -> Core\n   *\n   * Instance of [[Core]] chain executor. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.core = new ParserCore()\n\n  /**\n   * MarkdownIt#renderer -> Renderer\n   *\n   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   *\n   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).\n   **/\n  this.renderer = new Renderer()\n\n  /**\n   * MarkdownIt#linkify -> LinkifyIt\n   *\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)\n   * rule.\n   **/\n  this.linkify = new LinkifyIt()\n\n  /**\n   * MarkdownIt#validateLink(url) -> Boolean\n   *\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   **/\n  this.validateLink = validateLink\n\n  /**\n   * MarkdownIt#normalizeLink(url) -> String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n  this.normalizeLink = normalizeLink\n\n  /**\n   * MarkdownIt#normalizeLinkText(url) -> String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText\n\n  // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -> utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).\n   **/\n  this.utils = utils\n\n  /**\n   * MarkdownIt#helpers -> helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n  this.helpers = utils.assign({}, helpers)\n\n  this.options = {}\n  this.configure(presetName)\n\n  if (options) { this.set(options) }\n}\n\n/** chainable\n * MarkdownIt.set(options)\n *\n * Set parser options (in the same format as in constructor). Probably, you\n * will never need it, but you can change options after constructor call.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .set({ html: true, breaks: true })\n *             .set({ typographer, true });\n * ```\n *\n * __Note:__ To achieve the best possible performance, don't modify a\n * `markdown-it` instance options on the fly. If you need multiple configurations\n * it's best to create multiple instances and initialize each with separate\n * config.\n **/\nMarkdownIt.prototype.set = function (options) {\n  utils.assign(this.options, options)\n  return this\n}\n\n/** chainable, internal\n * MarkdownIt.configure(presets)\n *\n * Batch load of all options and compenent settings. This is internal method,\n * and you probably will not need it. But if you will - see available presets\n * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)\n *\n * We strongly recommend to use presets instead of direct config loads. That\n * will give better compatibility with next versions.\n **/\nMarkdownIt.prototype.configure = function (presets) {\n  const self = this\n\n  if (utils.isString(presets)) {\n    const presetName = presets\n    presets = config[presetName]\n    if (!presets) { throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name') }\n  }\n\n  if (!presets) { throw new Error('Wrong `markdown-it` preset, can\\'t be empty') }\n\n  if (presets.options) { self.set(presets.options) }\n\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enableOnly(presets.components[name].rules)\n      }\n      if (presets.components[name].rules2) {\n        self[name].ruler2.enableOnly(presets.components[name].rules2)\n      }\n    })\n  }\n  return this\n}\n\n/** chainable\n * MarkdownIt.enable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to enable\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable list or rules. It will automatically find appropriate components,\n * containing rules with given names. If rule not found, and `ignoreInvalid`\n * not set - throws exception.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .enable(['sub', 'sup'])\n *             .disable('smartquotes');\n * ```\n **/\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n  let result = []\n\n  if (!Array.isArray(list)) { list = [list] }\n\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.enable(list, true))\n  }, this)\n\n  result = result.concat(this.inline.ruler2.enable(list, true))\n\n  const missed = list.filter(function (name) { return result.indexOf(name) < 0 })\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed)\n  }\n\n  return this\n}\n\n/** chainable\n * MarkdownIt.disable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * The same as [[MarkdownIt.enable]], but turn specified rules off.\n **/\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n  let result = []\n\n  if (!Array.isArray(list)) { list = [list] }\n\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.disable(list, true))\n  }, this)\n\n  result = result.concat(this.inline.ruler2.disable(list, true))\n\n  const missed = list.filter(function (name) { return result.indexOf(name) < 0 })\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed)\n  }\n  return this\n}\n\n/** chainable\n * MarkdownIt.use(plugin, params)\n *\n * Load specified plugin with given params into current parser instance.\n * It's just a sugar to call `plugin(md, params)` with curring.\n *\n * ##### Example\n *\n * ```javascript\n * var iterator = require('markdown-it-for-inline');\n * var md = require('markdown-it')()\n *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');\n *             });\n * ```\n **/\nMarkdownIt.prototype.use = function (plugin /*, params, ... */) {\n  const args = [this].concat(Array.prototype.slice.call(arguments, 1))\n  plugin.apply(plugin, args)\n  return this\n}\n\n/** internal\n * MarkdownIt.parse(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Parse input string and return list of block tokens (special token type\n * \"inline\" will contain list of inline tokens). You should not call this\n * method directly, until you write custom renderer (for example, to produce\n * AST).\n *\n * `env` is used to pass data between \"distributed\" rules and return additional\n * metadata like reference info, needed for the renderer. It also can be used to\n * inject data in specific cases. Usually, you will be ok to pass `{}`,\n * and then pass updated object to renderer.\n **/\nMarkdownIt.prototype.parse = function (src, env) {\n  if (typeof src !== 'string') {\n    throw new Error('Input data should be a String')\n  }\n\n  const state = new this.core.State(src, this, env)\n\n  this.core.process(state)\n\n  return state.tokens\n}\n\n/**\n * MarkdownIt.render(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Render markdown string into html. It does all magic for you :).\n *\n * `env` can be used to inject additional metadata (`{}` by default).\n * But you will not need it with high probability. See also comment\n * in [[MarkdownIt.parse]].\n **/\nMarkdownIt.prototype.render = function (src, env) {\n  env = env || {}\n\n  return this.renderer.render(this.parse(src, env), this.options, env)\n}\n\n/** internal\n * MarkdownIt.parseInline(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the\n * block tokens list with the single `inline` element, containing parsed inline\n * tokens in `children` property. Also updates `env` object.\n **/\nMarkdownIt.prototype.parseInline = function (src, env) {\n  const state = new this.core.State(src, this, env)\n\n  state.inlineMode = true\n  this.core.process(state)\n\n  return state.tokens\n}\n\n/**\n * MarkdownIt.renderInline(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `<p>` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {}\n\n  return this.renderer.render(this.parseInline(src, env), this.options, env)\n}\n\nexport default MarkdownIt\n"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -0,0 +1,148 @@
+const require_ruler = require('./ruler.cjs');
+const require_state_block = require('./rules_block/state_block.cjs');
+const require_table = require('./rules_block/table.cjs');
+const require_code = require('./rules_block/code.cjs');
+const require_fence = require('./rules_block/fence.cjs');
+const require_blockquote = require('./rules_block/blockquote.cjs');
+const require_hr = require('./rules_block/hr.cjs');
+const require_list = require('./rules_block/list.cjs');
+const require_reference = require('./rules_block/reference.cjs');
+const require_html_block = require('./rules_block/html_block.cjs');
+const require_heading = require('./rules_block/heading.cjs');
+const require_lheading = require('./rules_block/lheading.cjs');
+const require_paragraph = require('./rules_block/paragraph.cjs');
+
+//#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",
+		require_table.default,
+		["paragraph", "reference"]
+	],
+	["code", require_code.default],
+	[
+		"fence",
+		require_fence.default,
+		[
+			"paragraph",
+			"reference",
+			"blockquote",
+			"list"
+		]
+	],
+	[
+		"blockquote",
+		require_blockquote.default,
+		[
+			"paragraph",
+			"reference",
+			"blockquote",
+			"list"
+		]
+	],
+	[
+		"hr",
+		require_hr.default,
+		[
+			"paragraph",
+			"reference",
+			"blockquote",
+			"list"
+		]
+	],
+	[
+		"list",
+		require_list.default,
+		[
+			"paragraph",
+			"reference",
+			"blockquote"
+		]
+	],
+	["reference", require_reference.default],
+	[
+		"html_block",
+		require_html_block.default,
+		[
+			"paragraph",
+			"reference",
+			"blockquote"
+		]
+	],
+	[
+		"heading",
+		require_heading.default,
+		[
+			"paragraph",
+			"reference",
+			"blockquote"
+		]
+	],
+	["lheading", require_lheading.default],
+	["paragraph", require_paragraph.default]
+];
+/**
+* new ParserBlock()
+**/
+function ParserBlock() {
+	/**
+	* ParserBlock#ruler -> Ruler
+	*
+	* [[Ruler]] instance. Keep configuration of block rules.
+	**/
+	this.ruler = new require_ruler.default();
+	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 = require_state_block.default;
+
+//#endregion
+exports.default = ParserBlock;