vue-files-preview-inno 1.0.38-e

package/es/node_modules/markdown-it/lib/index.mjs

@@ -0,0 +1,113 @@
+import * as m from "./common/utils.mjs";
+import { isString as c, assign as a } from "./common/utils.mjs";
+import * as p from "./helpers/index.mjs";
+import d from "./renderer.mjs";
+import w from "./parser_core.mjs";
+import y from "./parser_block.mjs";
+import k from "./parser_inline.mjs";
+import g from "../../linkify-it/index.mjs";
+import s from "../../mdurl/lib/decode.mjs";
+import b from "../../mdurl/lib/encode.mjs";
+import f from "../../mdurl/lib/format.mjs";
+import u from "../../mdurl/lib/parse.mjs";
+import l from "../../punycode.js/punycode.es6.mjs";
+import O from "./presets/default.mjs";
+import E from "./presets/zero.mjs";
+import I from "./presets/commonmark.mjs";
+const A = {
+  default: O,
+  zero: E,
+  commonmark: I
+}, _ = /^(vbscript|javascript|file|data):/, x = /^data:image\/(gif|png|jpeg|webp);/;
+function L(t) {
+  const r = t.trim().toLowerCase();
+  return _.test(r) ? x.test(r) : !0;
+}
+const h = ["http:", "https:", "mailto:"];
+function z(t) {
+  const r = u(t, !0);
+  if (r.hostname && (!r.protocol || h.indexOf(r.protocol) >= 0))
+    try {
+      r.hostname = l.toASCII(r.hostname);
+    } catch {
+    }
+  return b(f(r));
+}
+function R(t) {
+  const r = u(t, !0);
+  if (r.hostname && (!r.protocol || h.indexOf(r.protocol) >= 0))
+    try {
+      r.hostname = l.toUnicode(r.hostname);
+    } catch {
+    }
+  return s(f(r), s.defaultChars + "%");
+}
+function n(t, r) {
+  if (!(this instanceof n))
+    return new n(t, r);
+  r || c(t) || (r = t || {}, t = "default"), this.inline = new k(), this.block = new y(), this.core = new w(), this.renderer = new d(), this.linkify = new g(), this.validateLink = L, this.normalizeLink = z, this.normalizeLinkText = R, this.utils = m, this.helpers = a({}, p), this.options = {}, this.configure(t), r && this.set(r);
+}
+n.prototype.set = function(t) {
+  return a(this.options, t), this;
+};
+n.prototype.configure = function(t) {
+  const r = this;
+  if (c(t)) {
+    const o = t;
+    if (t = A[o], !t)
+      throw new Error('Wrong `markdown-it` preset "' + o + '", check name');
+  }
+  if (!t)
+    throw new Error("Wrong `markdown-it` preset, can't be empty");
+  return t.options && r.set(t.options), t.components && Object.keys(t.components).forEach(function(o) {
+    t.components[o].rules && r[o].ruler.enableOnly(t.components[o].rules), t.components[o].rules2 && r[o].ruler2.enableOnly(t.components[o].rules2);
+  }), this;
+};
+n.prototype.enable = function(t, r) {
+  let o = [];
+  Array.isArray(t) || (t = [t]), ["core", "block", "inline"].forEach(function(e) {
+    o = o.concat(this[e].ruler.enable(t, !0));
+  }, this), o = o.concat(this.inline.ruler2.enable(t, !0));
+  const i = t.filter(function(e) {
+    return o.indexOf(e) < 0;
+  });
+  if (i.length && !r)
+    throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + i);
+  return this;
+};
+n.prototype.disable = function(t, r) {
+  let o = [];
+  Array.isArray(t) || (t = [t]), ["core", "block", "inline"].forEach(function(e) {
+    o = o.concat(this[e].ruler.disable(t, !0));
+  }, this), o = o.concat(this.inline.ruler2.disable(t, !0));
+  const i = t.filter(function(e) {
+    return o.indexOf(e) < 0;
+  });
+  if (i.length && !r)
+    throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + i);
+  return this;
+};
+n.prototype.use = function(t) {
+  const r = [this].concat(Array.prototype.slice.call(arguments, 1));
+  return t.apply(t, r), this;
+};
+n.prototype.parse = function(t, r) {
+  if (typeof t != "string")
+    throw new Error("Input data should be a String");
+  const o = new this.core.State(t, this, r);
+  return this.core.process(o), o.tokens;
+};
+n.prototype.render = function(t, r) {
+  return r = r || {}, this.renderer.render(this.parse(t, r), this.options, r);
+};
+n.prototype.parseInline = function(t, r) {
+  const o = new this.core.State(t, this, r);
+  return o.inlineMode = !0, this.core.process(o), o.tokens;
+};
+n.prototype.renderInline = function(t, r) {
+  return r = r || {}, this.renderer.render(this.parseInline(t, r), this.options, r);
+};
+export {
+  n as default
+};
+//# sourceMappingURL=index.mjs.map

