@viswa-test/audit-log 0.0.1

package/dist/cjs/node_modules/micromark-core-commonmark/lib/character-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-reference.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/character-reference.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterReference\");\n    effects.enter(\"characterReferenceMarker\");\n    effects.consume(code);\n    effects.exit(\"characterReferenceMarker\");\n    return open;\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter(\"characterReferenceMarkerNumeric\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerNumeric\");\n      return numeric;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter(\"characterReferenceMarkerHexadecimal\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerHexadecimal\");\n      effects.enter(\"characterReferenceValue\");\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}"],"names":["characterReference","name","tokenize","effects","ok","nok","self","this","max","test","size","code","enter","consume","exit","open","numeric","asciiAlphanumeric","value","asciiHexDigit","asciiDigit","token","decodeNamedCharacterReference","sliceSerialize"],"mappings":"8LAaY,MAACA,EAAqB,CAChCC,KAAM,qBACNC,SAQF,SAAoCC,EAASC,EAAIC,GAC/C,MAAMC,EAAOC,KACb,IAEIC,EAEAC,EAJAC,EAAO,EAKX,OAgBA,SAAeC,GAKb,OAJAR,EAAQS,MAAM,sBACdT,EAAQS,MAAM,4BACdT,EAAQU,QAAQF,GAChBR,EAAQW,KAAK,4BACNC,CACR,EAiBD,SAASA,EAAKJ,GACZ,OAAa,KAATA,GACFR,EAAQS,MAAM,mCACdT,EAAQU,QAAQF,GAChBR,EAAQW,KAAK,mCACNE,IAETb,EAAQS,MAAM,2BACdJ,EAAM,GACNC,EAAOQ,EAAAA,kBACAC,EAAMP,GACd,CAcD,SAASK,EAAQL,GACf,OAAa,KAATA,GAAwB,MAATA,GACjBR,EAAQS,MAAM,uCACdT,EAAQU,QAAQF,GAChBR,EAAQW,KAAK,uCACbX,EAAQS,MAAM,2BACdJ,EAAM,EACNC,EAAOU,EAAAA,cACAD,IAETf,EAAQS,MAAM,2BACdJ,EAAM,EACNC,EAAOW,EAAAA,WACAF,EAAMP,GACd,CAmBD,SAASO,EAAMP,GACb,GAAa,KAATA,GAAeD,EAAM,CACvB,MAAMW,EAAQlB,EAAQW,KAAK,2BAC3B,OAAIL,IAASQ,EAAAA,mBAAsBK,EAAAA,8BAA8BhB,EAAKiB,eAAeF,KAMrFlB,EAAQS,MAAM,4BACdT,EAAQU,QAAQF,GAChBR,EAAQW,KAAK,4BACbX,EAAQW,KAAK,sBACNV,GATEC,EAAIM,EAUd,CACD,OAAIF,EAAKE,IAASD,IAASF,GACzBL,EAAQU,QAAQF,GACTO,GAEFb,EAAIM,EACZ,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/code-fenced.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),n=require("../../micromark-util-character/index.js");const c={partial:!0,tokenize:function(e,n,c){const t=this;return function(n){if(null===n)return c(n);return e.enter("lineEnding"),e.consume(n),e.exit("lineEnding"),r};function r(e){return t.parser.lazy[t.now().line]?c(e):n(e)}}},t={concrete:!0,name:"codeFenced",tokenize:function(t,r,i){const o=this,u={partial:!0,tokenize:function(c,t,r){let i=0;return u;function u(e){return c.enter("lineEnding"),c.consume(e),c.exit("lineEnding"),a}function a(t){return c.enter("codeFencedFence"),n.markdownSpace(t)?e.factorySpace(c,f,"linePrefix",o.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(t):f(t)}function f(e){return e===d?(c.enter("codeFencedFenceSequence"),s(e)):r(e)}function s(t){return t===d?(i++,c.consume(t),s):i>=l?(c.exit("codeFencedFenceSequence"),n.markdownSpace(t)?e.factorySpace(c,F,"whitespace")(t):F(t)):r(t)}function F(e){return null===e||n.markdownLineEnding(e)?(c.exit("codeFencedFence"),t(e)):r(e)}}};let d,a=0,l=0;return function(e){return function(e){const n=o.events[o.events.length-1];return a=n&&"linePrefix"===n[1].type?n[2].sliceSerialize(n[1],!0).length:0,d=e,t.enter("codeFenced"),t.enter("codeFencedFence"),t.enter("codeFencedFenceSequence"),f(e)}(e)};function f(c){return c===d?(l++,t.consume(c),f):l<3?i(c):(t.exit("codeFencedFenceSequence"),n.markdownSpace(c)?e.factorySpace(t,s,"whitespace")(c):s(c))}function s(e){return null===e||n.markdownLineEnding(e)?(t.exit("codeFencedFence"),o.interrupt?r(e):t.check(c,k,h)(e)):(t.enter("codeFencedFenceInfo"),t.enter("chunkString",{contentType:"string"}),F(e))}function F(c){return null===c||n.markdownLineEnding(c)?(t.exit("chunkString"),t.exit("codeFencedFenceInfo"),s(c)):n.markdownSpace(c)?(t.exit("chunkString"),t.exit("codeFencedFenceInfo"),e.factorySpace(t,m,"whitespace")(c)):96===c&&c===d?i(c):(t.consume(c),F)}function m(e){return null===e||n.markdownLineEnding(e)?s(e):(t.enter("codeFencedFenceMeta"),t.enter("chunkString",{contentType:"string"}),p(e))}function p(e){return null===e||n.markdownLineEnding(e)?(t.exit("chunkString"),t.exit("codeFencedFenceMeta"),s(e)):96===e&&e===d?i(e):(t.consume(e),p)}function k(e){return t.attempt(u,h,g)(e)}function g(e){return t.enter("lineEnding"),t.consume(e),t.exit("lineEnding"),x}function x(c){return a>0&&n.markdownSpace(c)?e.factorySpace(t,S,"linePrefix",a+1)(c):S(c)}function S(e){return null===e||n.markdownLineEnding(e)?t.check(c,k,h)(e):(t.enter("codeFlowValue"),w(e))}function w(e){return null===e||n.markdownLineEnding(e)?(t.exit("codeFlowValue"),S(e)):(t.consume(e),w)}function h(e){return t.exit("codeFenced"),r(e)}}};exports.codeFenced=t;
+//# sourceMappingURL=code-fenced.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/code-fenced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-fenced.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/code-fenced.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuation\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  concrete: true,\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    partial: true,\n    tokenize: tokenizeCloseStart\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceMeta\");\n      return infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}"],"names":["nonLazyContinuation","partial","tokenize","effects","ok","nok","self","this","code","enter","consume","exit","lineStart","parser","lazy","now","line","codeFenced","concrete","name","closeStart","size","startBefore","start","markdownSpace","factorySpace","beforeSequenceClose","constructs","disable","null","includes","undefined","marker","sequenceClose","sizeOpen","sequenceCloseAfter","markdownLineEnding","initialPrefix","tail","events","length","type","sliceSerialize","sequenceOpen","beforeSequenceOpen","infoBefore","interrupt","check","atNonLazyBreak","after","contentType","info","metaBefore","meta","attempt","contentBefore","contentStart","beforeContentChunk","contentChunk"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/code-indented.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),n=require("../../micromark-util-character/index.js");const t={name:"codeIndented",tokenize:function(t,r,o){const c=this;return function(n){return t.enter("codeIndented"),e.factorySpace(t,u,"linePrefix",5)(n)};function u(e){const n=c.events[c.events.length-1];return n&&"linePrefix"===n[1].type&&n[2].sliceSerialize(n[1],!0).length>=4?d(e):o(e)}function d(e){return null===e?a(e):n.markdownLineEnding(e)?t.attempt(i,d,a)(e):(t.enter("codeFlowValue"),l(e))}function l(e){return null===e||n.markdownLineEnding(e)?(t.exit("codeFlowValue"),d(e)):(t.consume(e),l)}function a(e){return t.exit("codeIndented"),r(e)}}},i={partial:!0,tokenize:function(t,i,r){const o=this;return c;function c(i){return o.parser.lazy[o.now().line]?r(i):n.markdownLineEnding(i)?(t.enter("lineEnding"),t.consume(i),t.exit("lineEnding"),c):e.factorySpace(t,u,"linePrefix",5)(i)}function u(e){const t=o.events[o.events.length-1];return t&&"linePrefix"===t[1].type&&t[2].sliceSerialize(t[1],!0).length>=4?i(e):n.markdownLineEnding(e)?c(e):r(e)}}};exports.codeIndented=t;
+//# sourceMappingURL=code-indented.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/code-indented.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-indented.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/code-indented.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  partial: true,\n  tokenize: tokenizeFurtherStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}"],"names":["codeIndented","name","tokenize","effects","ok","nok","self","this","code","enter","factorySpace","afterPrefix","tail","events","length","type","sliceSerialize","atBreak","after","markdownLineEnding","attempt","furtherStart","inside","exit","consume","partial","parser","lazy","now","line"],"mappings":"iLAYY,MAACA,EAAe,CAC1BC,KAAM,eACNC,SAcF,SAA8BC,EAASC,EAAIC,GACzC,MAAMC,EAAOC,KACb,OAgBA,SAAeC,GAMb,OAHAL,EAAQM,MAAM,gBAGPC,EAAYA,aAACP,EAASQ,EAAa,aAAc,EAAjDD,CAAwDF,EAChE,EAYD,SAASG,EAAYH,GACnB,MAAMI,EAAON,EAAKO,OAAOP,EAAKO,OAAOC,OAAS,GAC9C,OAAOF,GAAyB,eAAjBA,EAAK,GAAGG,MAAyBH,EAAK,GAAGI,eAAeJ,EAAK,IAAI,GAAME,QAAU,EAAIG,EAAQT,GAAQH,EAAIG,EACzH,CAYD,SAASS,EAAQT,GACf,OAAa,OAATA,EACKU,EAAMV,GAEXW,EAAAA,mBAAmBX,GACdL,EAAQiB,QAAQC,EAAcJ,EAASC,EAAvCf,CAA8CK,IAEvDL,EAAQM,MAAM,iBACPa,EAAOd,GACf,CAYD,SAASc,EAAOd,GACd,OAAa,OAATA,GAAiBW,EAAkBA,mBAACX,IACtCL,EAAQoB,KAAK,iBACNN,EAAQT,KAEjBL,EAAQqB,QAAQhB,GACTc,EACR,CAGD,SAASJ,EAAMV,GAKb,OAJAL,EAAQoB,KAAK,gBAINnB,EAAGI,EACX,CACH,GApGMa,EAAe,CACnBI,SAAS,EACTvB,SAyGF,SAA8BC,EAASC,EAAIC,GACzC,MAAMC,EAAOC,KACb,OAAOc,EAaP,SAASA,EAAab,GAGpB,OAAIF,EAAKoB,OAAOC,KAAKrB,EAAKsB,MAAMC,MACvBxB,EAAIG,GAETW,EAAAA,mBAAmBX,IACrBL,EAAQM,MAAM,cACdN,EAAQqB,QAAQhB,GAChBL,EAAQoB,KAAK,cACNF,GASFX,EAAYA,aAACP,EAASQ,EAAa,aAAc,EAAjDD,CAAwDF,EAChE,CAYD,SAASG,EAAYH,GACnB,MAAMI,EAAON,EAAKO,OAAOP,EAAKO,OAAOC,OAAS,GAC9C,OAAOF,GAAyB,eAAjBA,EAAK,GAAGG,MAAyBH,EAAK,GAAGI,eAAeJ,EAAK,IAAI,GAAME,QAAU,EAAIV,EAAGI,GAAQW,EAAkBA,mBAACX,GAAQa,EAAab,GAAQH,EAAIG,EACpK,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/code-text.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-util-character/index.js");const n={name:"codeText",previous:function(e){return 96!==e||"characterEscape"===this.events[this.events.length-1][1].type},resolve:function(e){let n,t,i=e.length-4,c=3;if(!("lineEnding"!==e[c][1].type&&"space"!==e[c][1].type||"lineEnding"!==e[i][1].type&&"space"!==e[i][1].type))for(n=c;++n<i;)if("codeTextData"===e[n][1].type){e[c][1].type="codeTextPadding",e[i][1].type="codeTextPadding",c+=2,i-=2;break}n=c-1,i++;for(;++n<=i;)void 0===t?n!==i&&"lineEnding"!==e[n][1].type&&(t=n):n!==i&&"lineEnding"!==e[n][1].type||(e[t][1].type="codeTextData",n!==t+2&&(e[t][1].end=e[n-1][1].end,e.splice(t+2,n-t-2),i-=n-t-2,n=t+2),t=void 0);return e},tokenize:function(n,t,i){let c,o,r=0;return function(e){return n.enter("codeText"),n.enter("codeTextSequence"),d(e)};function d(e){return 96===e?(n.consume(e),r++,d):(n.exit("codeTextSequence"),u(e))}function u(t){return null===t?i(t):32===t?(n.enter("space"),n.consume(t),n.exit("space"),u):96===t?(o=n.enter("codeTextSequence"),c=0,s(t)):e.markdownLineEnding(t)?(n.enter("lineEnding"),n.consume(t),n.exit("lineEnding"),u):(n.enter("codeTextData"),a(t))}function a(t){return null===t||32===t||96===t||e.markdownLineEnding(t)?(n.exit("codeTextData"),u(t)):(n.consume(t),a)}function s(e){return 96===e?(n.consume(e),c++,s):c===r?(n.exit("codeTextSequence"),n.exit("codeText"),t(e)):(o.type="codeTextData",a(e))}}};exports.codeText=n;
+//# sourceMappingURL=code-text.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/code-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-text.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/code-text.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}"],"names":["codeText","name","previous","code","this","events","length","type","resolve","index","enter","tailExitIndex","headEnterIndex","undefined","end","splice","tokenize","effects","ok","nok","size","token","sizeOpen","sequenceOpen","consume","exit","between","sequenceClose","markdownLineEnding","data"],"mappings":"6HAcY,MAACA,EAAW,CACtBC,KAAM,WACNC,SA2DF,SAAkBC,GAEhB,OAAgB,KAATA,GAA+D,oBAAhDC,KAAKC,OAAOD,KAAKC,OAAOC,OAAS,GAAG,GAAGC,IAC/D,EA7DEC,QAMF,SAAyBH,GACvB,IAGII,EAEAC,EALAC,EAAgBN,EAAOC,OAAS,EAChCM,EAAiB,EAOrB,KAAwC,eAAnCP,EAAOO,GAAgB,GAAGL,MAA4D,UAAnCF,EAAOO,GAAgB,GAAGL,MAAwD,eAAlCF,EAAOM,GAAe,GAAGJ,MAA2D,UAAlCF,EAAOM,GAAe,GAAGJ,MAIjL,IAHAE,EAAQG,IAGCH,EAAQE,GACf,GAA8B,iBAA1BN,EAAOI,GAAO,GAAGF,KAAyB,CAE5CF,EAAOO,GAAgB,GAAGL,KAAO,kBACjCF,EAAOM,GAAe,GAAGJ,KAAO,kBAChCK,GAAkB,EAClBD,GAAiB,EACjB,KACD,CAKLF,EAAQG,EAAiB,EACzBD,IACA,OAASF,GAASE,QACFE,IAAVH,EACED,IAAUE,GAA2C,eAA1BN,EAAOI,GAAO,GAAGF,OAC9CG,EAAQD,GAEDA,IAAUE,GAA2C,eAA1BN,EAAOI,GAAO,GAAGF,OACrDF,EAAOK,GAAO,GAAGH,KAAO,eACpBE,IAAUC,EAAQ,IACpBL,EAAOK,GAAO,GAAGI,IAAMT,EAAOI,EAAQ,GAAG,GAAGK,IAC5CT,EAAOU,OAAOL,EAAQ,EAAGD,EAAQC,EAAQ,GACzCC,GAAiBF,EAAQC,EAAQ,EACjCD,EAAQC,EAAQ,GAElBA,OAAQG,GAGZ,OAAOR,CACT,EAlDEW,SAmEF,SAA0BC,EAASC,EAAIC,GAErC,IAEIC,EAEAC,EAJAC,EAAW,EAKf,OAcA,SAAenB,GAGb,OAFAc,EAAQP,MAAM,YACdO,EAAQP,MAAM,oBACPa,EAAapB,EACrB,EAYD,SAASoB,EAAapB,GACpB,OAAa,KAATA,GACFc,EAAQO,QAAQrB,GAChBmB,IACOC,IAETN,EAAQQ,KAAK,oBACNC,EAAQvB,GAChB,CAYD,SAASuB,EAAQvB,GAEf,OAAa,OAATA,EACKgB,EAAIhB,GAMA,KAATA,GACFc,EAAQP,MAAM,SACdO,EAAQO,QAAQrB,GAChBc,EAAQQ,KAAK,SACNC,GAII,KAATvB,GACFkB,EAAQJ,EAAQP,MAAM,oBACtBU,EAAO,EACAO,EAAcxB,IAEnByB,EAAAA,mBAAmBzB,IACrBc,EAAQP,MAAM,cACdO,EAAQO,QAAQrB,GAChBc,EAAQQ,KAAK,cACNC,IAITT,EAAQP,MAAM,gBACPmB,EAAK1B,GACb,CAYD,SAAS0B,EAAK1B,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAeyB,qBAAmBzB,IACpEc,EAAQQ,KAAK,gBACNC,EAAQvB,KAEjBc,EAAQO,QAAQrB,GACT0B,EACR,CAYD,SAASF,EAAcxB,GAErB,OAAa,KAATA,GACFc,EAAQO,QAAQrB,GAChBiB,IACOO,GAILP,IAASE,GACXL,EAAQQ,KAAK,oBACbR,EAAQQ,KAAK,YACNP,EAAGf,KAIZkB,EAAMd,KAAO,eACNsB,EAAK1B,GACb,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/content.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("../../micromark-factory-space/index.js"),e=require("../../micromark-util-character/index.js"),t=require("../../micromark-util-subtokenize/index.js");const r={resolve:function(n){return t.subtokenize(n),n},tokenize:function(n,t){let r;return function(e){return n.enter("content"),r=n.enter("chunkContent",{contentType:"content"}),o(e)};function o(t){return null===t?c(t):e.markdownLineEnding(t)?n.check(i,u,c)(t):(n.consume(t),o)}function c(e){return n.exit("chunkContent"),n.exit("content"),t(e)}function u(e){return n.consume(e),n.exit("chunkContent"),r.next=n.enter("chunkContent",{contentType:"content",previous:r}),r=r.next,o}}},i={partial:!0,tokenize:function(t,r,i){const o=this;return function(e){return t.exit("chunkContent"),t.enter("lineEnding"),t.consume(e),t.exit("lineEnding"),n.factorySpace(t,c,"linePrefix")};function c(n){if(null===n||e.markdownLineEnding(n))return i(n);const c=o.events[o.events.length-1];return!o.parser.constructs.disable.null.includes("codeIndented")&&c&&"linePrefix"===c[1].type&&c[2].sliceSerialize(c[1],!0).length>=4?r(n):t.interrupt(o.parser.constructs.flow,i,r)(n)}}};exports.content=r;
+//# sourceMappingURL=content.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/content.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\n};\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}"],"names":["content","resolve","events","subtokenize","tokenize","effects","ok","previous","code","enter","contentType","chunkInside","contentEnd","markdownLineEnding","check","continuationConstruct","contentContinue","consume","exit","next","partial","nok","self","this","factorySpace","prefixed","tail","length","parser","constructs","disable","null","includes","type","sliceSerialize","interrupt","flow"],"mappings":"wOAkBY,MAACA,EAAU,CACrBC,QAgBF,SAAwBC,GAEtB,OADAC,EAAWA,YAACD,GACLA,CACT,EAlBEE,SAyBF,SAAyBC,EAASC,GAEhC,IAAIC,EACJ,OAYA,SAAoBC,GAKlB,OAJAH,EAAQI,MAAM,WACdF,EAAWF,EAAQI,MAAM,eAAgB,CACvCC,YAAa,YAERC,EAAYH,EACpB,EAYD,SAASG,EAAYH,GACnB,OAAa,OAATA,EACKI,EAAWJ,GAKhBK,EAAAA,mBAAmBL,GACdH,EAAQS,MAAMC,EAAuBC,EAAiBJ,EAAtDP,CAAkEG,IAI3EH,EAAQY,QAAQT,GACTG,EACR,CAOD,SAASC,EAAWJ,GAGlB,OAFAH,EAAQa,KAAK,gBACbb,EAAQa,KAAK,WACNZ,EAAGE,EACX,CAOD,SAASQ,EAAgBR,GAQvB,OAPAH,EAAQY,QAAQT,GAChBH,EAAQa,KAAK,gBACbX,EAASY,KAAOd,EAAQI,MAAM,eAAgB,CAC5CC,YAAa,UACbH,aAEFA,EAAWA,EAASY,KACbR,CACR,CACH,GAhGMI,EAAwB,CAC5BK,SAAS,EACThB,SAqGF,SAA8BC,EAASC,EAAIe,GACzC,MAAMC,EAAOC,KACb,OAOA,SAAwBf,GAKtB,OAJAH,EAAQa,KAAK,gBACbb,EAAQI,MAAM,cACdJ,EAAQY,QAAQT,GAChBH,EAAQa,KAAK,cACNM,eAAanB,EAASoB,EAAU,aACxC,EAOD,SAASA,EAASjB,GAChB,GAAa,OAATA,GAAiBK,EAAkBA,mBAACL,GACtC,OAAOa,EAAIb,GAKb,MAAMkB,EAAOJ,EAAKpB,OAAOoB,EAAKpB,OAAOyB,OAAS,GAC9C,OAAKL,EAAKM,OAAOC,WAAWC,QAAQC,KAAKC,SAAS,iBAAmBN,GAAyB,eAAjBA,EAAK,GAAGO,MAAyBP,EAAK,GAAGQ,eAAeR,EAAK,IAAI,GAAMC,QAAU,EACrJrB,EAAGE,GAELH,EAAQ8B,UAAUb,EAAKM,OAAOC,WAAWO,KAAMf,EAAKf,EAApDD,CAAwDG,EAChE,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/definition.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var i=require("../../micromark-factory-destination/index.js"),e=require("../../micromark-factory-label/index.js"),n=require("../../micromark-factory-space/index.js"),t=require("../../micromark-factory-title/index.js"),r=require("../../micromark-factory-whitespace/index.js"),o=require("../../micromark-util-character/index.js"),a=require("../../micromark-util-normalize-identifier/index.js");const c={name:"definition",tokenize:function(t,c,u){const d=this;let s;return function(i){return t.enter("definition"),function(i){return e.factoryLabel.call(d,t,l,u,"definitionLabel","definitionLabelMarker","definitionLabelString")(i)}(i)};function l(i){return s=a.normalizeIdentifier(d.sliceSerialize(d.events[d.events.length-1][1]).slice(1,-1)),58===i?(t.enter("definitionMarker"),t.consume(i),t.exit("definitionMarker"),m):u(i)}function m(i){return o.markdownLineEndingOrSpace(i)?r.factoryWhitespace(t,k)(i):k(i)}function k(e){return i.factoryDestination(t,p,u,"definitionDestination","definitionDestinationLiteral","definitionDestinationLiteralMarker","definitionDestinationRaw","definitionDestinationString")(e)}function p(i){return t.attempt(f,y,y)(i)}function y(i){return o.markdownSpace(i)?n.factorySpace(t,x,"whitespace")(i):x(i)}function x(i){return null===i||o.markdownLineEnding(i)?(t.exit("definition"),d.parser.defined.push(s),c(i)):u(i)}}},f={partial:!0,tokenize:function(i,e,a){return function(e){return o.markdownLineEndingOrSpace(e)?r.factoryWhitespace(i,c)(e):a(e)};function c(e){return t.factoryTitle(i,f,a,"definitionTitle","definitionTitleMarker","definitionTitleString")(e)}function f(e){return o.markdownSpace(e)?n.factorySpace(i,u,"whitespace")(e):u(e)}function u(i){return null===i||o.markdownLineEnding(i)?e(i):a(i)}}};exports.definition=c;
+//# sourceMappingURL=definition.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/definition.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["definition","name","tokenize","effects","ok","nok","self","this","identifier","code","enter","factoryLabel","call","labelAfter","before","normalizeIdentifier","sliceSerialize","events","length","slice","consume","exit","markerAfter","markdownLineEndingOrSpace","factoryWhitespace","destinationBefore","factoryDestination","destinationAfter","attempt","titleBefore","after","markdownSpace","factorySpace","afterWhitespace","markdownLineEnding","parser","defined","push","partial","beforeMarker","factoryTitle","titleAfter","titleAfterOptionalWhitespace"],"mappings":"4cAiBY,MAACA,EAAa,CACxBC,KAAM,aACNC,SAcF,SAA4BC,EAASC,EAAIC,GACvC,MAAMC,EAAOC,KAEb,IAAIC,EACJ,OAYA,SAAeC,GAKb,OADAN,EAAQO,MAAM,cAchB,SAAgBD,GAGd,OAAOE,eAAaC,KAAKN,EAAMH,EAASU,EAExCR,EAAK,kBAAmB,wBAAyB,wBAF1CM,CAEmEF,EAC3E,CAnBQK,CAAOL,EACf,EA8BD,SAASI,EAAWJ,GAElB,OADAD,EAAaO,EAAmBA,oBAACT,EAAKU,eAAeV,EAAKW,OAAOX,EAAKW,OAAOC,OAAS,GAAG,IAAIC,MAAM,GAAI,IAC1F,KAATV,GACFN,EAAQO,MAAM,oBACdP,EAAQiB,QAAQX,GAChBN,EAAQkB,KAAK,oBACNC,GAEFjB,EAAII,EACZ,CAYD,SAASa,EAAYb,GAEnB,OAAOc,4BAA0Bd,GAAQe,EAAAA,kBAAkBrB,EAASsB,EAA3BD,CAA8Cf,GAAQgB,EAAkBhB,EAClH,CAYD,SAASgB,EAAkBhB,GACzB,OAAOiB,EAAAA,mBAAmBvB,EAASwB,EAEnCtB,EAAK,wBAAyB,+BAAgC,qCAAsC,2BAA4B,8BAFzHqB,CAEwJjB,EAChK,CAYD,SAASkB,EAAiBlB,GACxB,OAAON,EAAQyB,QAAQC,EAAaC,EAAOA,EAApC3B,CAA2CM,EACnD,CAcD,SAASqB,EAAMrB,GACb,OAAOsB,gBAActB,GAAQuB,EAAAA,aAAa7B,EAAS8B,EAAiB,aAAvCD,CAAqDvB,GAAQwB,EAAgBxB,EAC3G,CAcD,SAASwB,EAAgBxB,GACvB,OAAa,OAATA,GAAiByB,EAAkBA,mBAACzB,IACtCN,EAAQkB,KAAK,cAKbf,EAAK6B,OAAOC,QAAQC,KAAK7B,GAKlBJ,EAAGK,IAELJ,EAAII,EACZ,CACH,GAlKMoB,EAAc,CAClBS,SAAS,EACTpC,SAuKF,SAA6BC,EAASC,EAAIC,GACxC,OAcA,SAAqBI,GACnB,OAAOc,4BAA0Bd,GAAQe,EAAAA,kBAAkBrB,EAASoC,EAA3Bf,CAAyCf,GAAQJ,EAAII,EAC/F,EAaD,SAAS8B,EAAa9B,GACpB,OAAO+B,EAAYA,aAACrC,EAASsC,EAAYpC,EAAK,kBAAmB,wBAAyB,wBAAnFmC,CAA4G/B,EACpH,CAYD,SAASgC,EAAWhC,GAClB,OAAOsB,gBAActB,GAAQuB,EAAAA,aAAa7B,EAASuC,EAA8B,aAApDV,CAAkEvB,GAAQiC,EAA6BjC,EACrI,CAYD,SAASiC,EAA6BjC,GACpC,OAAgB,OAATA,GAAiByB,EAAAA,mBAAmBzB,GAAQL,EAAGK,GAAQJ,EAAII,EACnE,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/hard-break-escape.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-util-character/index.js");const r={name:"hardBreakEscape",tokenize:function(r,n,a){return function(e){return r.enter("hardBreakEscape"),r.consume(e),t};function t(t){return e.markdownLineEnding(t)?(r.exit("hardBreakEscape"),n(t)):a(t)}}};exports.hardBreakEscape=r;
+//# sourceMappingURL=hard-break-escape.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/hard-break-escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hard-break-escape.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}"],"names":["hardBreakEscape","name","tokenize","effects","ok","nok","code","enter","consume","after","markdownLineEnding","exit"],"mappings":"6HAWY,MAACA,EAAkB,CAC7BC,KAAM,kBACNC,SAQF,SAAiCC,EAASC,EAAIC,GAC5C,OAaA,SAAeC,GAGb,OAFAH,EAAQI,MAAM,mBACdJ,EAAQK,QAAQF,GACTG,CACR,EAaD,SAASA,EAAMH,GACb,OAAII,EAAAA,mBAAmBJ,IACrBH,EAAQQ,KAAK,mBACNP,EAAGE,IAELD,EAAIC,EACZ,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/heading-atx.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),n=require("../../micromark-util-character/index.js"),t=require("../../micromark-util-chunked/index.js");const r={name:"headingAtx",resolve:function(e,n){let r,i,a=e.length-2,c=3;"whitespace"===e[c][1].type&&(c+=2);a-2>c&&"whitespace"===e[a][1].type&&(a-=2);"atxHeadingSequence"===e[a][1].type&&(c===a-1||a-4>c&&"whitespace"===e[a-2][1].type)&&(a-=c+1===a?2:4);a>c&&(r={type:"atxHeadingText",start:e[c][1].start,end:e[a][1].end},i={type:"chunkText",start:e[c][1].start,end:e[a][1].end,contentType:"text"},t.splice(e,c,a-c+1,[["enter",r,n],["enter",i,n],["exit",i,n],["exit",r,n]]));return e},tokenize:function(t,r,i){let a=0;return function(e){return t.enter("atxHeading"),function(e){return t.enter("atxHeadingSequence"),c(e)}(e)};function c(e){return 35===e&&a++<6?(t.consume(e),c):null===e||n.markdownLineEndingOrSpace(e)?(t.exit("atxHeadingSequence"),u(e)):i(e)}function u(i){return 35===i?(t.enter("atxHeadingSequence"),d(i)):null===i||n.markdownLineEnding(i)?(t.exit("atxHeading"),r(i)):n.markdownSpace(i)?e.factorySpace(t,u,"whitespace")(i):(t.enter("atxHeadingText"),o(i))}function d(e){return 35===e?(t.consume(e),d):(t.exit("atxHeadingSequence"),u(e))}function o(e){return null===e||35===e||n.markdownLineEndingOrSpace(e)?(t.exit("atxHeadingText"),u(e)):(t.consume(e),o)}}};exports.headingAtx=r;
+//# sourceMappingURL=heading-atx.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/heading-atx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-atx.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/heading-atx.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  resolve: resolveHeadingAtx,\n  tokenize: tokenizeHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: \"atxHeadingText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: \"chunkText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: \"text\"\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}"],"names":["headingAtx","name","resolve","events","context","content","text","contentEnd","length","contentStart","type","start","end","contentType","splice","tokenize","effects","ok","nok","size","code","enter","sequenceOpen","before","consume","markdownLineEndingOrSpace","exit","atBreak","sequenceFurther","markdownLineEnding","markdownSpace","factorySpace","data"],"mappings":"oOAeY,MAACA,EAAa,CACxBC,KAAM,aACNC,QAKF,SAA2BC,EAAQC,GACjC,IAGIC,EAEAC,EALAC,EAAaJ,EAAOK,OAAS,EAC7BC,EAAe,EAOkB,eAAjCN,EAAOM,GAAc,GAAGC,OAC1BD,GAAgB,GAIdF,EAAa,EAAIE,GAA+C,eAA/BN,EAAOI,GAAY,GAAGG,OACzDH,GAAc,GAEmB,uBAA/BJ,EAAOI,GAAY,GAAGG,OAAkCD,IAAiBF,EAAa,GAAKA,EAAa,EAAIE,GAAmD,eAAnCN,EAAOI,EAAa,GAAG,GAAGG,QACxJH,GAAcE,EAAe,IAAMF,EAAa,EAAI,GAElDA,EAAaE,IACfJ,EAAU,CACRK,KAAM,iBACNC,MAAOR,EAAOM,GAAc,GAAGE,MAC/BC,IAAKT,EAAOI,GAAY,GAAGK,KAE7BN,EAAO,CACLI,KAAM,YACNC,MAAOR,EAAOM,GAAc,GAAGE,MAC/BC,IAAKT,EAAOI,GAAY,GAAGK,IAC3BC,YAAa,QAEfC,EAAAA,OAAOX,EAAQM,EAAcF,EAAaE,EAAe,EAAG,CAAC,CAAC,QAASJ,EAASD,GAAU,CAAC,QAASE,EAAMF,GAAU,CAAC,OAAQE,EAAMF,GAAU,CAAC,OAAQC,EAASD,MAEjK,OAAOD,CACT,EAvCEY,SA8CF,SAA4BC,EAASC,EAAIC,GACvC,IAAIC,EAAO,EACX,OAYA,SAAeC,GAGb,OADAJ,EAAQK,MAAM,cAchB,SAAgBD,GAEd,OADAJ,EAAQK,MAAM,sBACPC,EAAaF,EACrB,CAhBQG,CAAOH,EACf,EA2BD,SAASE,EAAaF,GACpB,OAAa,KAATA,GAAeD,IAAS,GAC1BH,EAAQQ,QAAQJ,GACTE,GAII,OAATF,GAAiBK,EAAyBA,0BAACL,IAC7CJ,EAAQU,KAAK,sBACNC,EAAQP,IAEVF,EAAIE,EACZ,CAYD,SAASO,EAAQP,GACf,OAAa,KAATA,GACFJ,EAAQK,MAAM,sBACPO,EAAgBR,IAEZ,OAATA,GAAiBS,EAAkBA,mBAACT,IACtCJ,EAAQU,KAAK,cAINT,EAAGG,IAERU,EAAAA,cAAcV,GACTW,EAAAA,aAAaf,EAASW,EAAS,aAA/BI,CAA6CX,IAKtDJ,EAAQK,MAAM,kBACPW,EAAKZ,GACb,CAcD,SAASQ,EAAgBR,GACvB,OAAa,KAATA,GACFJ,EAAQQ,QAAQJ,GACTQ,IAETZ,EAAQU,KAAK,sBACNC,EAAQP,GAChB,CAYD,SAASY,EAAKZ,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAeK,EAAAA,0BAA0BL,IAC5DJ,EAAQU,KAAK,kBACNC,EAAQP,KAEjBJ,EAAQQ,QAAQJ,GACTY,EACR,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/html-flow.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("../../micromark-util-character/index.js"),e=require("../../micromark-util-html-tag-name/index.js"),t=require("./blank-line.js");const r={concrete:!0,name:"htmlFlow",resolveTo:function(n){let e=n.length;for(;e--&&("enter"!==n[e][0]||"htmlFlow"!==n[e][1].type););e>1&&"linePrefix"===n[e-2][1].type&&(n[e][1].start=n[e-2][1].start,n[e+1][1].start=n[e-2][1].start,n.splice(e-2,2));return n},tokenize:function(t,r,i){const c=this;let m,s,a,l,f;return function(n){return function(n){return t.enter("htmlFlow"),t.enter("htmlFlowData"),t.consume(n),d}(n)};function d(e){return 33===e?(t.consume(e),p):47===e?(t.consume(e),s=!0,k):63===e?(t.consume(e),m=3,c.interrupt?r:_):n.asciiAlpha(e)?(t.consume(e),a=String.fromCharCode(e),g):i(e)}function p(e){return 45===e?(t.consume(e),m=2,h):91===e?(t.consume(e),m=5,l=0,w):n.asciiAlpha(e)?(t.consume(e),m=4,c.interrupt?r:_):i(e)}function h(n){return 45===n?(t.consume(n),c.interrupt?r:_):i(n)}function w(n){const e="CDATA[";return n===e.charCodeAt(l++)?(t.consume(n),6===l?c.interrupt?r:b:w):i(n)}function k(e){return n.asciiAlpha(e)?(t.consume(e),a=String.fromCharCode(e),g):i(e)}function g(u){if(null===u||47===u||62===u||n.markdownLineEndingOrSpace(u)){const n=47===u,o=a.toLowerCase();return n||s||!e.htmlRawNames.includes(o)?e.htmlBlockNames.includes(a.toLowerCase())?(m=6,n?(t.consume(u),E):c.interrupt?r(u):b(u)):(m=7,c.interrupt&&!c.parser.lazy[c.now().line]?i(u):s?C(u):L(u)):(m=1,c.interrupt?r(u):b(u))}return 45===u||n.asciiAlphanumeric(u)?(t.consume(u),a+=String.fromCharCode(u),g):i(u)}function E(n){return 62===n?(t.consume(n),c.interrupt?r:b):i(n)}function C(e){return n.markdownSpace(e)?(t.consume(e),C):z(e)}function L(e){return 47===e?(t.consume(e),z):58===e||95===e||n.asciiAlpha(e)?(t.consume(e),x):n.markdownSpace(e)?(t.consume(e),L):z(e)}function x(e){return 45===e||46===e||58===e||95===e||n.asciiAlphanumeric(e)?(t.consume(e),x):S(e)}function S(e){return 61===e?(t.consume(e),A):n.markdownSpace(e)?(t.consume(e),S):L(e)}function A(e){return null===e||60===e||61===e||62===e||96===e?i(e):34===e||39===e?(t.consume(e),f=e,F):n.markdownSpace(e)?(t.consume(e),A):D(e)}function F(e){return e===f?(t.consume(e),f=null,y):null===e||n.markdownLineEnding(e)?i(e):(t.consume(e),F)}function D(e){return null===e||34===e||39===e||47===e||60===e||61===e||62===e||96===e||n.markdownLineEndingOrSpace(e)?S(e):(t.consume(e),D)}function y(e){return 47===e||62===e||n.markdownSpace(e)?L(e):i(e)}function z(n){return 62===n?(t.consume(n),j):i(n)}function j(e){return null===e||n.markdownLineEnding(e)?b(e):n.markdownSpace(e)?(t.consume(e),j):i(e)}function b(e){return 45===e&&2===m?(t.consume(e),O):60===e&&1===m?(t.consume(e),P):62===e&&4===m?(t.consume(e),B):63===e&&3===m?(t.consume(e),_):93===e&&5===m?(t.consume(e),T):!n.markdownLineEnding(e)||6!==m&&7!==m?null===e||n.markdownLineEnding(e)?(t.exit("htmlFlowData"),q(e)):(t.consume(e),b):(t.exit("htmlFlowData"),t.check(u,M,q)(e))}function q(n){return t.check(o,v,M)(n)}function v(n){return t.enter("lineEnding"),t.consume(n),t.exit("lineEnding"),N}function N(e){return null===e||n.markdownLineEnding(e)?q(e):(t.enter("htmlFlowData"),b(e))}function O(n){return 45===n?(t.consume(n),_):b(n)}function P(n){return 47===n?(t.consume(n),a="",R):b(n)}function R(r){if(62===r){const n=a.toLowerCase();return e.htmlRawNames.includes(n)?(t.consume(r),B):b(r)}return n.asciiAlpha(r)&&a.length<8?(t.consume(r),a+=String.fromCharCode(r),R):b(r)}function T(n){return 93===n?(t.consume(n),_):b(n)}function _(n){return 62===n?(t.consume(n),B):45===n&&2===m?(t.consume(n),_):b(n)}function B(e){return null===e||n.markdownLineEnding(e)?(t.exit("htmlFlowData"),M(e)):(t.consume(e),B)}function M(n){return t.exit("htmlFlow"),r(n)}}},u={partial:!0,tokenize:function(n,e,r){return function(u){return n.enter("lineEnding"),n.consume(u),n.exit("lineEnding"),n.attempt(t.blankLine,e,r)}}},o={partial:!0,tokenize:function(e,t,r){const u=this;return function(t){if(n.markdownLineEnding(t))return e.enter("lineEnding"),e.consume(t),e.exit("lineEnding"),o;return r(t)};function o(n){return u.parser.lazy[u.now().line]?r(n):t(n)}}};exports.htmlFlow=r;
+//# sourceMappingURL=html-flow.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/html-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-flow.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/html-flow.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  concrete: true,\n  name: 'htmlFlow',\n  resolveTo: resolveToHtmlFlow,\n  tokenize: tokenizeHtmlFlow\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  partial: true,\n  tokenize: tokenizeBlankLineBefore\n};\nconst nonLazyContinuationStart = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuationStart\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === \"linePrefix\") {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      // Always the case.\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}"],"names":["htmlFlow","concrete","name","resolveTo","events","index","length","type","start","splice","tokenize","effects","ok","nok","self","this","marker","closingTag","buffer","markerB","code","enter","consume","open","before","declarationOpen","tagCloseStart","interrupt","continuationDeclarationInside","asciiAlpha","String","fromCharCode","tagName","commentOpenInside","cdataOpenInside","value","charCodeAt","continuation","markdownLineEndingOrSpace","slash","toLowerCase","htmlRawNames","includes","htmlBlockNames","basicSelfClosing","parser","lazy","now","line","completeClosingTagAfter","completeAttributeNameBefore","asciiAlphanumeric","markdownSpace","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","markdownLineEnding","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","exit","continuationStart","check","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","partial","attempt","blankLine","after"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/html-text.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("../../micromark-factory-space/index.js"),e=require("../../micromark-util-character/index.js");const u={name:"htmlText",tokenize:function(u,r,t){const c=this;let o,i,m;return function(n){return u.enter("htmlText"),u.enter("htmlTextData"),u.consume(n),s};function s(n){return 33===n?(u.consume(n),a):47===n?(u.consume(n),A):63===n?(u.consume(n),E):e.asciiAlpha(n)?(u.consume(n),D):t(n)}function a(n){return 45===n?(u.consume(n),d):91===n?(u.consume(n),i=0,k):e.asciiAlpha(n)?(u.consume(n),g):t(n)}function d(n){return 45===n?(u.consume(n),p):t(n)}function l(n){return null===n?t(n):45===n?(u.consume(n),f):e.markdownLineEnding(n)?(m=l,_(n)):(u.consume(n),l)}function f(n){return 45===n?(u.consume(n),p):l(n)}function p(n){return 62===n?P(n):45===n?f(n):l(n)}function k(n){const e="CDATA[";return n===e.charCodeAt(i++)?(u.consume(n),6===i?h:k):t(n)}function h(n){return null===n?t(n):93===n?(u.consume(n),w):e.markdownLineEnding(n)?(m=h,_(n)):(u.consume(n),h)}function w(n){return 93===n?(u.consume(n),x):h(n)}function x(n){return 62===n?P(n):93===n?(u.consume(n),x):h(n)}function g(n){return null===n||62===n?P(n):e.markdownLineEnding(n)?(m=g,_(n)):(u.consume(n),g)}function E(n){return null===n?t(n):63===n?(u.consume(n),L):e.markdownLineEnding(n)?(m=E,_(n)):(u.consume(n),E)}function L(n){return 62===n?P(n):E(n)}function A(n){return e.asciiAlpha(n)?(u.consume(n),S):t(n)}function S(n){return 45===n||e.asciiAlphanumeric(n)?(u.consume(n),S):T(n)}function T(n){return e.markdownLineEnding(n)?(m=T,_(n)):e.markdownSpace(n)?(u.consume(n),T):P(n)}function D(n){return 45===n||e.asciiAlphanumeric(n)?(u.consume(n),D):47===n||62===n||e.markdownLineEndingOrSpace(n)?v(n):t(n)}function v(n){return 47===n?(u.consume(n),P):58===n||95===n||e.asciiAlpha(n)?(u.consume(n),O):e.markdownLineEnding(n)?(m=v,_(n)):e.markdownSpace(n)?(u.consume(n),v):P(n)}function O(n){return 45===n||46===n||58===n||95===n||e.asciiAlphanumeric(n)?(u.consume(n),O):j(n)}function j(n){return 61===n?(u.consume(n),y):e.markdownLineEnding(n)?(m=j,_(n)):e.markdownSpace(n)?(u.consume(n),j):v(n)}function y(n){return null===n||60===n||61===n||62===n||96===n?t(n):34===n||39===n?(u.consume(n),o=n,b):e.markdownLineEnding(n)?(m=y,_(n)):e.markdownSpace(n)?(u.consume(n),y):(u.consume(n),q)}function b(n){return n===o?(u.consume(n),o=void 0,C):null===n?t(n):e.markdownLineEnding(n)?(m=b,_(n)):(u.consume(n),b)}function q(n){return null===n||34===n||39===n||60===n||61===n||96===n?t(n):47===n||62===n||e.markdownLineEndingOrSpace(n)?v(n):(u.consume(n),q)}function C(n){return 47===n||62===n||e.markdownLineEndingOrSpace(n)?v(n):t(n)}function P(n){return 62===n?(u.consume(n),u.exit("htmlTextData"),u.exit("htmlText"),r):t(n)}function _(n){return u.exit("htmlTextData"),u.enter("lineEnding"),u.consume(n),u.exit("lineEnding"),z}function z(r){return e.markdownSpace(r)?n.factorySpace(u,I,"linePrefix",c.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(r):I(r)}function I(n){return u.enter("htmlTextData"),m(n)}}};exports.htmlText=u;
+//# sourceMappingURL=html-text.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/html-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-text.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/html-text.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"htmlText\");\n    effects.enter(\"htmlTextData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit(\"htmlTextData\");\n      effects.exit(\"htmlText\");\n      return ok;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}"],"names":["htmlText","name","tokenize","effects","ok","nok","self","this","marker","index","returnState","code","enter","consume","open","declarationOpen","tagCloseStart","instruction","asciiAlpha","tagOpen","commentOpenInside","cdataOpenInside","declaration","commentEnd","comment","commentClose","markdownLineEnding","lineEndingBefore","end","value","charCodeAt","cdata","cdataClose","cdataEnd","instructionClose","tagClose","asciiAlphanumeric","tagCloseBetween","markdownSpace","markdownLineEndingOrSpace","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","undefined","tagOpenAttributeValueQuotedAfter","exit","lineEndingAfter","factorySpace","lineEndingAfterPrefix","parser","constructs","disable","null","includes"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/label-end.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-destination/index.js"),r=require("../../micromark-factory-label/index.js"),n=require("../../micromark-factory-title/index.js"),t=require("../../micromark-factory-whitespace/index.js"),i=require("../../micromark-util-character/index.js"),a=require("../../micromark-util-chunked/index.js"),c=require("../../micromark-util-normalize-identifier/index.js"),l=require("../../micromark-util-resolve-all/index.js");const o={name:"labelEnd",resolveAll:function(e){let r=-1;const n=[];for(;++r<e.length;){const t=e[r][1];if(n.push(e[r]),"labelImage"===t.type||"labelLink"===t.type||"labelEnd"===t.type){const e="labelImage"===t.type?4:2;t.type="data",r+=e}}e.length!==n.length&&a.splice(e,0,e.length,n);return e},resolveTo:function(e,r){let n,t,i,c,o=e.length,u=0;for(;o--;)if(n=e[o][1],t){if("link"===n.type||"labelLink"===n.type&&n._inactive)break;"enter"===e[o][0]&&"labelLink"===n.type&&(n._inactive=!0)}else if(i){if("enter"===e[o][0]&&("labelImage"===n.type||"labelLink"===n.type)&&!n._balanced&&(t=o,"labelLink"!==n.type)){u=2;break}}else"labelEnd"===n.type&&(i=o);const s={type:"labelLink"===e[t][1].type?"link":"image",start:{...e[t][1].start},end:{...e[e.length-1][1].end}},f={type:"label",start:{...e[t][1].start},end:{...e[i][1].end}},d={type:"labelText",start:{...e[t+u+2][1].end},end:{...e[i-2][1].start}};return c=[["enter",s,r],["enter",f,r]],c=a.push(c,e.slice(t+1,t+u+3)),c=a.push(c,[["enter",d,r]]),c=a.push(c,l.resolveAll(r.parser.constructs.insideSpan.null,e.slice(t+u+4,i-3),r)),c=a.push(c,[["exit",d,r],e[i-2],e[i-1],["exit",f,r]]),c=a.push(c,e.slice(i+1)),c=a.push(c,[["exit",s,r]]),a.splice(e,t,e.length,c),e},tokenize:function(e,r,n){const t=this;let i,a,l=t.events.length;for(;l--;)if(("labelImage"===t.events[l][1].type||"labelLink"===t.events[l][1].type)&&!t.events[l][1]._balanced){i=t.events[l][1];break}return function(r){if(!i)return n(r);if(i._inactive)return k(r);return a=t.parser.defined.includes(c.normalizeIdentifier(t.sliceSerialize({start:i.end,end:t.now()}))),e.enter("labelEnd"),e.enter("labelMarker"),e.consume(r),e.exit("labelMarker"),e.exit("labelEnd"),o};function o(r){return 40===r?e.attempt(u,p,a?p:k)(r):91===r?e.attempt(s,p,a?d:k)(r):a?p(r):k(r)}function d(r){return e.attempt(f,p,k)(r)}function p(e){return r(e)}function k(e){return i._balanced=!0,n(e)}}},u={tokenize:function(r,a,c){return function(e){return r.enter("resource"),r.enter("resourceMarker"),r.consume(e),r.exit("resourceMarker"),l};function l(e){return i.markdownLineEndingOrSpace(e)?t.factoryWhitespace(r,o)(e):o(e)}function o(n){return 41===n?p(n):e.factoryDestination(r,u,s,"resourceDestination","resourceDestinationLiteral","resourceDestinationLiteralMarker","resourceDestinationRaw","resourceDestinationString",32)(n)}function u(e){return i.markdownLineEndingOrSpace(e)?t.factoryWhitespace(r,f)(e):p(e)}function s(e){return c(e)}function f(e){return 34===e||39===e||40===e?n.factoryTitle(r,d,c,"resourceTitle","resourceTitleMarker","resourceTitleString")(e):p(e)}function d(e){return i.markdownLineEndingOrSpace(e)?t.factoryWhitespace(r,p)(e):p(e)}function p(e){return 41===e?(r.enter("resourceMarker"),r.consume(e),r.exit("resourceMarker"),r.exit("resource"),a):c(e)}}},s={tokenize:function(e,n,t){const i=this;return function(n){return r.factoryLabel.call(i,e,a,l,"reference","referenceMarker","referenceString")(n)};function a(e){return i.parser.defined.includes(c.normalizeIdentifier(i.sliceSerialize(i.events[i.events.length-1][1]).slice(1,-1)))?n(e):t(e)}function l(e){return t(e)}}},f={tokenize:function(e,r,n){return function(r){return e.enter("reference"),e.enter("referenceMarker"),e.consume(r),e.exit("referenceMarker"),t};function t(t){return 93===t?(e.enter("referenceMarker"),e.consume(t),e.exit("referenceMarker"),e.exit("reference"),r):n(t)}}};exports.labelEnd=o;
+//# sourceMappingURL=label-end.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/label-end.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-end.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/label-end.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Event,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  resolveAll: resolveAllLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  tokenize: tokenizeLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  /** @type {Array<Event>} */\n  const newEvents = [];\n  while (++index < events.length) {\n    const token = events[index][1];\n    newEvents.push(events[index]);\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      const offset = token.type === \"labelImage\" ? 4 : 2;\n      token.type = \"data\";\n      index += offset;\n    }\n  }\n\n  // If the events are equal, we don't have to copy newEvents to events\n  if (events.length !== newEvents.length) {\n    splice(events, 0, events.length, newEvents);\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\n        break;\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === \"labelLink\") {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\n        open = index;\n        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\n    }\n  }\n  const group = {\n    type: events[open][1].type === \"labelLink\" ? \"link\" : \"image\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n  const label = {\n    type: \"label\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[close][1].end\n    }\n  };\n  const text = {\n    type: \"labelText\",\n    start: {\n      ...events[open + offset + 2][1].end\n    },\n    end: {\n      ...events[close - 2][1].start\n    }\n  };\n  media = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\n  while (index--) {\n    if ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter(\"resourceMarker\");\n      effects.consume(code);\n      effects.exit(\"resourceMarker\");\n      effects.exit(\"resource\");\n      return ok;\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter(\"referenceMarker\");\n      effects.consume(code);\n      effects.exit(\"referenceMarker\");\n      effects.exit(\"reference\");\n      return ok;\n    }\n    return nok(code);\n  }\n}"],"names":["labelEnd","name","resolveAll","events","index","newEvents","length","token","push","type","offset","splice","resolveTo","context","open","close","media","_inactive","_balanced","group","start","end","label","text","slice","parser","constructs","insideSpan","null","tokenize","effects","ok","nok","self","this","labelStart","defined","code","labelEndNok","includes","normalizeIdentifier","sliceSerialize","now","enter","consume","exit","after","attempt","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","resourceBefore","markdownLineEndingOrSpace","factoryWhitespace","resourceOpen","resourceEnd","factoryDestination","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","factoryTitle","resourceTitleAfter","factoryLabel","call","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/label-start-image.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={name:"labelStartImage",resolveAll:require("./label-end.js").labelEnd.resolveAll,tokenize:function(e,r,t){const l=this;return function(r){return e.enter("labelImage"),e.enter("labelImageMarker"),e.consume(r),e.exit("labelImageMarker"),n};function n(r){return 91===r?(e.enter("labelMarker"),e.consume(r),e.exit("labelMarker"),e.exit("labelImage"),a):t(r)}function a(e){return 94===e&&"_hiddenFootnoteSupport"in l.parser.constructs?t(e):r(e)}}};exports.labelStartImage=e;
+//# sourceMappingURL=label-start-image.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/label-start-image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-start-image.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/label-start-image.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartImage\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelImage\");\n    effects.enter(\"labelImageMarker\");\n    effects.consume(code);\n    effects.exit(\"labelImageMarker\");\n    return open;\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter(\"labelMarker\");\n      effects.consume(code);\n      effects.exit(\"labelMarker\");\n      effects.exit(\"labelImage\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}"],"names":["labelStartImage","name","resolveAll","labelEnd","tokenize","effects","ok","nok","self","this","code","enter","consume","exit","open","after","parser","constructs"],"mappings":"oEAYY,MAACA,EAAkB,CAC7BC,KAAM,kBACNC,qCAAoBC,SAACD,WACrBE,SAQF,SAAiCC,EAASC,EAAIC,GAC5C,MAAMC,EAAOC,KACb,OAYA,SAAeC,GAKb,OAJAL,EAAQM,MAAM,cACdN,EAAQM,MAAM,oBACdN,EAAQO,QAAQF,GAChBL,EAAQQ,KAAK,oBACNC,CACR,EAYD,SAASA,EAAKJ,GACZ,OAAa,KAATA,GACFL,EAAQM,MAAM,eACdN,EAAQO,QAAQF,GAChBL,EAAQQ,KAAK,eACbR,EAAQQ,KAAK,cACNE,GAEFR,EAAIG,EACZ,CA6BD,SAASK,EAAML,GAMb,OAAgB,KAATA,GAAe,2BAA4BF,EAAKQ,OAAOC,WAAaV,EAAIG,GAAQJ,EAAGI,EAC3F,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/label-start-link.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={name:"labelStartLink",resolveAll:require("./label-end.js").labelEnd.resolveAll,tokenize:function(e,t,n){const r=this;return function(t){return e.enter("labelLink"),e.enter("labelMarker"),e.consume(t),e.exit("labelMarker"),e.exit("labelLink"),l};function l(e){return 94===e&&"_hiddenFootnoteSupport"in r.parser.constructs?n(e):t(e)}}};exports.labelStartLink=e;
+//# sourceMappingURL=label-start-link.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/label-start-link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-start-link.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/label-start-link.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartLink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelLink\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelLink\");\n    return after;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}"],"names":["labelStartLink","name","resolveAll","labelEnd","tokenize","effects","ok","nok","self","this","code","enter","consume","exit","after","parser","constructs"],"mappings":"oEAYY,MAACA,EAAiB,CAC5BC,KAAM,iBACNC,qCAAoBC,SAACD,WACrBE,SAQF,SAAgCC,EAASC,EAAIC,GAC3C,MAAMC,EAAOC,KACb,OAYA,SAAeC,GAMb,OALAL,EAAQM,MAAM,aACdN,EAAQM,MAAM,eACdN,EAAQO,QAAQF,GAChBL,EAAQQ,KAAK,eACbR,EAAQQ,KAAK,aACNC,CACR,EAGD,SAASA,EAAMJ,GAKb,OAAgB,KAATA,GAAe,2BAA4BF,EAAKO,OAAOC,WAAaT,EAAIG,GAAQJ,EAAGI,EAC3F,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/line-ending.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js");const n={name:"lineEnding",tokenize:function(n,i){return function(r){return n.enter("lineEnding"),n.consume(r),n.exit("lineEnding"),e.factorySpace(n,i,"linePrefix")}}};exports.lineEnding=n;
+//# sourceMappingURL=line-ending.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/line-ending.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-ending.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/line-ending.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, ok, \"linePrefix\");\n  }\n}"],"names":["lineEnding","name","tokenize","effects","ok","code","enter","consume","exit","factorySpace"],"mappings":"4HAYY,MAACA,EAAa,CACxBC,KAAM,aACNC,SAQF,SAA4BC,EAASC,GACnC,OAGA,SAAeC,GAIb,OAHAF,EAAQG,MAAM,cACdH,EAAQI,QAAQF,GAChBF,EAAQK,KAAK,cACNC,eAAaN,EAASC,EAAI,aAClC,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/list.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),t=require("../../micromark-util-character/index.js"),n=require("./blank-line.js"),i=require("./thematic-break.js");const r={continuation:{tokenize:function(i,a,o){const s=this;return s.containerState._closeFlow=void 0,i.check(n.blankLine,function(t){return s.containerState.furtherBlankLines=s.containerState.furtherBlankLines||s.containerState.initialBlankLine,e.factorySpace(i,a,"listItemIndent",s.containerState.size+1)(t)},function(e){if(s.containerState.furtherBlankLines||!t.markdownSpace(e))return s.containerState.furtherBlankLines=void 0,s.containerState.initialBlankLine=void 0,l(e);return s.containerState.furtherBlankLines=void 0,s.containerState.initialBlankLine=void 0,i.attempt(c,a,l)(e)});function l(t){return s.containerState._closeFlow=!0,s.interrupt=void 0,e.factorySpace(i,i.attempt(r,a,o),"linePrefix",s.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(t)}}},exit:function(e){e.exit(this.containerState.type)},name:"list",tokenize:function(e,r,c){const o=this,s=o.events[o.events.length-1];let l=s&&"linePrefix"===s[1].type?s[2].sliceSerialize(s[1],!0).length:0,u=0;return function(n){const r=o.containerState.type||(42===n||43===n||45===n?"listUnordered":"listOrdered");if("listUnordered"===r?!o.containerState.marker||n===o.containerState.marker:t.asciiDigit(n)){if(o.containerState.type||(o.containerState.type=r,e.enter(r,{_container:!0})),"listUnordered"===r)return e.enter("listItemPrefix"),42===n||45===n?e.check(i.thematicBreak,c,d)(n):d(n);if(!o.interrupt||49===n)return e.enter("listItemPrefix"),e.enter("listItemValue"),f(n)}return c(n)};function f(n){return t.asciiDigit(n)&&++u<10?(e.consume(n),f):(!o.interrupt||u<2)&&(o.containerState.marker?n===o.containerState.marker:41===n||46===n)?(e.exit("listItemValue"),d(n)):c(n)}function d(t){return e.enter("listItemMarker"),e.consume(t),e.exit("listItemMarker"),o.containerState.marker=o.containerState.marker||t,e.check(n.blankLine,o.interrupt?c:m,e.attempt(a,k,S))}function m(e){return o.containerState.initialBlankLine=!0,l++,k(e)}function S(n){return t.markdownSpace(n)?(e.enter("listItemPrefixWhitespace"),e.consume(n),e.exit("listItemPrefixWhitespace"),k):c(n)}function k(t){return o.containerState.size=l+o.sliceSerialize(e.exit("listItemPrefix"),!0).length,r(t)}}},a={partial:!0,tokenize:function(n,i,r){const a=this;return e.factorySpace(n,function(e){const n=a.events[a.events.length-1];return!t.markdownSpace(e)&&n&&"listItemPrefixWhitespace"===n[1].type?i(e):r(e)},"listItemPrefixWhitespace",a.parser.constructs.disable.null.includes("codeIndented")?void 0:5)}},c={partial:!0,tokenize:function(t,n,i){const r=this;return e.factorySpace(t,function(e){const t=r.events[r.events.length-1];return t&&"listItemIndent"===t[1].type&&t[2].sliceSerialize(t[1],!0).length===r.containerState.size?n(e):i(e)},"listItemIndent",r.containerState.size+1)}};exports.list=r;
+//# sourceMappingURL=list.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/list.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n\n/** @type {Construct} */\nexport const list = {\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd,\n  name: 'list',\n  tokenize: tokenizeListStart\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  partial: true,\n  tokenize: tokenizeListItemPrefixWhitespace\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  partial: true,\n  tokenize: tokenizeIndent\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit(\"listItemValue\");\n      return atMarker(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter(\"listItemMarker\");\n    effects.consume(code);\n    effects.exit(\"listItemMarker\");\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"listItemPrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"listItemPrefixWhitespace\");\n      return endOfPrefix;\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Exiter}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}"],"names":["list","continuation","tokenize","effects","ok","nok","self","this","containerState","_closeFlow","undefined","check","blankLine","code","furtherBlankLines","initialBlankLine","factorySpace","size","markdownSpace","notInCurrentItem","attempt","indentConstruct","interrupt","parser","constructs","disable","null","includes","exit","type","name","tail","events","length","initialSize","sliceSerialize","kind","marker","asciiDigit","enter","_container","thematicBreak","atMarker","inside","consume","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","partial"],"mappings":"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"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/setext-underline.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),t=require("../../micromark-util-character/index.js");const n={name:"setextUnderline",resolveTo:function(e,t){let n,r,i,s=e.length;for(;s--;)if("enter"===e[s][0]){if("content"===e[s][1].type){n=s;break}"paragraph"===e[s][1].type&&(r=s)}else"content"===e[s][1].type&&e.splice(s,1),i||"definition"!==e[s][1].type||(i=s);const a={type:"setextHeading",start:{...e[n][1].start},end:{...e[e.length-1][1].end}};e[r][1].type="setextHeadingText",i?(e.splice(r,0,["enter",a,t]),e.splice(i+1,0,["exit",e[n][1],t]),e[n][1].end={...e[i][1].end}):e[n][1]=a;return e.push(["exit",a,t]),e},tokenize:function(n,r,i){const s=this;let a;return function(e){let t,r=s.events.length;for(;r--;)if("lineEnding"!==s.events[r][1].type&&"linePrefix"!==s.events[r][1].type&&"content"!==s.events[r][1].type){t="paragraph"===s.events[r][1].type;break}if(!s.parser.lazy[s.now().line]&&(s.interrupt||t))return n.enter("setextHeadingLine"),a=e,function(e){return n.enter("setextHeadingLineSequence"),o(e)}(e);return i(e)};function o(r){return r===a?(n.consume(r),o):(n.exit("setextHeadingLineSequence"),t.markdownSpace(r)?e.factorySpace(n,c,"lineSuffix")(r):c(r))}function c(e){return null===e||t.markdownLineEnding(e)?(n.exit("setextHeadingLine"),r(e)):i(e)}}};exports.setextUnderline=n;
+//# sourceMappingURL=setext-underline.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/setext-underline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setext-underline.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/setext-underline.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  resolveTo: resolveToSetextUnderline,\n  tokenize: tokenizeSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === \"content\") {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\n      }\n    }\n  }\n  const heading = {\n    type: \"setextHeading\",\n    start: {\n      ...events[content][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = {\n      ...events[definition][1].end\n    };\n  } else {\n    events[content][1] = heading;\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\n        paragraph = self.events[index][1].type === \"paragraph\";\n        break;\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}"],"names":["setextUnderline","name","resolveTo","events","context","content","text","definition","index","length","type","splice","heading","start","end","push","tokenize","effects","ok","nok","self","this","marker","code","paragraph","parser","lazy","now","line","interrupt","enter","inside","before","consume","exit","markdownSpace","factorySpace","after","markdownLineEnding"],"mappings":"iLAcY,MAACA,EAAkB,CAC7BC,KAAM,kBACNC,UAKF,SAAkCC,EAAQC,GAExC,IAEIC,EAEAC,EAEAC,EANAC,EAAQL,EAAOM,OAUnB,KAAOD,KACL,GAAyB,UAArBL,EAAOK,GAAO,GAAgB,CAChC,GAA8B,YAA1BL,EAAOK,GAAO,GAAGE,KAAoB,CACvCL,EAAUG,EACV,KACD,CAC6B,cAA1BL,EAAOK,GAAO,GAAGE,OACnBJ,EAAOE,EAEV,KAG+B,YAA1BL,EAAOK,GAAO,GAAGE,MAEnBP,EAAOQ,OAAOH,EAAO,GAElBD,GAAwC,eAA1BJ,EAAOK,GAAO,GAAGE,OAClCH,EAAaC,GAInB,MAAMI,EAAU,CACdF,KAAM,gBACNG,MAAO,IACFV,EAAOE,GAAS,GAAGQ,OAExBC,IAAK,IACAX,EAAOA,EAAOM,OAAS,GAAG,GAAGK,MAKpCX,EAAOG,GAAM,GAAGI,KAAO,oBAInBH,GACFJ,EAAOQ,OAAOL,EAAM,EAAG,CAAC,QAASM,EAASR,IAC1CD,EAAOQ,OAAOJ,EAAa,EAAG,EAAG,CAAC,OAAQJ,EAAOE,GAAS,GAAID,IAC9DD,EAAOE,GAAS,GAAGS,IAAM,IACpBX,EAAOI,GAAY,GAAGO,MAG3BX,EAAOE,GAAS,GAAKO,EAKvB,OADAT,EAAOY,KAAK,CAAC,OAAQH,EAASR,IACvBD,CACT,EAjEEa,SAwEF,SAAiCC,EAASC,EAAIC,GAC5C,MAAMC,EAAOC,KAEb,IAAIC,EACJ,OAaA,SAAeC,GACb,IAEIC,EAFAhB,EAAQY,EAAKjB,OAAOM,OAIxB,KAAOD,KAGL,GAAmC,eAA/BY,EAAKjB,OAAOK,GAAO,GAAGE,MAAwD,eAA/BU,EAAKjB,OAAOK,GAAO,GAAGE,MAAwD,YAA/BU,EAAKjB,OAAOK,GAAO,GAAGE,KAAoB,CAC1Ic,EAA2C,cAA/BJ,EAAKjB,OAAOK,GAAO,GAAGE,KAClC,KACD,CAKH,IAAKU,EAAKK,OAAOC,KAAKN,EAAKO,MAAMC,QAAUR,EAAKS,WAAaL,GAG3D,OAFAP,EAAQa,MAAM,qBACdR,EAASC,EAiBb,SAAgBA,GAEd,OADAN,EAAQa,MAAM,6BACPC,EAAOR,EACf,CAnBUS,CAAOT,GAEhB,OAAOJ,EAAII,EACZ,EA6BD,SAASQ,EAAOR,GACd,OAAIA,IAASD,GACXL,EAAQgB,QAAQV,GACTQ,IAETd,EAAQiB,KAAK,6BACNC,gBAAcZ,GAAQa,EAAAA,aAAanB,EAASoB,EAAO,aAA7BD,CAA2Cb,GAAQc,EAAMd,GACvF,CAaD,SAASc,EAAMd,GACb,OAAa,OAATA,GAAiBe,EAAkBA,mBAACf,IACtCN,EAAQiB,KAAK,qBACNhB,EAAGK,IAELJ,EAAII,EACZ,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/thematic-break.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),t=require("../../micromark-util-character/index.js");const r={name:"thematicBreak",tokenize:function(r,n,a){let c,i=0;return function(e){return r.enter("thematicBreak"),function(e){return c=e,u(e)}(e)};function u(e){return e===c?(r.enter("thematicBreakSequence"),o(e)):i>=3&&(null===e||t.markdownLineEnding(e))?(r.exit("thematicBreak"),n(e)):a(e)}function o(n){return n===c?(r.consume(n),i++,o):(r.exit("thematicBreakSequence"),t.markdownSpace(n)?e.factorySpace(r,u,"whitespace")(n):u(n))}}};exports.thematicBreak=r;
+//# sourceMappingURL=thematic-break.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/thematic-break.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thematic-break.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/thematic-break.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}"],"names":["thematicBreak","name","tokenize","effects","ok","nok","marker","size","code","enter","atBreak","before","sequence","markdownLineEnding","exit","consume","markdownSpace","factorySpace"],"mappings":"iLAaY,MAACA,EAAgB,CAC3BC,KAAM,gBACNC,SAQF,SAA+BC,EAASC,EAAIC,GAC1C,IAEIC,EAFAC,EAAO,EAGX,OAYA,SAAeC,GAGb,OAFAL,EAAQM,MAAM,iBAehB,SAAgBD,GAEd,OADAF,EAASE,EACFE,EAAQF,EAChB,CAhBQG,CAAOH,EACf,EA2BD,SAASE,EAAQF,GACf,OAAIA,IAASF,GACXH,EAAQM,MAAM,yBACPG,EAASJ,IAEdD,GAAQ,IAAe,OAATC,GAAiBK,EAAkBA,mBAACL,KACpDL,EAAQW,KAAK,iBACNV,EAAGI,IAELH,EAAIG,EACZ,CAYD,SAASI,EAASJ,GAChB,OAAIA,IAASF,GACXH,EAAQY,QAAQP,GAChBD,IACOK,IAETT,EAAQW,KAAK,yBACNE,gBAAcR,GAAQS,EAAAA,aAAad,EAASO,EAAS,aAA/BO,CAA6CT,GAAQE,EAAQF,GAC3F,CACH"}

