@viswa-test/audit-log 0.0.1

package/dist/node_modules/micromark/lib/initialize/text.js

@@ -0,0 +1,2 @@
+const e={resolveAll:i()},t=r("string"),n=r("text");function r(e){return{resolveAll:i("text"===e?o:void 0),tokenize:function(t){const n=this,r=this.parser.constructs[e],i=t.attempt(r,o,f);return o;function o(e){return l(e)?i(e):f(e)}function f(e){if(null!==e)return t.enter("data"),t.consume(e),s;t.consume(e)}function s(e){return l(e)?(t.exit("data"),i(e)):(t.consume(e),s)}function l(e){if(null===e)return!0;const t=r[e];let i=-1;if(t)for(;++i<t.length;){const e=t[i];if(!e.previous||e.previous.call(n,n.previous))return!0}return!1}}}}function i(e){return function(t,n){let r,i=-1;for(;++i<=t.length;)void 0===r?t[i]&&"data"===t[i][1].type&&(r=i,i++):t[i]&&"data"===t[i][1].type||(i!==r+2&&(t[r][1].end=t[i-1][1].end,t.splice(r+2,i-r-2),i=r+2),r=void 0);return e?e(t,n):t}}function o(e,t){let n=0;for(;++n<=e.length;)if((n===e.length||"lineEnding"===e[n][1].type)&&"data"===e[n-1][1].type){const r=e[n-1][1],i=t.sliceStream(r);let o,f=i.length,s=-1,l=0;for(;f--;){const e=i[f];if("string"==typeof e){for(s=e.length;32===e.charCodeAt(s-1);)l++,s--;if(s)break;s=-1}else if(-2===e)o=!0,l++;else if(-1!==e){f++;break}}if(t._contentTypeTextTrailing&&n===e.length&&(l=0),l){const i={type:n===e.length||o||l<2?"lineSuffix":"hardBreakTrailing",start:{_bufferIndex:f?s:r.start._bufferIndex+s,_index:r.start._index+f,line:r.end.line,column:r.end.column-l,offset:r.end.offset-l},end:{...r.end}};r.end={...i.start},r.start.offset===r.end.offset?Object.assign(r,i):(e.splice(n,0,["enter",i,t],["exit",i,t]),n+=2)}n++}return e}export{e as resolver,t as string,n as text};
+//# sourceMappingURL=text.js.map

package/dist/node_modules/micromark/lib/initialize/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sources":["../../../../../node_modules/micromark/lib/initialize/text.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      // Allow final trailing whitespace.\n      if (context._contentTypeTextTrailing && eventIndex === events.length) {\n        size = 0;\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}"],"names":["resolver","resolveAll","createResolver","string","initializeFactory","text","field","resolveAllLineSuffixes","undefined","tokenize","effects","self","this","constructs","parser","attempt","start","notText","code","atBreak","enter","consume","data","exit","list","index","length","item","previous","call","extraResolver","events","context","type","end","splice","eventIndex","chunks","sliceStream","tabs","bufferIndex","size","chunk","charCodeAt","_contentTypeTextTrailing","token","_bufferIndex","_index","line","column","offset","Object","assign"],"mappings":"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"}

package/dist/node_modules/micromark/lib/parse.js

@@ -0,0 +1,2 @@
+import{combineExtensions as t}from"../../micromark-util-combine-extensions/index.js";import{content as i}from"./initialize/content.js";import{document as o}from"./initialize/document.js";import{flow as n}from"./initialize/flow.js";import{string as r,text as e}from"./initialize/text.js";import*as m from"./constructs.js";import{createTokenizer as s}from"./create-tokenizer.js";function c(c){const f={constructs:t([m,...(c||{}).extensions||[]]),content:u(i),defined:[],document:u(o),flow:u(n),lazy:{},string:u(r),text:u(e)};return f;function u(t){return function(i){return s(f,t,i)}}}export{c as parse};
+//# sourceMappingURL=parse.js.map

package/dist/node_modules/micromark/lib/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sources":["../../../../node_modules/micromark/lib/parse.js"],"sourcesContent":["/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}"],"names":["parse","options","parser","constructs","combineExtensions","defaultConstructs","extensions","content","create","defined","document","flow","lazy","string","text","initial","from","createTokenizer"],"mappings":"yXAwBO,SAASA,EAAMC,GACpB,MAKMC,EAAS,CACjBC,WAJEC,EAAkB,CAACC,MAFFJ,GAAW,IAEuBK,YAAc,KAK/DC,QAASC,EAAOD,GAChBE,QAAS,GACTC,SAAUF,EAAOE,GACjBC,KAAMH,EAAOG,GACbC,KAAM,CAAE,EACRC,OAAQL,EAAOK,GACfC,KAAMN,EAAOM,IAEf,OAAOZ,EAQP,SAASM,EAAOO,GACd,OAEA,SAAiBC,GACf,OAAOC,EAAgBf,EAAQa,EAASC,EACzC,CACF,CACH"}

package/dist/node_modules/micromark/lib/postprocess.js

@@ -0,0 +1,2 @@
+import{subtokenize as r}from"../../micromark-util-subtokenize/index.js";function o(o){for(;!r(o););return o}export{o as postprocess};
+//# sourceMappingURL=postprocess.js.map

package/dist/node_modules/micromark/lib/postprocess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postprocess.js","sources":["../../../../node_modules/micromark/lib/postprocess.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}"],"names":["postprocess","events","subtokenize"],"mappings":"wEAYO,SAASA,EAAYC,GAC1B,MAAQC,EAAYD,KAGpB,OAAOA,CACT"}

package/dist/node_modules/micromark/lib/preprocess.js