package/es/node_modules/markdown-it/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../../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"],"names":["config","cfg_default","cfg_zero","cfg_commonmark","BAD_PROTO_RE","GOOD_DATA_RE","validateLink","url","str","RECODE_HOSTNAME_FOR","normalizeLink","parsed","mdurl.parse","punycode","mdurl.encode","mdurl.format","normalizeLinkText","mdurl.decode","MarkdownIt","presetName","options","utils.isString","ParserInline","ParserBlock","ParserCore","Renderer","LinkifyIt","utils","utils.assign","helpers","presets","self","name","list","ignoreInvalid","result","chain","missed","plugin","args","src","env","state"],"mappings":"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","x_google_ignoreList":[0]}

package/es/node_modules/markdown-it/lib/parser_block.mjs

@@ -0,0 +1,64 @@
+import u from "./ruler.mjs";
+import s from "./rules_block/state_block.mjs";
+import k from "./rules_block/table.mjs";
+import b from "./rules_block/code.mjs";
+import g from "./rules_block/fence.mjs";
+import d from "./rules_block/blockquote.mjs";
+import q from "./rules_block/hr.mjs";
+import w from "./rules_block/list.mjs";
+import y from "./rules_block/reference.mjs";
+import E from "./rules_block/html_block.mjs";
+import x from "./rules_block/heading.mjs";
+import S from "./rules_block/lheading.mjs";
+import _ from "./rules_block/paragraph.mjs";
+const t = [
+  // First 2 params - rule name & source. Secondary array - list of rules,
+  // which can be terminated by this one.
+  ["table", k, ["paragraph", "reference"]],
+  ["code", b],
+  ["fence", g, ["paragraph", "reference", "blockquote", "list"]],
+  ["blockquote", d, ["paragraph", "reference", "blockquote", "list"]],
+  ["hr", q, ["paragraph", "reference", "blockquote", "list"]],
+  ["list", w, ["paragraph", "reference", "blockquote"]],
+  ["reference", y],
+  ["html_block", E, ["paragraph", "reference", "blockquote"]],
+  ["heading", x, ["paragraph", "reference", "blockquote"]],
+  ["lheading", S],
+  ["paragraph", _]
+];
+function c() {
+  this.ruler = new u();
+  for (let e = 0; e < t.length; e++)
+    this.ruler.push(t[e][0], t[e][1], { alt: (t[e][2] || []).slice() });
+}
+c.prototype.tokenize = function(e, n, o) {
+  const l = this.ruler.getRules(""), i = l.length, m = e.md.options.maxNesting;
+  let r = n, p = !1;
+  for (; r < o && (e.line = r = e.skipEmptyLines(r), !(r >= o || e.sCount[r] < e.blkIndent)); ) {
+    if (e.level >= m) {
+      e.line = o;
+      break;
+    }
+    const h = e.line;
+    let f = !1;
+    for (let a = 0; a < i; a++)
+      if (f = l[a](e, r, o, !1), f) {
+        if (h >= e.line)
+          throw new Error("block rule didn't increment state.line");
+        break;
+      }
+    if (!f) throw new Error("none of the block rules matched");
+    e.tight = !p, e.isEmpty(e.line - 1) && (p = !0), r = e.line, r < o && e.isEmpty(r) && (p = !0, r++, e.line = r);
+  }
+};
+c.prototype.parse = function(e, n, o, l) {
+  if (!e)
+    return;
+  const i = new this.State(e, n, o, l);
+  this.tokenize(i, i.line, i.lineMax);
+};
+c.prototype.State = s;
+export {
+  c as default
+};
+//# sourceMappingURL=parser_block.mjs.map