package/dist/cjs/node_modules/micromark-factory-destination/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("../micromark-util-character/index.js");exports.factoryDestination=function(e,t,r,i,u,c,o,s,l){const m=l||Number.POSITIVE_INFINITY;let x=0;return function(t){if(60===t)return e.enter(i),e.enter(u),e.enter(c),e.consume(t),e.exit(c),a;if(null===t||32===t||41===t||n.asciiControl(t))return r(t);return e.enter(i),e.enter(o),e.enter(s),e.enter("chunkString",{contentType:"string"}),d(t)};function a(n){return 62===n?(e.enter(c),e.consume(n),e.exit(c),e.exit(u),e.exit(i),t):(e.enter(s),e.enter("chunkString",{contentType:"string"}),f(n))}function f(t){return 62===t?(e.exit("chunkString"),e.exit(s),a(t)):null===t||60===t||n.markdownLineEnding(t)?r(t):(e.consume(t),92===t?g:f)}function g(n){return 60===n||62===n||92===n?(e.consume(n),f):f(n)}function d(u){return x||null!==u&&41!==u&&!n.markdownLineEndingOrSpace(u)?x<m&&40===u?(e.consume(u),x++,d):41===u?(e.consume(u),x--,d):null===u||32===u||40===u||n.asciiControl(u)?r(u):(e.consume(u),92===u?k:d):(e.exit("chunkString"),e.exit(s),e.exit(o),e.exit(i),t(u))}function k(n){return 40===n||41===n||92===n?(e.consume(n),d):d(n)}};
+//# sourceMappingURL=index.js.map