@@ -0,0 +1,2 @@
+const e=/[\0\t\n\r]/g;function t(){let t,s=1,n="",o=!0;return function(i,r,c){const h=[];let u,d,a,l,p;i=n+("string"==typeof i?i.toString():new TextDecoder(r||void 0).decode(i)),a=0,n="",o&&(65279===i.charCodeAt(0)&&a++,o=void 0);for(;a<i.length;){if(e.lastIndex=a,u=e.exec(i),l=u&&void 0!==u.index?u.index:i.length,p=i.charCodeAt(l),!u){n=i.slice(a);break}if(10===p&&a===l&&t)h.push(-3),t=void 0;else switch(t&&(h.push(-5),t=void 0),a<l&&(h.push(i.slice(a,l)),s+=l-a),p){case 0:h.push(65533),s++;break;case 9:for(d=4*Math.ceil(s/4),h.push(-2);s++<d;)h.push(-1);break;case 10:h.push(-4),s=1;break;default:t=!0,s=1}a=l+1}c&&(t&&h.push(-5),n&&h.push(n),h.push(null));return h}}export{t as preprocess};
+//# sourceMappingURL=preprocess.js.map

package/dist/node_modules/micromark/lib/preprocess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess.js","sources":["../../../../node_modules/micromark/lib/preprocess.js"],"sourcesContent":["/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}"],"names":["search","preprocess","atCarriageReturn","column","buffer","start","value","encoding","end","chunks","match","next","startPosition","endPosition","code","toString","TextDecoder","undefined","decode","charCodeAt","length","lastIndex","exec","index","slice","push","Math","ceil"],"mappings":"AAiBA,MAAMA,EAAS,cAMR,SAASC,IACd,IAKIC,EALAC,EAAS,EACTC,EAAS,GAETC,GAAQ,EAGZ,OAIA,SAAsBC,EAAOC,EAAUC,GAErC,MAAMC,EAAS,GAEf,IAAIC,EAEAC,EAEAC,EAEAC,EAEAC,EACJR,EAAQF,GAA2B,iBAAVE,EAAqBA,EAAMS,WAAa,IAAIC,YAAYT,QAAYU,GAAWC,OAAOZ,IAC/GM,EAAgB,EAChBR,EAAS,GACLC,IAE0B,QAAxBC,EAAMa,WAAW,IACnBP,IAEFP,OAAQY,GAEV,KAAOL,EAAgBN,EAAMc,QAAQ,CAKnC,GAJApB,EAAOqB,UAAYT,EACnBF,EAAQV,EAAOsB,KAAKhB,GACpBO,EAAcH,QAAyBO,IAAhBP,EAAMa,MAAsBb,EAAMa,MAAQjB,EAAMc,OACvEN,EAAOR,EAAMa,WAAWN,IACnBH,EAAO,CACVN,EAASE,EAAMkB,MAAMZ,GACrB,KACD,CACD,GAAa,KAATE,GAAeF,IAAkBC,GAAeX,EAClDO,EAAOgB,MAAM,GACbvB,OAAmBe,OAUnB,OARIf,IACFO,EAAOgB,MAAM,GACbvB,OAAmBe,GAEjBL,EAAgBC,IAClBJ,EAAOgB,KAAKnB,EAAMkB,MAAMZ,EAAeC,IACvCV,GAAUU,EAAcD,GAElBE,GACN,KAAK,EAEDL,EAAOgB,KAAK,OACZtB,IACA,MAEJ,KAAK,EAID,IAFAQ,EAA+B,EAAxBe,KAAKC,KAAKxB,EAAS,GAC1BM,EAAOgB,MAAM,GACNtB,IAAWQ,GAAMF,EAAOgB,MAAM,GACrC,MAEJ,KAAK,GAEDhB,EAAOgB,MAAM,GACbtB,EAAS,EACT,MAEJ,QAEID,GAAmB,EACnBC,EAAS,EAIjBS,EAAgBC,EAAc,CAC/B,CACGL,IACEN,GAAkBO,EAAOgB,MAAM,GAC/BrB,GAAQK,EAAOgB,KAAKrB,GACxBK,EAAOgB,KAAK,OAEd,OAAOhB,CACR,CACH"}

package/dist/node_modules/micromark-core-commonmark/lib/attention.js

@@ -0,0 +1,2 @@
+import{push as e,splice as t}from"../../micromark-util-chunked/index.js";import{classifyCharacter as n}from"../../micromark-util-classify-character/index.js";import{resolveAll as s}from"../../micromark-util-resolve-all/index.js";const r={name:"attention",resolveAll:function(n,r){let i,a,f,c,u,l,d,p,m=-1;for(;++m<n.length;)if("enter"===n[m][0]&&"attentionSequence"===n[m][1].type&&n[m][1]._close)for(i=m;i--;)if("exit"===n[i][0]&&"attentionSequence"===n[i][1].type&&n[i][1]._open&&r.sliceSerialize(n[i][1]).charCodeAt(0)===r.sliceSerialize(n[m][1]).charCodeAt(0)){if((n[i][1]._close||n[m][1]._open)&&(n[m][1].end.offset-n[m][1].start.offset)%3&&!((n[i][1].end.offset-n[i][1].start.offset+n[m][1].end.offset-n[m][1].start.offset)%3))continue;l=n[i][1].end.offset-n[i][1].start.offset>1&&n[m][1].end.offset-n[m][1].start.offset>1?2:1;const x={...n[i][1].end},h={...n[m][1].start};o(x,-l),o(h,l),c={type:l>1?"strongSequence":"emphasisSequence",start:x,end:{...n[i][1].end}},u={type:l>1?"strongSequence":"emphasisSequence",start:{...n[m][1].start},end:h},f={type:l>1?"strongText":"emphasisText",start:{...n[i][1].end},end:{...n[m][1].start}},a={type:l>1?"strong":"emphasis",start:{...c.start},end:{...u.end}},n[i][1].end={...c.start},n[m][1].start={...u.end},d=[],n[i][1].end.offset-n[i][1].start.offset&&(d=e(d,[["enter",n[i][1],r],["exit",n[i][1],r]])),d=e(d,[["enter",a,r],["enter",c,r],["exit",c,r],["enter",f,r]]),d=e(d,s(r.parser.constructs.insideSpan.null,n.slice(i+1,m),r)),d=e(d,[["exit",f,r],["enter",u,r],["exit",u,r],["exit",a,r]]),n[m][1].end.offset-n[m][1].start.offset?(p=2,d=e(d,[["enter",n[m][1],r],["exit",n[m][1],r]])):p=0,t(n,i-1,m-i+3,d),m=i+d.length-p-2;break}m=-1;for(;++m<n.length;)"attentionSequence"===n[m][1].type&&(n[m][1].type="data");return n},tokenize:function(e,t){const s=this.parser.constructs.attentionMarkers.null,r=this.previous,o=n(r);let i;return function(t){return i=t,e.enter("attentionSequence"),a(t)};function a(f){if(f===i)return e.consume(f),a;const c=e.exit("attentionSequence"),u=n(f),l=!u||2===u&&o||s.includes(f),d=!o||2===o&&u||s.includes(r);return c._open=Boolean(42===i?l:l&&(o||!d)),c._close=Boolean(42===i?d:d&&(u||!l)),t(f)}}};function o(e,t){e.column+=t,e.offset+=t,e._bufferIndex+=t}export{r as attention};
+//# sourceMappingURL=attention.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attention.js","sources":["../../../../node_modules/micromark-core-commonmark/lib/attention.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\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    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}"],"names":["attention","name","resolveAll","events","context","open","group","text","openingSequence","closingSequence","use","nextEvents","offset","index","length","type","_close","_open","sliceSerialize","charCodeAt","end","start","movePoint","push","parser","constructs","insideSpan","null","slice","splice","tokenize","effects","ok","attentionMarkers","this","previous","before","classifyCharacter","marker","code","enter","inside","consume","token","exit","after","includes","close","Boolean","point","column","_bufferIndex"],"mappings":"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"}