package/es/node_modules/markdown-it/lib/parser_block.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser_block.mjs","sources":["../../../../../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"],"names":["_rules","r_table","r_code","r_fence","r_blockquote","r_hr","r_list","r_reference","r_html_block","r_heading","r_lheading","r_paragraph","ParserBlock","Ruler","i","state","startLine","endLine","rules","len","maxNesting","line","hasEmptyLines","prevLine","ok","src","md","env","outTokens","StateBlock"],"mappings":";;;;;;;;;;;;;AAqBA,MAAMA,IAAS;AAAA;AAAA;AAAA,EAGb,CAAC,SAAcC,GAAc,CAAC,aAAa,WAAW,CAAC;AAAA,EACvD,CAAC,QAAcC,CAAM;AAAA,EACrB,CAAC,SAAcC,GAAc,CAAC,aAAa,aAAa,cAAc,MAAM,CAAC;AAAA,EAC7E,CAAC,cAAcC,GAAc,CAAC,aAAa,aAAa,cAAc,MAAM,CAAC;AAAA,EAC7E,CAAC,MAAcC,GAAc,CAAC,aAAa,aAAa,cAAc,MAAM,CAAC;AAAA,EAC7E,CAAC,QAAcC,GAAc,CAAC,aAAa,aAAa,YAAY,CAAC;AAAA,EACrE,CAAC,aAAcC,CAAW;AAAA,EAC1B,CAAC,cAAcC,GAAc,CAAC,aAAa,aAAa,YAAY,CAAC;AAAA,EACrE,CAAC,WAAcC,GAAc,CAAC,aAAa,aAAa,YAAY,CAAC;AAAA,EACrE,CAAC,YAAcC,CAAU;AAAA,EACzB,CAAC,aAAcC,CAAW;AAC5B;AAKA,SAASC,IAAe;AAMtB,OAAK,QAAQ,IAAIC,EAAK;AAEtB,WAASC,IAAI,GAAGA,IAAId,EAAO,QAAQc;AACjC,SAAK,MAAM,KAAKd,EAAOc,CAAC,EAAE,CAAC,GAAGd,EAAOc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAMd,EAAOc,CAAC,EAAE,CAAC,KAAK,IAAI,QAAO,CAAE;AAErF;AAIAF,EAAY,UAAU,WAAW,SAAUG,GAAOC,GAAWC,GAAS;AACpE,QAAMC,IAAQ,KAAK,MAAM,SAAS,EAAE,GAC9BC,IAAMD,EAAM,QACZE,IAAaL,EAAM,GAAG,QAAQ;AACpC,MAAIM,IAAOL,GACPM,IAAgB;AAEpB,SAAOD,IAAOJ,MACZF,EAAM,OAAOM,IAAON,EAAM,eAAeM,CAAI,GACzC,EAAAA,KAAQJ,KAIRF,EAAM,OAAOM,CAAI,IAAIN,EAAM,eANV;AAUrB,QAAIA,EAAM,SAASK,GAAY;AAC7B,MAAAL,EAAM,OAAOE;AACb;AAAA,IACF;AAQA,UAAMM,IAAWR,EAAM;AACvB,QAAIS,IAAK;AAET,aAASV,IAAI,GAAGA,IAAIK,GAAKL;AAEvB,UADAU,IAAKN,EAAMJ,CAAC,EAAEC,GAAOM,GAAMJ,GAAS,EAAK,GACrCO,GAAI;AACN,YAAID,KAAYR,EAAM;AACpB,gBAAM,IAAI,MAAM,wCAAwC;AAE1D;AAAA,MACF;AAIF,QAAI,CAACS,EAAI,OAAM,IAAI,MAAM,iCAAiC;AAI1D,IAAAT,EAAM,QAAQ,CAACO,GAGXP,EAAM,QAAQA,EAAM,OAAO,CAAC,MAC9BO,IAAgB,KAGlBD,IAAON,EAAM,MAETM,IAAOJ,KAAWF,EAAM,QAAQM,CAAI,MACtCC,IAAgB,IAChBD,KACAN,EAAM,OAAOM;AAAA,EAEjB;AACF;AAOAT,EAAY,UAAU,QAAQ,SAAUa,GAAKC,GAAIC,GAAKC,GAAW;AAC/D,MAAI,CAACH;AAAO;AAEZ,QAAMV,IAAQ,IAAI,KAAK,MAAMU,GAAKC,GAAIC,GAAKC,CAAS;AAEpD,OAAK,SAASb,GAAOA,EAAM,MAAMA,EAAM,OAAO;AAChD;AAEAH,EAAY,UAAU,QAAQiB;","x_google_ignoreList":[0]}