package/dist/node_modules/micromark-core-commonmark/lib/autolink.js

@@ -0,0 +1,2 @@
+import{asciiAlpha as n,asciiAlphanumeric as t,asciiControl as e,asciiAtext as o}from"../../micromark-util-character/index.js";const r={name:"autolink",tokenize:function(r,u,i){let c=0;return function(n){return r.enter("autolink"),r.enter("autolinkMarker"),r.consume(n),r.exit("autolinkMarker"),r.enter("autolinkProtocol"),a};function a(t){return n(t)?(r.consume(t),k):64===t?i(t):s(t)}function k(n){return 43===n||45===n||46===n||t(n)?(c=1,l(n)):s(n)}function l(n){return 58===n?(r.consume(n),c=0,m):(43===n||45===n||46===n||t(n))&&c++<32?(r.consume(n),l):(c=0,s(n))}function m(n){return 62===n?(r.exit("autolinkProtocol"),r.enter("autolinkMarker"),r.consume(n),r.exit("autolinkMarker"),r.exit("autolink"),u):null===n||32===n||60===n||e(n)?i(n):(r.consume(n),m)}function s(n){return 64===n?(r.consume(n),f):o(n)?(r.consume(n),s):i(n)}function f(n){return t(n)?x(n):i(n)}function x(n){return 46===n?(r.consume(n),c=0,f):62===n?(r.exit("autolinkProtocol").type="autolinkEmail",r.enter("autolinkMarker"),r.consume(n),r.exit("autolinkMarker"),r.exit("autolink"),u):M(n)}function M(n){if((45===n||t(n))&&c++<63){const t=45===n?M:x;return r.consume(n),t}return i(n)}}};export{r as autolink};
+//# sourceMappingURL=autolink.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autolink.js","sources":["../../../../node_modules/micromark-core-commonmark/lib/autolink.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"autolink\");\n    effects.enter(\"autolinkMarker\");\n    effects.consume(code);\n    effects.exit(\"autolinkMarker\");\n    effects.enter(\"autolinkProtocol\");\n    return open;\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}"],"names":["autolink","name","tokenize","effects","ok","nok","size","code","enter","consume","exit","open","asciiAlpha","schemeOrEmailAtext","emailAtext","asciiAlphanumeric","schemeInsideOrEmailAtext","urlInside","asciiControl","emailAtSignOrDot","asciiAtext","emailLabel","type","emailValue","next"],"mappings":"8HAWY,MAACA,EAAW,CACtBC,KAAM,WACNC,SAQF,SAA0BC,EAASC,EAAIC,GACrC,IAAIC,EAAO,EACX,OAcA,SAAeC,GAMb,OALAJ,EAAQK,MAAM,YACdL,EAAQK,MAAM,kBACdL,EAAQM,QAAQF,GAChBJ,EAAQO,KAAK,kBACbP,EAAQK,MAAM,oBACPG,CACR,EAcD,SAASA,EAAKJ,GACZ,OAAIK,EAAWL,IACbJ,EAAQM,QAAQF,GACTM,GAEI,KAATN,EACKF,EAAIE,GAENO,EAAWP,EACnB,CAcD,SAASM,EAAmBN,GAE1B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeQ,EAAkBR,IAEjED,EAAO,EACAU,EAAyBT,IAE3BO,EAAWP,EACnB,CAcD,SAASS,EAAyBT,GAChC,OAAa,KAATA,GACFJ,EAAQM,QAAQF,GAChBD,EAAO,EACAW,IAIK,KAATV,GAAwB,KAATA,GAAwB,KAATA,GAAeQ,EAAkBR,KAAUD,IAAS,IACrFH,EAAQM,QAAQF,GACTS,IAETV,EAAO,EACAQ,EAAWP,GACnB,CAYD,SAASU,EAAUV,GACjB,OAAa,KAATA,GACFJ,EAAQO,KAAK,oBACbP,EAAQK,MAAM,kBACdL,EAAQM,QAAQF,GAChBJ,EAAQO,KAAK,kBACbP,EAAQO,KAAK,YACNN,GAII,OAATG,GAA0B,KAATA,GAAwB,KAATA,GAAeW,EAAaX,GACvDF,EAAIE,IAEbJ,EAAQM,QAAQF,GACTU,EACR,CAYD,SAASH,EAAWP,GAClB,OAAa,KAATA,GACFJ,EAAQM,QAAQF,GACTY,GAELC,EAAWb,IACbJ,EAAQM,QAAQF,GACTO,GAEFT,EAAIE,EACZ,CAYD,SAASY,EAAiBZ,GACxB,OAAOQ,EAAkBR,GAAQc,EAAWd,GAAQF,EAAIE,EACzD,CAYD,SAASc,EAAWd,GAClB,OAAa,KAATA,GACFJ,EAAQM,QAAQF,GAChBD,EAAO,EACAa,GAEI,KAATZ,GAEFJ,EAAQO,KAAK,oBAAoBY,KAAO,gBACxCnB,EAAQK,MAAM,kBACdL,EAAQM,QAAQF,GAChBJ,EAAQO,KAAK,kBACbP,EAAQO,KAAK,YACNN,GAEFmB,EAAWhB,EACnB,CAcD,SAASgB,EAAWhB,GAElB,IAAc,KAATA,GAAeQ,EAAkBR,KAAUD,IAAS,GAAI,CAC3D,MAAMkB,EAAgB,KAATjB,EAAcgB,EAAaF,EAExC,OADAlB,EAAQM,QAAQF,GACTiB,CACR,CACD,OAAOnB,EAAIE,EACZ,CACH"}

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

@@ -0,0 +1,2 @@
+import{factorySpace as r}from"../../micromark-factory-space/index.js";import{markdownSpace as n,markdownLineEnding as t}from"../../micromark-util-character/index.js";const i={partial:!0,tokenize:function(i,o,e){return function(t){return n(t)?r(i,c,"linePrefix")(t):c(t)};function c(r){return null===r||t(r)?o(r):e(r)}}};export{i as blankLine};
+//# sourceMappingURL=blank-line.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blank-line.js","sources":["../../../../node_modules/micromark-core-commonmark/lib/blank-line.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 blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["blankLine","partial","tokenize","effects","ok","nok","code","markdownSpace","factorySpace","after","markdownLineEnding"],"mappings":"sKAYY,MAACA,EAAY,CACvBC,SAAS,EACTC,SAQF,SAA2BC,EAASC,EAAIC,GACtC,OAgBA,SAAeC,GACb,OAAOC,EAAcD,GAAQE,EAAaL,EAASM,EAAO,aAA7BD,CAA2CF,GAAQG,EAAMH,EACvF,EAgBD,SAASG,EAAMH,GACb,OAAgB,OAATA,GAAiBI,EAAmBJ,GAAQF,EAAGE,GAAQD,EAAIC,EACnE,CACH"}

package/dist/node_modules/micromark-core-commonmark/lib/block-quote.js

@@ -0,0 +1,2 @@
+import{factorySpace as e}from"../../micromark-factory-space/index.js";import{markdownSpace as t}from"../../micromark-util-character/index.js";const n={continuation:{tokenize:function(o,r,i){const c=this;return function(n){if(t(n))return e(o,u,"linePrefix",c.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(n);return u(n)};function u(e){return o.attempt(n,r,i)(e)}}},exit:function(e){e.exit("blockQuote")},name:"blockQuote",tokenize:function(e,n,o){const r=this;return function(t){if(62===t){const n=r.containerState;return n.open||(e.enter("blockQuote",{_container:!0}),n.open=!0),e.enter("blockQuotePrefix"),e.enter("blockQuoteMarker"),e.consume(t),e.exit("blockQuoteMarker"),i}return o(t)};function i(o){return t(o)?(e.enter("blockQuotePrefixWhitespace"),e.consume(o),e.exit("blockQuotePrefixWhitespace"),e.exit("blockQuotePrefix"),n):(e.exit("blockQuotePrefix"),n(o))}}};export{n as blockQuote};
+//# sourceMappingURL=block-quote.js.map

package/dist/node_modules/micromark-core-commonmark/lib/block-quote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-quote.js","sources":["../../../../node_modules/micromark-core-commonmark/lib/block-quote.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"blockQuotePrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"blockQuotePrefixWhitespace\");\n      effects.exit(\"blockQuotePrefix\");\n      return ok;\n    }\n    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}"],"names":["blockQuote","continuation","tokenize","effects","ok","nok","self","this","code","markdownSpace","factorySpace","contBefore","parser","constructs","disable","null","includes","undefined","attempt","exit","name","state","containerState","open","enter","_container","consume","after"],"mappings":"8IAaY,MAACA,EAAa,CACxBC,aAAc,CACZC,SAgFJ,SAAwCC,EAASC,EAAIC,GACnD,MAAMC,EAAOC,KACb,OAeA,SAAmBC,GACjB,GAAIC,EAAcD,GAGhB,OAAOE,EAAaP,EAASQ,EAAY,aAAcL,EAAKM,OAAOC,WAAWC,QAAQC,KAAKC,SAAS,qBAAkBC,EAAY,EAA3HP,CAA8HF,GAEvI,OAAOG,EAAWH,EACnB,EAeD,SAASG,EAAWH,GAClB,OAAOL,EAAQe,QAAQlB,EAAYI,EAAIC,EAAhCF,CAAqCK,EAC7C,CACH,GAxHEW,KA2HF,SAAchB,GACZA,EAAQgB,KAAK,aACf,EA5HEC,KAAM,aACNlB,SAQF,SAAiCC,EAASC,EAAIC,GAC5C,MAAMC,EAAOC,KACb,OAYA,SAAeC,GACb,GAAa,KAATA,EAAa,CACf,MAAMa,EAAQf,EAAKgB,eAWnB,OAVKD,EAAME,OACTpB,EAAQqB,MAAM,aAAc,CAC1BC,YAAY,IAEdJ,EAAME,MAAO,GAEfpB,EAAQqB,MAAM,oBACdrB,EAAQqB,MAAM,oBACdrB,EAAQuB,QAAQlB,GAChBL,EAAQgB,KAAK,oBACNQ,CACR,CACD,OAAOtB,EAAIG,EACZ,EAYD,SAASmB,EAAMnB,GACb,OAAIC,EAAcD,IAChBL,EAAQqB,MAAM,8BACdrB,EAAQuB,QAAQlB,GAChBL,EAAQgB,KAAK,8BACbhB,EAAQgB,KAAK,oBACNf,IAETD,EAAQgB,KAAK,oBACNf,EAAGI,GACX,CACH"}