package/es/node_modules/markdown-it/lib/parser_core.mjs

@@ -0,0 +1,35 @@
+import m from "./ruler.mjs";
+import n from "./rules_core/state_core.mjs";
+import p from "./rules_core/normalize.mjs";
+import s from "./rules_core/block.mjs";
+import f from "./rules_core/inline.mjs";
+import u from "./rules_core/linkify.mjs";
+import a from "./rules_core/replacements.mjs";
+import c from "./rules_core/smartquotes.mjs";
+import h from "./rules_core/text_join.mjs";
+const t = [
+  ["normalize", p],
+  ["block", s],
+  ["inline", f],
+  ["linkify", u],
+  ["replacements", a],
+  ["smartquotes", c],
+  // `text_join` finds `text_special` tokens (for escape sequences)
+  // and joins them with the rest of the text
+  ["text_join", h]
+];
+function i() {
+  this.ruler = new m();
+  for (let r = 0; r < t.length; r++)
+    this.ruler.push(t[r][0], t[r][1]);
+}
+i.prototype.process = function(r) {
+  const e = this.ruler.getRules("");
+  for (let o = 0, l = e.length; o < l; o++)
+    e[o](r);
+};
+i.prototype.State = n;
+export {
+  i as default
+};
+//# sourceMappingURL=parser_core.mjs.map

package/es/node_modules/markdown-it/lib/parser_core.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser_core.mjs","sources":["../../../../../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"],"names":["_rules","r_normalize","r_block","r_inline","r_linkify","r_replacements","r_smartquotes","r_text_join","Core","Ruler","i","state","rules","StateCore"],"mappings":";;;;;;;;;AAkBA,MAAMA,IAAS;AAAA,EACb,CAAC,aAAkBC,CAAW;AAAA,EAC9B,CAAC,SAAkBC,CAAO;AAAA,EAC1B,CAAC,UAAkBC,CAAQ;AAAA,EAC3B,CAAC,WAAkBC,CAAS;AAAA,EAC5B,CAAC,gBAAkBC,CAAc;AAAA,EACjC,CAAC,eAAkBC,CAAa;AAAA;AAAA;AAAA,EAGhC,CAAC,aAAkBC,CAAW;AAChC;AAKA,SAASC,IAAQ;AAMf,OAAK,QAAQ,IAAIC,EAAK;AAEtB,WAASC,IAAI,GAAGA,IAAIV,EAAO,QAAQU;AACjC,SAAK,MAAM,KAAKV,EAAOU,CAAC,EAAE,CAAC,GAAGV,EAAOU,CAAC,EAAE,CAAC,CAAC;AAE9C;AAOAF,EAAK,UAAU,UAAU,SAAUG,GAAO;AACxC,QAAMC,IAAQ,KAAK,MAAM,SAAS,EAAE;AAEpC,WAASF,IAAI,GAAG,IAAIE,EAAM,QAAQF,IAAI,GAAGA;AACvC,IAAAE,EAAMF,CAAC,EAAEC,CAAK;AAElB;AAEAH,EAAK,UAAU,QAAQK;","x_google_ignoreList":[0]}