package/dist/node_modules/micromark-core-commonmark/lib/character-escape.js

@@ -0,0 +1,2 @@
+import{asciiPunctuation as e}from"../../micromark-util-character/index.js";const r={name:"characterEscape",tokenize:function(r,c,a){return function(e){return r.enter("characterEscape"),r.enter("escapeMarker"),r.consume(e),r.exit("escapeMarker"),t};function t(t){return e(t)?(r.enter("characterEscapeValue"),r.consume(t),r.exit("characterEscapeValue"),r.exit("characterEscape"),c):a(t)}}};export{r as characterEscape};
+//# sourceMappingURL=character-escape.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"character-escape.js","sources":["../../../../node_modules/micromark-core-commonmark/lib/character-escape.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter(\"characterEscapeValue\");\n      effects.consume(code);\n      effects.exit(\"characterEscapeValue\");\n      effects.exit(\"characterEscape\");\n      return ok;\n    }\n    return nok(code);\n  }\n}"],"names":["characterEscape","name","tokenize","effects","ok","nok","code","enter","consume","exit","inside","asciiPunctuation"],"mappings":"2EAWY,MAACA,EAAkB,CAC7BC,KAAM,kBACNC,SAQF,SAAiCC,EAASC,EAAIC,GAC5C,OAYA,SAAeC,GAKb,OAJAH,EAAQI,MAAM,mBACdJ,EAAQI,MAAM,gBACdJ,EAAQK,QAAQF,GAChBH,EAAQM,KAAK,gBACNC,CACR,EAYD,SAASA,EAAOJ,GAEd,OAAIK,EAAiBL,IACnBH,EAAQI,MAAM,wBACdJ,EAAQK,QAAQF,GAChBH,EAAQM,KAAK,wBACbN,EAAQM,KAAK,mBACNL,GAEFC,EAAIC,EACZ,CACH"}

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

@@ -0,0 +1,2 @@
+import{decodeNamedCharacterReference as e}from"../../decode-named-character-reference/index.dom.js";import{asciiAlphanumeric as r,asciiHexDigit as c,asciiDigit as a}from"../../micromark-util-character/index.js";const n={name:"characterReference",tokenize:function(n,t,i){const f=this;let u,o,h=0;return function(e){return n.enter("characterReference"),n.enter("characterReferenceMarker"),n.consume(e),n.exit("characterReferenceMarker"),m};function m(e){return 35===e?(n.enter("characterReferenceMarkerNumeric"),n.consume(e),n.exit("characterReferenceMarkerNumeric"),R):(n.enter("characterReferenceValue"),u=31,o=r,s(e))}function R(e){return 88===e||120===e?(n.enter("characterReferenceMarkerHexadecimal"),n.consume(e),n.exit("characterReferenceMarkerHexadecimal"),n.enter("characterReferenceValue"),u=6,o=c,s):(n.enter("characterReferenceValue"),u=7,o=a,s(e))}function s(c){if(59===c&&h){const a=n.exit("characterReferenceValue");return o!==r||e(f.sliceSerialize(a))?(n.enter("characterReferenceMarker"),n.consume(c),n.exit("characterReferenceMarker"),n.exit("characterReference"),t):i(c)}return o(c)&&h++<u?(n.consume(c),s):i(c)}}};export{n as characterReference};
+//# sourceMappingURL=character-reference.js.map

package/dist/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":"mNAaY,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,EACAC,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,EACAD,IAETf,EAAQS,MAAM,2BACdJ,EAAM,EACNC,EAAOW,EACAF,EAAMP,GACd,CAmBD,SAASO,EAAMP,GACb,GAAa,KAATA,GAAeD,EAAM,CACvB,MAAMW,EAAQlB,EAAQW,KAAK,2BAC3B,OAAIL,IAASQ,GAAsBK,EAA8BhB,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/node_modules/micromark-core-commonmark/lib/code-fenced.js

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

package/dist/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/node_modules/micromark-core-commonmark/lib/code-indented.js

@@ -0,0 +1,2 @@
+import{factorySpace as e}from"../../micromark-factory-space/index.js";import{markdownLineEnding as n}from"../../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(t,l,"linePrefix",5)(n)};function l(e){const n=c.events[c.events.length-1];return n&&"linePrefix"===n[1].type&&n[2].sliceSerialize(n[1],!0).length>=4?u(e):o(e)}function u(e){return null===e?a(e):n(e)?t.attempt(i,u,a)(e):(t.enter("codeFlowValue"),s(e))}function s(e){return null===e||n(e)?(t.exit("codeFlowValue"),u(e)):(t.consume(e),s)}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(i)?(t.enter("lineEnding"),t.consume(i),t.exit("lineEnding"),c):e(t,l,"linePrefix",5)(i)}function l(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(e)?c(e):r(e)}}};export{t as codeIndented};
+//# sourceMappingURL=code-indented.js.map

package/dist/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":"mJAYY,MAACA,EAAe,CAC1BC,KAAM,eACNC,SAcF,SAA8BC,EAASC,EAAIC,GACzC,MAAMC,EAAOC,KACb,OAgBA,SAAeC,GAMb,OAHAL,EAAQM,MAAM,gBAGPC,EAAaP,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,EAAmBX,GACdL,EAAQiB,QAAQC,EAAcJ,EAASC,EAAvCf,CAA8CK,IAEvDL,EAAQM,MAAM,iBACPa,EAAOd,GACf,CAYD,SAASc,EAAOd,GACd,OAAa,OAATA,GAAiBW,EAAmBX,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,EAAmBX,IACrBL,EAAQM,MAAM,cACdN,EAAQqB,QAAQhB,GAChBL,EAAQoB,KAAK,cACNF,GASFX,EAAaP,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,EAAmBX,GAAQa,EAAab,GAAQH,EAAIG,EACpK,CACH"}

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

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

package/dist/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":"6EAcY,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,EAAmBzB,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,EAAmBzB,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/node_modules/micromark-core-commonmark/lib/content.js

@@ -0,0 +1,2 @@
+import{factorySpace as n}from"../../micromark-factory-space/index.js";import{markdownLineEnding as e}from"../../micromark-util-character/index.js";import{subtokenize as t}from"../../micromark-util-subtokenize/index.js";const r={resolve:function(n){return t(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(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(t,c,"linePrefix")};function c(n){if(null===n||e(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)}}};export{r as content};
+//# sourceMappingURL=content.js.map

package/dist/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":"2NAkBY,MAACA,EAAU,CACrBC,QAgBF,SAAwBC,GAEtB,OADAC,EAAYD,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,EAAmBL,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,EAAmBL,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/node_modules/micromark-core-commonmark/lib/definition.js

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

package/dist/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":"4kBAiBY,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,EAAoBT,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,EAA0Bd,GAAQe,EAAkBrB,EAASsB,EAA3BD,CAA8Cf,GAAQgB,EAAkBhB,EAClH,CAYD,SAASgB,EAAkBhB,GACzB,OAAOiB,EAAmBvB,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,EAActB,GAAQuB,EAAa7B,EAAS8B,EAAiB,aAAvCD,CAAqDvB,GAAQwB,EAAgBxB,EAC3G,CAcD,SAASwB,EAAgBxB,GACvB,OAAa,OAATA,GAAiByB,EAAmBzB,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,EAA0Bd,GAAQe,EAAkBrB,EAASoC,EAA3Bf,CAAyCf,GAAQJ,EAAII,EAC/F,EAaD,SAAS8B,EAAa9B,GACpB,OAAO+B,EAAarC,EAASsC,EAAYpC,EAAK,kBAAmB,wBAAyB,wBAAnFmC,CAA4G/B,EACpH,CAYD,SAASgC,EAAWhC,GAClB,OAAOsB,EAActB,GAAQuB,EAAa7B,EAASuC,EAA8B,aAApDV,CAAkEvB,GAAQiC,EAA6BjC,EACrI,CAYD,SAASiC,EAA6BjC,GACpC,OAAgB,OAATA,GAAiByB,EAAmBzB,GAAQL,EAAGK,GAAQJ,EAAII,EACnE,CACH"}

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

@@ -0,0 +1,2 @@
+import{markdownLineEnding as r}from"../../micromark-util-character/index.js";const e={name:"hardBreakEscape",tokenize:function(e,n,t){return function(r){return e.enter("hardBreakEscape"),e.consume(r),a};function a(a){return r(a)?(e.exit("hardBreakEscape"),n(a)):t(a)}}};export{e as hardBreakEscape};
+//# sourceMappingURL=hard-break-escape.js.map

package/dist/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":"6EAWY,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,EAAmBJ,IACrBH,EAAQQ,KAAK,mBACNP,EAAGE,IAELD,EAAIC,EACZ,CACH"}

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

@@ -0,0 +1,2 @@
+import{factorySpace as e}from"../../micromark-factory-space/index.js";import{markdownLineEndingOrSpace as t,markdownLineEnding as n,markdownSpace as r}from"../../micromark-util-character/index.js";import{splice as i}from"../../micromark-util-chunked/index.js";const a={name:"headingAtx",resolve:function(e,t){let n,r,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&&(n={type:"atxHeadingText",start:e[c][1].start,end:e[a][1].end},r={type:"chunkText",start:e[c][1].start,end:e[a][1].end,contentType:"text"},i(e,c,a-c+1,[["enter",n,t],["enter",r,t],["exit",r,t],["exit",n,t]]));return e},tokenize:function(i,a,c){let u=0;return function(e){return i.enter("atxHeading"),function(e){return i.enter("atxHeadingSequence"),o(e)}(e)};function o(e){return 35===e&&u++<6?(i.consume(e),o):null===e||t(e)?(i.exit("atxHeadingSequence"),x(e)):c(e)}function x(t){return 35===t?(i.enter("atxHeadingSequence"),d(t)):null===t||n(t)?(i.exit("atxHeading"),a(t)):r(t)?e(i,x,"whitespace")(t):(i.enter("atxHeadingText"),s(t))}function d(e){return 35===e?(i.consume(e),d):(i.exit("atxHeadingSequence"),x(e))}function s(e){return null===e||35===e||t(e)?(i.exit("atxHeadingText"),x(e)):(i.consume(e),s)}}};export{a as headingAtx};
+//# sourceMappingURL=heading-atx.js.map

package/dist/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":"oQAeY,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,EAAOX,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,EAA0BL,IAC7CJ,EAAQU,KAAK,sBACNC,EAAQP,IAEVF,EAAIE,EACZ,CAYD,SAASO,EAAQP,GACf,OAAa,KAATA,GACFJ,EAAQK,MAAM,sBACPO,EAAgBR,IAEZ,OAATA,GAAiBS,EAAmBT,IACtCJ,EAAQU,KAAK,cAINT,EAAGG,IAERU,EAAcV,GACTW,EAAaf,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,EAA0BL,IAC5DJ,EAAQU,KAAK,kBACNC,EAAQP,KAEjBJ,EAAQQ,QAAQJ,GACTY,EACR,CACH"}

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

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

package/dist/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":"iTAgBY,MAACA,EAAW,CACtBC,UAAU,EACVC,KAAM,WACNC,UAeF,SAA2BC,GACzB,IAAIC,EAAQD,EAAOE,OACnB,KAAOD,MACoB,UAArBD,EAAOC,GAAO,IAA4C,aAA1BD,EAAOC,GAAO,GAAGE,QAInDF,EAAQ,GAAmC,eAA9BD,EAAOC,EAAQ,GAAG,GAAGE,OAEpCH,EAAOC,GAAO,GAAGG,MAAQJ,EAAOC,EAAQ,GAAG,GAAGG,MAE9CJ,EAAOC,EAAQ,GAAG,GAAGG,MAAQJ,EAAOC,EAAQ,GAAG,GAAGG,MAElDJ,EAAOK,OAAOJ,EAAQ,EAAG,IAE3B,OAAOD,CACT,EA9BEM,SAqCF,SAA0BC,EAASC,EAAIC,GACrC,MAAMC,EAAOC,KAEb,IAAIC,EAEAC,EAEAC,EAEAb,EAEAc,EACJ,OAYA,SAAeC,GAEb,OAaF,SAAgBA,GAId,OAHAT,EAAQU,MAAM,YACdV,EAAQU,MAAM,gBACdV,EAAQW,QAAQF,GACTG,CACR,CAlBQC,CAAOJ,EACf,EAiCD,SAASG,EAAKH,GACZ,OAAa,KAATA,GACFT,EAAQW,QAAQF,GACTK,GAEI,KAATL,GACFT,EAAQW,QAAQF,GAChBH,GAAa,EACNS,GAEI,KAATN,GACFT,EAAQW,QAAQF,GAChBJ,EAAS,EAMFF,EAAKa,UAAYf,EAAKgB,GAI3BC,EAAWT,IAEbT,EAAQW,QAAQF,GAChBF,EAASY,OAAOC,aAAaX,GACtBY,GAEFnB,EAAIO,EACZ,CAgBD,SAASK,EAAgBL,GACvB,OAAa,KAATA,GACFT,EAAQW,QAAQF,GAChBJ,EAAS,EACFiB,GAEI,KAATb,GACFT,EAAQW,QAAQF,GAChBJ,EAAS,EACTX,EAAQ,EACD6B,GAILL,EAAWT,IACbT,EAAQW,QAAQF,GAChBJ,EAAS,EAGFF,EAAKa,UAAYf,EAAKgB,GAExBf,EAAIO,EACZ,CAYD,SAASa,EAAkBb,GACzB,OAAa,KAATA,GACFT,EAAQW,QAAQF,GAGTN,EAAKa,UAAYf,EAAKgB,GAExBf,EAAIO,EACZ,CAYD,SAASc,EAAgBd,GACvB,MAAMe,EAAQ,SACd,OAAIf,IAASe,EAAMC,WAAW/B,MAC5BM,EAAQW,QAAQF,GACFe,IAAV9B,EAGKS,EAAKa,UAAYf,EAAKyB,EAExBH,GAEFrB,EAAIO,EACZ,CAYD,SAASM,EAAcN,GACrB,OAAIS,EAAWT,IAEbT,EAAQW,QAAQF,GAChBF,EAASY,OAAOC,aAAaX,GACtBY,GAEFnB,EAAIO,EACZ,CAcD,SAASY,EAAQZ,GACf,GAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAekB,EAA0BlB,GAAO,CAClF,MAAMmB,EAAiB,KAATnB,EACRlB,EAAOgB,EAAOsB,cACpB,OAAKD,GAAUtB,IAAcwB,EAAaC,SAASxC,GAM/CyC,EAAeD,SAASxB,EAAOsB,gBACjCxB,EAAS,EACLuB,GACF5B,EAAQW,QAAQF,GACTwB,GAKF9B,EAAKa,UAAYf,EAAGQ,GAAQiB,EAAajB,KAElDJ,EAAS,EAEFF,EAAKa,YAAcb,EAAK+B,OAAOC,KAAKhC,EAAKiC,MAAMC,MAAQnC,EAAIO,GAAQH,EAAagC,EAAwB7B,GAAQ8B,EAA4B9B,KAlBjJJ,EAAS,EAGFF,EAAKa,UAAYf,EAAGQ,GAAQiB,EAAajB,GAgBnD,CAGD,OAAa,KAATA,GAAe+B,EAAkB/B,IACnCT,EAAQW,QAAQF,GAChBF,GAAUY,OAAOC,aAAaX,GACvBY,GAEFnB,EAAIO,EACZ,CAYD,SAASwB,EAAiBxB,GACxB,OAAa,KAATA,GACFT,EAAQW,QAAQF,GAGTN,EAAKa,UAAYf,EAAKyB,GAExBxB,EAAIO,EACZ,CAYD,SAAS6B,EAAwB7B,GAC/B,OAAIgC,EAAchC,IAChBT,EAAQW,QAAQF,GACT6B,GAEFI,EAAYjC,EACpB,CAyBD,SAAS8B,EAA4B9B,GACnC,OAAa,KAATA,GACFT,EAAQW,QAAQF,GACTiC,GAII,KAATjC,GAAwB,KAATA,GAAeS,EAAWT,IAC3CT,EAAQW,QAAQF,GACTkC,GAELF,EAAchC,IAChBT,EAAQW,QAAQF,GACT8B,GAEFG,EAAYjC,EACpB,CAgBD,SAASkC,EAAsBlC,GAE7B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAe+B,EAAkB/B,IAChFT,EAAQW,QAAQF,GACTkC,GAEFC,EAA2BnC,EACnC,CAeD,SAASmC,EAA2BnC,GAClC,OAAa,KAATA,GACFT,EAAQW,QAAQF,GACToC,GAELJ,EAAchC,IAChBT,EAAQW,QAAQF,GACTmC,GAEFL,EAA4B9B,EACpC,CAeD,SAASoC,EAA6BpC,GACpC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzDP,EAAIO,GAEA,KAATA,GAAwB,KAATA,GACjBT,EAAQW,QAAQF,GAChBD,EAAUC,EACHqC,GAELL,EAAchC,IAChBT,EAAQW,QAAQF,GACToC,GAEFE,EAA+BtC,EACvC,CAcD,SAASqC,EAA6BrC,GACpC,OAAIA,IAASD,GACXR,EAAQW,QAAQF,GAChBD,EAAU,KACHwC,GAEI,OAATvC,GAAiBwC,EAAmBxC,GAC/BP,EAAIO,IAEbT,EAAQW,QAAQF,GACTqC,EACR,CAYD,SAASC,EAA+BtC,GACtC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAekB,EAA0BlB,GAC/ImC,EAA2BnC,IAEpCT,EAAQW,QAAQF,GACTsC,EACR,CAaD,SAASC,EAAkCvC,GACzC,OAAa,KAATA,GAAwB,KAATA,GAAegC,EAAchC,GACvC8B,EAA4B9B,GAE9BP,EAAIO,EACZ,CAYD,SAASiC,EAAYjC,GACnB,OAAa,KAATA,GACFT,EAAQW,QAAQF,GACTyC,GAEFhD,EAAIO,EACZ,CAYD,SAASyC,EAAczC,GACrB,OAAa,OAATA,GAAiBwC,EAAmBxC,GAG/BiB,EAAajB,GAElBgC,EAAchC,IAChBT,EAAQW,QAAQF,GACTyC,GAEFhD,EAAIO,EACZ,CAYD,SAASiB,EAAajB,GACpB,OAAa,KAATA,GAA0B,IAAXJ,GACjBL,EAAQW,QAAQF,GACT0C,GAEI,KAAT1C,GAA0B,IAAXJ,GACjBL,EAAQW,QAAQF,GACT2C,GAEI,KAAT3C,GAA0B,IAAXJ,GACjBL,EAAQW,QAAQF,GACT4C,GAEI,KAAT5C,GAA0B,IAAXJ,GACjBL,EAAQW,QAAQF,GACTQ,GAEI,KAATR,GAA0B,IAAXJ,GACjBL,EAAQW,QAAQF,GACT6C,IAELL,EAAmBxC,IAAqB,IAAXJ,GAA2B,IAAXA,EAIpC,OAATI,GAAiBwC,EAAmBxC,IACtCT,EAAQuD,KAAK,gBACNC,EAAkB/C,KAE3BT,EAAQW,QAAQF,GACTiB,IARL1B,EAAQuD,KAAK,gBACNvD,EAAQyD,MAAMC,EAAiBC,EAAmBH,EAAlDxD,CAAqES,GAQ/E,CAaD,SAAS+C,EAAkB/C,GACzB,OAAOT,EAAQyD,MAAMG,EAA0BC,EAA0BF,EAAlE3D,CAAqFS,EAC7F,CAaD,SAASoD,EAAyBpD,GAIhC,OAHAT,EAAQU,MAAM,cACdV,EAAQW,QAAQF,GAChBT,EAAQuD,KAAK,cACNO,CACR,CAaD,SAASA,EAAmBrD,GAC1B,OAAa,OAATA,GAAiBwC,EAAmBxC,GAC/B+C,EAAkB/C,IAE3BT,EAAQU,MAAM,gBACPgB,EAAajB,GACrB,CAYD,SAAS0C,EAA0B1C,GACjC,OAAa,KAATA,GACFT,EAAQW,QAAQF,GACTQ,GAEFS,EAAajB,EACrB,CAYD,SAAS2C,EAAuB3C,GAC9B,OAAa,KAATA,GACFT,EAAQW,QAAQF,GAChBF,EAAS,GACFwD,GAEFrC,EAAajB,EACrB,CAYD,SAASsD,EAAsBtD,GAC7B,GAAa,KAATA,EAAa,CACf,MAAMlB,EAAOgB,EAAOsB,cACpB,OAAIC,EAAaC,SAASxC,IACxBS,EAAQW,QAAQF,GACT4C,GAEF3B,EAAajB,EACrB,CACD,OAAIS,EAAWT,IAASF,EAAOZ,OAAS,GAEtCK,EAAQW,QAAQF,GAChBF,GAAUY,OAAOC,aAAaX,GACvBsD,GAEFrC,EAAajB,EACrB,CAYD,SAAS6C,EAAwB7C,GAC/B,OAAa,KAATA,GACFT,EAAQW,QAAQF,GACTQ,GAEFS,EAAajB,EACrB,CAoBD,SAASQ,EAA8BR,GACrC,OAAa,KAATA,GACFT,EAAQW,QAAQF,GACT4C,GAII,KAAT5C,GAA0B,IAAXJ,GACjBL,EAAQW,QAAQF,GACTQ,GAEFS,EAAajB,EACrB,CAYD,SAAS4C,EAAkB5C,GACzB,OAAa,OAATA,GAAiBwC,EAAmBxC,IACtCT,EAAQuD,KAAK,gBACNI,EAAkBlD,KAE3BT,EAAQW,QAAQF,GACT4C,EACR,CAYD,SAASM,EAAkBlD,GAMzB,OALAT,EAAQuD,KAAK,YAKNtD,EAAGQ,EACX,CACH,GA1wBMiD,EAAkB,CACtBM,SAAS,EACTjE,SA6zBF,SAAiCC,EAASC,EAAIC,GAC5C,OAaA,SAAeO,GAIb,OAHAT,EAAQU,MAAM,cACdV,EAAQW,QAAQF,GAChBT,EAAQuD,KAAK,cACNvD,EAAQiE,QAAQC,EAAWjE,EAAIC,EACvC,CACH,GA/0BM0D,EAA2B,CAC/BI,SAAS,EACTjE,SA2wBF,SAA0CC,EAASC,EAAIC,GACrD,MAAMC,EAAOC,KACb,OAaA,SAAeK,GACb,GAAIwC,EAAmBxC,GAIrB,OAHAT,EAAQU,MAAM,cACdV,EAAQW,QAAQF,GAChBT,EAAQuD,KAAK,cACNY,EAET,OAAOjE,EAAIO,EACZ,EAaD,SAAS0D,EAAM1D,GACb,OAAON,EAAK+B,OAAOC,KAAKhC,EAAKiC,MAAMC,MAAQnC,EAAIO,GAAQR,EAAGQ,EAC3D,CACH"}

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

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

package/dist/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/node_modules/micromark-core-commonmark/lib/label-end.js

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