package/es/node_modules/markdown-it/lib/parser_inline.mjs

@@ -0,0 +1,97 @@
+import c from "./ruler.mjs";
+import k from "./rules_inline/state_inline.mjs";
+import g from "./rules_inline/text.mjs";
+import a from "./rules_inline/linkify.mjs";
+import d from "./rules_inline/newline.mjs";
+import w from "./rules_inline/escape.mjs";
+import _ from "./rules_inline/backticks.mjs";
+import u from "./rules_inline/strikethrough.mjs";
+import h from "./rules_inline/emphasis.mjs";
+import x from "./rules_inline/link.mjs";
+import y from "./rules_inline/image.mjs";
+import b from "./rules_inline/autolink.mjs";
+import v from "./rules_inline/html_inline.mjs";
+import P from "./rules_inline/entity.mjs";
+import z from "./rules_inline/balance_pairs.mjs";
+import N from "./rules_inline/fragments_join.mjs";
+const m = [
+  ["text", g],
+  ["linkify", a],
+  ["newline", d],
+  ["escape", w],
+  ["backticks", _],
+  ["strikethrough", u.tokenize],
+  ["emphasis", h.tokenize],
+  ["link", x],
+  ["image", y],
+  ["autolink", b],
+  ["html_inline", v],
+  ["entity", P]
+], f = [
+  ["balance_pairs", z],
+  ["strikethrough", u.postProcess],
+  ["emphasis", h.postProcess],
+  // rules for pairs separate '**' into its own text tokens, which may be left unused,
+  // rule below merges unused segments back with the rest of the text
+  ["fragments_join", N]
+];
+function p() {
+  this.ruler = new c();
+  for (let o = 0; o < m.length; o++)
+    this.ruler.push(m[o][0], m[o][1]);
+  this.ruler2 = new c();
+  for (let o = 0; o < f.length; o++)
+    this.ruler2.push(f[o][0], f[o][1]);
+}
+p.prototype.skipToken = function(o) {
+  const i = o.pos, t = this.ruler.getRules(""), s = t.length, l = o.md.options.maxNesting, n = o.cache;
+  if (typeof n[i] < "u") {
+    o.pos = n[i];
+    return;
+  }
+  let r = !1;
+  if (o.level < l) {
+    for (let e = 0; e < s; e++)
+      if (o.level++, r = t[e](o, !0), o.level--, r) {
+        if (i >= o.pos)
+          throw new Error("inline rule didn't increment state.pos");
+        break;
+      }
+  } else
+    o.pos = o.posMax;
+  r || o.pos++, n[i] = o.pos;
+};
+p.prototype.tokenize = function(o) {
+  const i = this.ruler.getRules(""), t = i.length, s = o.posMax, l = o.md.options.maxNesting;
+  for (; o.pos < s; ) {
+    const n = o.pos;
+    let r = !1;
+    if (o.level < l) {
+      for (let e = 0; e < t; e++)
+        if (r = i[e](o, !1), r) {
+          if (n >= o.pos)
+            throw new Error("inline rule didn't increment state.pos");
+          break;
+        }
+    }
+    if (r) {
+      if (o.pos >= s)
+        break;
+      continue;
+    }
+    o.pending += o.src[o.pos++];
+  }
+  o.pending && o.pushPending();
+};
+p.prototype.parse = function(o, i, t, s) {
+  const l = new this.State(o, i, t, s);
+  this.tokenize(l);
+  const n = this.ruler2.getRules(""), r = n.length;
+  for (let e = 0; e < r; e++)
+    n[e](l);
+};
+p.prototype.State = k;
+export {
+  p as default
+};
+//# sourceMappingURL=parser_inline.mjs.map

package/es/node_modules/markdown-it/lib/parser_inline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser_inline.mjs","sources":["../../../../../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"],"names":["_rules","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","_rules2","r_balance_pairs","r_fragments_join","ParserInline","Ruler","i","state","pos","rules","len","maxNesting","cache","ok","end","prevPos","str","md","env","outTokens","StateInline"],"mappings":"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","x_google_ignoreList":[0]}

package/es/node_modules/markdown-it/lib/presets/commonmark.mjs

@@ -0,0 +1,79 @@
+const e = {
+  options: {
+    // Enable HTML tags in source
+    html: !0,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: !0,
+    // Convert '\n' in paragraphs into <br>
+    breaks: !1,
+    // CSS language prefix for fenced blocks
+    langPrefix: "language-",
+    // autoconvert URL-like texts to links
+    linkify: !1,
+    // Enable some language-neutral replacements + quotes beautification
+    typographer: !1,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Could be either a String or an Array.
+    //
+    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+    quotes: "“”‘’",
+    /* “”‘’ */
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed and should be escaped externaly.
+    // If result starts with <pre... internal wrapper is skipped.
+    //
+    // function (/*str, lang*/) { return ''; }
+    //
+    highlight: null,
+    // Internal protection, recursion limit
+    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"
+      ]
+    }
+  }
+};
+export {
+  e as default
+};
+//# sourceMappingURL=commonmark.mjs.map

package/es/node_modules/markdown-it/lib/presets/commonmark.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commonmark.mjs","sources":["../../../../../../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"],"names":["cfg_commonmark"],"mappings":"AAEA,MAAAA,IAAe;AAAA,EACb,SAAS;AAAA;AAAA,IAEP,MAAM;AAAA;AAAA,IAGN,UAAU;AAAA;AAAA,IAGV,QAAQ;AAAA;AAAA,IAGR,YAAY;AAAA;AAAA,IAGZ,SAAS;AAAA;AAAA,IAGT,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOb,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQR,WAAW;AAAA;AAAA,IAGX,YAAY;AAAA,EAChB;AAAA,EAEE,YAAY;AAAA,IAEV,MAAM;AAAA,MACJ,OAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACR;AAAA,IACA;AAAA,IAEI,OAAO;AAAA,MACL,OAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACR;AAAA,IACA;AAAA,IAEI,QAAQ;AAAA,MACN,OAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACR;AAAA,MACM,QAAQ;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,MACR;AAAA,IACA;AAAA,EACA;AACA;","x_google_ignoreList":[0]}

package/es/node_modules/markdown-it/lib/presets/default.mjs

@@ -0,0 +1,41 @@
+const e = {
+  options: {
+    // Enable HTML tags in source
+    html: !1,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: !1,
+    // Convert '\n' in paragraphs into <br>
+    breaks: !1,
+    // CSS language prefix for fenced blocks
+    langPrefix: "language-",
+    // autoconvert URL-like texts to links
+    linkify: !1,
+    // Enable some language-neutral replacements + quotes beautification
+    typographer: !1,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Could be either a String or an Array.
+    //
+    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+    quotes: "“”‘’",
+    /* “”‘’ */
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed and should be escaped externaly.
+    // If result starts with <pre... internal wrapper is skipped.
+    //
+    // function (/*str, lang*/) { return ''; }
+    //
+    highlight: null,
+    // Internal protection, recursion limit
+    maxNesting: 100
+  },
+  components: {
+    core: {},
+    block: {},
+    inline: {}
+  }
+};
+export {
+  e as default
+};
+//# sourceMappingURL=default.mjs.map

package/es/node_modules/markdown-it/lib/presets/default.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.mjs","sources":["../../../../../../node_modules/markdown-it/lib/presets/default.mjs"],"sourcesContent":["// markdown-it default options\n\nexport default {\n  options: {\n    // Enable HTML tags in source\n    html: false,\n\n    // Use '/' to close single tags (<br />)\n    xhtmlOut: false,\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: 100\n  },\n\n  components: {\n    core: {},\n    block: {},\n    inline: {}\n  }\n}\n"],"names":["cfg_default"],"mappings":"AAEA,MAAAA,IAAe;AAAA,EACb,SAAS;AAAA;AAAA,IAEP,MAAM;AAAA;AAAA,IAGN,UAAU;AAAA;AAAA,IAGV,QAAQ;AAAA;AAAA,IAGR,YAAY;AAAA;AAAA,IAGZ,SAAS;AAAA;AAAA,IAGT,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOb,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQR,WAAW;AAAA;AAAA,IAGX,YAAY;AAAA,EAChB;AAAA,EAEE,YAAY;AAAA,IACV,MAAM,CAAA;AAAA,IACN,OAAO,CAAA;AAAA,IACP,QAAQ,CAAA;AAAA,EACZ;AACA;","x_google_ignoreList":[0]}

package/es/node_modules/markdown-it/lib/presets/zero.mjs

@@ -0,0 +1,60 @@
+const e = {
+  options: {
+    // Enable HTML tags in source
+    html: !1,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: !1,
+    // Convert '\n' in paragraphs into <br>
+    breaks: !1,
+    // CSS language prefix for fenced blocks
+    langPrefix: "language-",
+    // autoconvert URL-like texts to links
+    linkify: !1,
+    // Enable some language-neutral replacements + quotes beautification
+    typographer: !1,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Could be either a String or an Array.
+    //
+    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
+    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
+    quotes: "“”‘’",
+    /* “”‘’ */
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed and should be escaped externaly.
+    // If result starts with <pre... internal wrapper is skipped.
+    //
+    // function (/*str, lang*/) { return ''; }
+    //
+    highlight: null,
+    // Internal protection, recursion limit
+    maxNesting: 20
+  },
+  components: {
+    core: {
+      rules: [
+        "normalize",
+        "block",
+        "inline",
+        "text_join"
+      ]
+    },
+    block: {
+      rules: [
+        "paragraph"
+      ]
+    },
+    inline: {
+      rules: [
+        "text"
+      ],
+      rules2: [
+        "balance_pairs",
+        "fragments_join"
+      ]
+    }
+  }
+};
+export {
+  e as default
+};
+//# sourceMappingURL=zero.mjs.map

package/es/node_modules/markdown-it/lib/presets/zero.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zero.mjs","sources":["../../../../../../node_modules/markdown-it/lib/presets/zero.mjs"],"sourcesContent":["// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\nexport default {\n  options: {\n    // Enable HTML tags in source\n    html: false,\n\n    // Use '/' to close single tags (<br />)\n    xhtmlOut: false,\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        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'fragments_join'\n      ]\n    }\n  }\n}\n"],"names":["cfg_zero"],"mappings":"AAGA,MAAAA,IAAe;AAAA,EACb,SAAS;AAAA;AAAA,IAEP,MAAM;AAAA;AAAA,IAGN,UAAU;AAAA;AAAA,IAGV,QAAQ;AAAA;AAAA,IAGR,YAAY;AAAA;AAAA,IAGZ,SAAS;AAAA;AAAA,IAGT,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOb,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQR,WAAW;AAAA;AAAA,IAGX,YAAY;AAAA,EAChB;AAAA,EAEE,YAAY;AAAA,IAEV,MAAM;AAAA,MACJ,OAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACR;AAAA,IACA;AAAA,IAEI,OAAO;AAAA,MACL,OAAO;AAAA,QACL;AAAA,MACR;AAAA,IACA;AAAA,IAEI,QAAQ;AAAA,MACN,OAAO;AAAA,QACL;AAAA,MACR;AAAA,MACM,QAAQ;AAAA,QACN;AAAA,QACA;AAAA,MACR;AAAA,IACA;AAAA,EACA;AACA;","x_google_ignoreList":[0]}