@e-llm-studio/instant-learning 0.0.205 → 0.0.207

package/dist/node_modules/react-markdown/node_modules/mdast-util-from-markdown/lib/index.js

@@ -1,2 +0,0 @@
-import{toString as e}from"../../mdast-util-to-string/lib/index.js";import{parse as t}from"../../micromark/lib/parse.js";import{preprocess as n}from"../../micromark/lib/preprocess.js";import{postprocess as i}from"../../micromark/lib/postprocess.js";import{decodeNumericCharacterReference as r}from"../../micromark-util-decode-numeric-character-reference/index.js";import{decodeString as s}from"../../micromark-util-decode-string/index.js";import{normalizeIdentifier as c}from"../../micromark-util-normalize-identifier/index.js";import{decodeNamedCharacterReference as a}from"../../../../decode-named-character-reference/index.dom.js";import{stringifyPosition as l}from"../../unist-util-stringify-position/lib/index.js";const o={}.hasOwnProperty,h=function(h,f,k){return"string"!=typeof f&&(k=f,f=void 0),function(t){const n={transforms:[],canContainEols:["emphasis","fragment","heading","paragraph","strong"],enter:{autolink:g(de),autolinkProtocol:P,autolinkEmail:P,atxHeading:g(le),blockQuote:g(ie),characterEscape:P,characterReference:P,codeFenced:g(re),codeFencedFenceInfo:y,codeFencedFenceMeta:y,codeIndented:g(re,y),codeText:g(se,y),codeTextData:P,data:P,codeFlowValue:P,definition:g(ce),definitionDestinationString:y,definitionLabelString:y,definitionTitleString:y,emphasis:g(ae),hardBreakEscape:g(oe),hardBreakTrailing:g(oe),htmlFlow:g(he,y),htmlFlowData:P,htmlText:g(he,y),htmlTextData:P,image:g(ue),label:y,link:g(de),listItem:g(pe),listItemValue:E,listOrdered:g(fe,I),listUnordered:g(fe),paragraph:g(ke),reference:X,referenceString:y,resourceDestinationString:y,resourceTitleString:y,setextHeading:g(le),strong:g(me),thematicBreak:g(ye)},exit:{atxHeading:S(),atxHeadingSequence:B,autolink:S(),autolinkEmail:ne,autolinkProtocol:te,blockQuote:S(),characterEscapeValue:V,characterReferenceMarkerHexadecimal:Z,characterReferenceMarkerNumeric:Z,characterReferenceValue:ee,codeFenced:S(C),codeFencedFence:w,codeFencedFenceInfo:v,codeFencedFenceMeta:F,codeFlowValue:V,codeIndented:S(H),codeText:S(q),codeTextData:V,data:V,definition:S(),definitionDestinationString:z,definitionLabelString:R,definitionTitleString:j,emphasis:S(),hardBreakEscape:S(Q),hardBreakTrailing:S(Q),htmlFlow:S(U),htmlFlowData:V,htmlText:S(_),htmlTextData:V,image:S(N),label:$,labelText:W,lineEnding:M,link:S(A),listItem:S(),listOrdered:S(),listUnordered:S(),paragraph:S(),referenceString:Y,resourceDestinationString:G,resourceTitleString:J,resource:K,setextHeading:S(O),setextHeadingLineSequence:L,setextHeadingText:D,strong:S(),thematicBreak:S()}};d(n,(t||{}).mdastExtensions||[]);const i={};return h;function h(e){let t={type:"root",children:[]};const i={stack:[t],tokenStack:[],config:n,enter:x,exit:b,buffer:y,resume:T,setData:k,getData:m},r=[];let s=-1;for(;++s<e.length;)if("listOrdered"===e[s][1].type||"listUnordered"===e[s][1].type)if("enter"===e[s][0])r.push(s);else{s=f(e,r.pop(),s)}for(s=-1;++s<e.length;){const t=n[e[s][0]];o.call(t,e[s][1].type)&&t[e[s][1].type].call(Object.assign({sliceSerialize:e[s][2].sliceSerialize},i),e[s][1])}if(i.tokenStack.length>0){const e=i.tokenStack[i.tokenStack.length-1];(e[1]||p).call(i,void 0,e[0])}for(t.position={start:u(e.length>0?e[0][1].start:{line:1,column:1,offset:0}),end:u(e.length>0?e[e.length-2][1].end:{line:1,column:1,offset:0})},s=-1;++s<n.transforms.length;)t=n.transforms[s](t)||t;return t}function f(e,t,n){let i,r,s,c,a=t-1,l=-1,o=!1;for(;++a<=n;){const t=e[a];if("listUnordered"===t[1].type||"listOrdered"===t[1].type||"blockQuote"===t[1].type?("enter"===t[0]?l++:l--,c=void 0):"lineEndingBlank"===t[1].type?"enter"===t[0]&&(!i||c||l||s||(s=a),c=void 0):"linePrefix"===t[1].type||"listItemValue"===t[1].type||"listItemMarker"===t[1].type||"listItemPrefix"===t[1].type||"listItemPrefixWhitespace"===t[1].type||(c=void 0),!l&&"enter"===t[0]&&"listItemPrefix"===t[1].type||-1===l&&"exit"===t[0]&&("listUnordered"===t[1].type||"listOrdered"===t[1].type)){if(i){let c=a;for(r=void 0;c--;){const t=e[c];if("lineEnding"===t[1].type||"lineEndingBlank"===t[1].type){if("exit"===t[0])continue;r&&(e[r][1].type="lineEndingBlank",o=!0),t[1].type="lineEnding",r=c}else if("linePrefix"!==t[1].type&&"blockQuotePrefix"!==t[1].type&&"blockQuotePrefixWhitespace"!==t[1].type&&"blockQuoteMarker"!==t[1].type&&"listItemIndent"!==t[1].type)break}s&&(!r||s<r)&&(i._spread=!0),i.end=Object.assign({},r?e[r][1].start:t[1].end),e.splice(r||a,0,["exit",i,t[2]]),a++,n++}"listItemPrefix"===t[1].type&&(i={type:"listItem",_spread:!1,start:Object.assign({},t[1].start),end:void 0},e.splice(a,0,["enter",i,t[2]]),a++,n++,s=void 0,c=!0)}}return e[t][1]._spread=o,n}function k(e,t){i[e]=t}function m(e){return i[e]}function g(e,t){return n;function n(n){x.call(this,e(n),n),t&&t.call(this,n)}}function y(){this.stack.push({type:"fragment",children:[]})}function x(e,t,n){return this.stack[this.stack.length-1].children.push(e),this.stack.push(e),this.tokenStack.push([t,n]),e.position={start:u(t.start)},e}function S(e){return t;function t(t){e&&e.call(this,t),b.call(this,t)}}function b(e,t){const n=this.stack.pop(),i=this.tokenStack.pop();if(!i)throw new Error("Cannot close `"+e.type+"` ("+l({start:e.start,end:e.end})+"): it’s not open");if(i[0].type!==e.type)if(t)t.call(this,e,i[0]);else{(i[1]||p).call(this,e,i[0])}return n.position.end=u(e.end),n}function T(){return e(this.stack.pop())}function I(){k("expectingFirstListItemValue",!0)}function E(e){if(m("expectingFirstListItemValue")){this.stack[this.stack.length-2].start=Number.parseInt(this.sliceSerialize(e),10),k("expectingFirstListItemValue")}}function v(){const e=this.resume();this.stack[this.stack.length-1].lang=e}function F(){const e=this.resume();this.stack[this.stack.length-1].meta=e}function w(){m("flowCodeInside")||(this.buffer(),k("flowCodeInside",!0))}function C(){const e=this.resume();this.stack[this.stack.length-1].value=e.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g,""),k("flowCodeInside")}function H(){const e=this.resume();this.stack[this.stack.length-1].value=e.replace(/(\r?\n|\r)$/g,"")}function R(e){const t=this.resume(),n=this.stack[this.stack.length-1];n.label=t,n.identifier=c(this.sliceSerialize(e)).toLowerCase()}function j(){const e=this.resume();this.stack[this.stack.length-1].title=e}function z(){const e=this.resume();this.stack[this.stack.length-1].url=e}function B(e){const t=this.stack[this.stack.length-1];if(!t.depth){const n=this.sliceSerialize(e).length;t.depth=n}}function D(){k("setextHeadingSlurpLineEnding",!0)}function L(e){this.stack[this.stack.length-1].depth=61===this.sliceSerialize(e).charCodeAt(0)?1:2}function O(){k("setextHeadingSlurpLineEnding")}function P(e){const t=this.stack[this.stack.length-1];let n=t.children[t.children.length-1];n&&"text"===n.type||(n=ge(),n.position={start:u(e.start)},t.children.push(n)),this.stack.push(n)}function V(e){const t=this.stack.pop();t.value+=this.sliceSerialize(e),t.position.end=u(e.end)}function M(e){const t=this.stack[this.stack.length-1];if(m("atHardBreak")){return t.children[t.children.length-1].position.end=u(e.end),void k("atHardBreak")}!m("setextHeadingSlurpLineEnding")&&n.canContainEols.includes(t.type)&&(P.call(this,e),V.call(this,e))}function Q(){k("atHardBreak",!0)}function U(){const e=this.resume();this.stack[this.stack.length-1].value=e}function _(){const e=this.resume();this.stack[this.stack.length-1].value=e}function q(){const e=this.resume();this.stack[this.stack.length-1].value=e}function A(){const e=this.stack[this.stack.length-1];if(m("inReference")){const t=m("referenceType")||"shortcut";e.type+="Reference",e.referenceType=t,delete e.url,delete e.title}else delete e.identifier,delete e.label;k("referenceType")}function N(){const e=this.stack[this.stack.length-1];if(m("inReference")){const t=m("referenceType")||"shortcut";e.type+="Reference",e.referenceType=t,delete e.url,delete e.title}else delete e.identifier,delete e.label;k("referenceType")}function W(e){const t=this.sliceSerialize(e),n=this.stack[this.stack.length-2];n.label=s(t),n.identifier=c(t).toLowerCase()}function $(){const e=this.stack[this.stack.length-1],t=this.resume(),n=this.stack[this.stack.length-1];if(k("inReference",!0),"link"===n.type){const t=e.children;n.children=t}else n.alt=t}function G(){const e=this.resume();this.stack[this.stack.length-1].url=e}function J(){const e=this.resume();this.stack[this.stack.length-1].title=e}function K(){k("inReference")}function X(){k("referenceType","collapsed")}function Y(e){const t=this.resume(),n=this.stack[this.stack.length-1];n.label=t,n.identifier=c(this.sliceSerialize(e)).toLowerCase(),k("referenceType","full")}function Z(e){k("characterReferenceType",e.type)}function ee(e){const t=this.sliceSerialize(e),n=m("characterReferenceType");let i;if(n)i=r(t,"characterReferenceMarkerNumeric"===n?10:16),k("characterReferenceType");else{i=a(t)}const s=this.stack.pop();s.value+=i,s.position.end=u(e.end)}function te(e){V.call(this,e);this.stack[this.stack.length-1].url=this.sliceSerialize(e)}function ne(e){V.call(this,e);this.stack[this.stack.length-1].url="mailto:"+this.sliceSerialize(e)}function ie(){return{type:"blockquote",children:[]}}function re(){return{type:"code",lang:null,meta:null,value:""}}function se(){return{type:"inlineCode",value:""}}function ce(){return{type:"definition",identifier:"",label:null,title:null,url:""}}function ae(){return{type:"emphasis",children:[]}}function le(){return{type:"heading",depth:void 0,children:[]}}function oe(){return{type:"break"}}function he(){return{type:"html",value:""}}function ue(){return{type:"image",title:null,url:"",alt:null}}function de(){return{type:"link",title:null,url:"",children:[]}}function fe(e){return{type:"list",ordered:"listOrdered"===e.type,start:null,spread:e._spread,children:[]}}function pe(e){return{type:"listItem",spread:e._spread,checked:null,children:[]}}function ke(){return{type:"paragraph",children:[]}}function me(){return{type:"strong",children:[]}}function ge(){return{type:"text",value:""}}function ye(){return{type:"thematicBreak"}}}(k)(i(t(k).document().write(n()(h,f,!0))))};function u(e){return{line:e.line,column:e.column,offset:e.offset}}function d(e,t){let n=-1;for(;++n<t.length;){const i=t[n];Array.isArray(i)?d(e,i):f(e,i)}}function f(e,t){let n;for(n in t)if(o.call(t,n))if("canContainEols"===n){const i=t[n];i&&e[n].push(...i)}else if("transforms"===n){const i=t[n];i&&e[n].push(...i)}else if("enter"===n||"exit"===n){const i=t[n];i&&Object.assign(e[n],i)}}function p(e,t){throw e?new Error("Cannot close `"+e.type+"` ("+l({start:e.start,end:e.end})+"): a different token (`"+t.type+"`, "+l({start:t.start,end:t.end})+") is open"):new Error("Cannot close document, a token (`"+t.type+"`, "+l({start:t.start,end:t.end})+") is still open")}export{h as fromMarkdown};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/mdast-util-from-markdown/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/react-markdown/node_modules/mdast-util-from-markdown/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n *\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').StaticPhrasingContent} StaticPhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('mdast').ReferenceType} ReferenceType\n * @typedef {import('../index.js').CompileData} CompileData\n */\n\n/**\n * @typedef {Root | Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n *\n * @typedef {Omit<UnistParent, 'type' | 'children'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @callback Transform\n *   Extra transform, to change the AST afterwards.\n * @param {Root} tree\n *   Tree to transform.\n * @returns {Root | undefined | null | void}\n *   New tree or nothing (in which case the current tree is used).\n *\n * @callback Handle\n *   Handle a token.\n * @param {CompileContext} this\n *   Context.\n * @param {Token} token\n *   Current token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n *\n * @callback OnEnterError\n *   Handle the case where the `right` token is open, but it is closed (by the\n *   `left` token) or because we reached the end of the document.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token | undefined} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @callback OnExitError\n *   Handle the case where the `right` token is open but it is closed by\n *   exiting the `left` token.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {[Token, OnEnterError | undefined]} TokenTuple\n *   Open token on the stack, with an optional error handler for when\n *   that token isn’t closed properly.\n */\n\n/**\n * @typedef Config\n *   Configuration.\n *\n *   We have our defaults, but extensions will add more.\n * @property {Array<string>} canContainEols\n *   Token types where line endings are used.\n * @property {Handles} enter\n *   Opening handles.\n * @property {Handles} exit\n *   Closing handles.\n * @property {Array<Transform>} transforms\n *   Tree transforms.\n *\n * @typedef {Partial<Config>} Extension\n *   Change how markdown tokens from micromark are turned into mdast.\n *\n * @typedef CompileContext\n *   mdast compiler context.\n * @property {Array<Node | Fragment>} stack\n *   Stack of nodes.\n * @property {Array<TokenTuple>} tokenStack\n *   Stack of tokens.\n * @property {<Key extends keyof CompileData>(key: Key) => CompileData[Key]} getData\n *   Get data from the key/value store.\n * @property {<Key extends keyof CompileData>(key: Key, value?: CompileData[Key]) => void} setData\n *   Set data into the key/value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<Kind extends Node>(this: CompileContext, node: Kind, token: Token, onError?: OnEnterError) => Kind} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {Config} config\n *   Configuration.\n *\n * @typedef FromMarkdownOptions\n *   Configuration for how to build mdast.\n * @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]\n *   Extensions for this utility to change how tokens are turned into a tree.\n *\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n *   Configuration.\n */\n\n// To do: micromark: create a registry of tokens?\n// To do: next major: don’t return given `Node` from `enter`.\n// To do: next major: remove setter/getter.\n\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nimport {decodeString} from 'micromark-util-decode-string'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {stringifyPosition} from 'unist-util-stringify-position'\nconst own = {}.hasOwnProperty\n\n/**\n * @param value\n *   Markdown to parse.\n * @param encoding\n *   Character encoding for when `value` is `Buffer`.\n * @param options\n *   Configuration.\n * @returns\n *   mdast tree.\n */\nexport const fromMarkdown =\n  /**\n   * @type {(\n   *   ((value: Value, encoding: Encoding, options?: Options | null | undefined) => Root) &\n   *   ((value: Value, options?: Options | null | undefined) => Root)\n   * )}\n   */\n\n  /**\n   * @param {Value} value\n   * @param {Encoding | Options | null | undefined} [encoding]\n   * @param {Options | null | undefined} [options]\n   * @returns {Root}\n   */\n  function (value, encoding, options) {\n    if (typeof encoding !== 'string') {\n      options = encoding\n      encoding = undefined\n    }\n    return compiler(options)(\n      postprocess(\n        parse(options).document().write(preprocess()(value, encoding, true))\n      )\n    )\n  }\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  }\n  configure(config, (options || {}).mdastExtensions || [])\n\n  /** @type {CompileData} */\n  const data = {}\n  return compile\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    }\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      setData,\n      getData\n    }\n    /** @type {Array<number>} */\n    const listStack = []\n    let index = -1\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          const tail = listStack.pop()\n          index = prepareList(events, tail, index)\n        }\n      }\n    }\n    index = -1\n    while (++index < events.length) {\n      const handler = config[events[index][0]]\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          Object.assign(\n            {\n              sliceSerialize: events[index][2].sliceSerialize\n            },\n            context\n          ),\n          events[index][1]\n        )\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1]\n      const handler = tail[1] || defaultOnError\n      handler.call(context, undefined, tail[0])\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(\n        events.length > 0\n          ? events[0][1].start\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      ),\n      end: point(\n        events.length > 0\n          ? events[events.length - 2][1].end\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      )\n    }\n\n    // Call transforms.\n    index = -1\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n    return tree\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1\n    let containerBalance = -1\n    let listSpread = false\n    /** @type {Token | undefined} */\n    let listItem\n    /** @type {number | undefined} */\n    let lineIndex\n    /** @type {number | undefined} */\n    let firstBlankLineIndex\n    /** @type {boolean | undefined} */\n    let atMarker\n    while (++index <= length) {\n      const event = events[index]\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          let tailIndex = index\n          lineIndex = undefined\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex]\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            listItem._spread = true\n          }\n\n          // Fix position.\n          listItem.end = Object.assign(\n            {},\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        }\n\n        // Create a new list item.\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          }\n          // @ts-expect-error: `listItem` is most definitely defined, TS...\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    }\n    events[start][1]._spread = listSpread\n    return length\n  }\n\n  /**\n   * Set data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @param {CompileData[Key]} [value]\n   *   New value.\n   * @returns {void}\n   *   Nothing.\n   */\n  function setData(key, value) {\n    data[key] = value\n  }\n\n  /**\n   * Get data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @returns {CompileData[Key]}\n   *   Value.\n   */\n  function getData(key) {\n    return data[key]\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Node} create\n   *   Create a node.\n   * @param {Handle} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {void}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    })\n  }\n\n  /**\n   * @template {Node} Kind\n   *   Node type.\n   * @this {CompileContext}\n   *   Context.\n   * @param {Kind} node\n   *   Node to enter.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnEnterError | undefined} [errorHandler]\n   *   Handle the case where this token is open, but it is closed by something else.\n   * @returns {Kind}\n   *   The given node.\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]\n    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n    parent.children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push([token, errorHandler])\n    // @ts-expect-error: `end` will be patched later.\n    node.position = {\n      start: point(token.start)\n    }\n    return node\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnExitError | undefined} [onExitError]\n   *   Handle the case where another token is open.\n   * @returns {Node}\n   *   The closed node.\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop()\n    const open = this.tokenStack.pop()\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({\n            start: token.start,\n            end: token.end\n          }) +\n          '): it’s not open'\n      )\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0])\n      } else {\n        const handler = open[1] || defaultOnError\n        handler.call(this, token, open[0])\n      }\n    }\n    node.position.end = point(token.end)\n    return node\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n  function resume() {\n    return toString(this.stack.pop())\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor = this.stack[this.stack.length - 2]\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n      setData('expectingFirstListItemValue')\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.lang = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.meta = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n    setData('flowCodeInside')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.title = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.url = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1]\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length\n      node.depth = depth\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1]\n    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1]\n    let tail = node.children[node.children.length - 1]\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text()\n      // @ts-expect-error: we’ll add `end` later.\n      tail.position = {\n        start: point(token.start)\n      }\n      // @ts-expect-error: Assume `parent` accepts `text`.\n      node.children.push(tail)\n    }\n    this.stack.push(tail)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1]\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1]\n      tail.position.end = point(token.end)\n      setData('atHardBreak')\n      return\n    }\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.includes(context.type)\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1]\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('referenceType') || 'shortcut'\n      node.type += 'Reference'\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType\n      // @ts-expect-error: mutate.\n      delete node.url\n      delete node.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier\n      // @ts-expect-error: mutate.\n      delete node.label\n    }\n    setData('referenceType')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1]\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('referenceType') || 'shortcut'\n      node.type += 'Reference'\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType\n      // @ts-expect-error: mutate.\n      delete node.url\n      delete node.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier\n      // @ts-expect-error: mutate.\n      delete node.label\n    }\n    setData('referenceType')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token)\n    const ancestor = this.stack[this.stack.length - 2]\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string)\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1]\n    const value = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    // Assume a reference.\n    setData('inReference', true)\n    if (node.type === 'link') {\n      /** @type {Array<StaticPhrasingContent>} */\n      // @ts-expect-error: Assume static phrasing content.\n      const children = fragment.children\n      node.children = children\n    } else {\n      node.alt = value\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.url = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.title = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    setData('inReference')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token)\n    const type = getData('characterReferenceType')\n    /** @type {string} */\n    let value\n    if (type) {\n      value = decodeNumericCharacterReference(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n      setData('characterReferenceType')\n    } else {\n      const result = decodeNamedCharacterReference(data)\n      value = result\n    }\n    const tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    const node = this.stack[this.stack.length - 1]\n    node.url = this.sliceSerialize(token)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    const node = this.stack[this.stack.length - 1]\n    node.url = 'mailto:' + this.sliceSerialize(token)\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    }\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    }\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    }\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    }\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    }\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    }\n  }\n\n  /** @returns {HTML} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    }\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    }\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    }\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    }\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    }\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    }\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    }\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    }\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Extension | Array<Extension>>} extensions\n * @returns {void}\n */\nfunction configure(combined, extensions) {\n  let index = -1\n  while (++index < extensions.length) {\n    const value = extensions[index]\n    if (Array.isArray(value)) {\n      configure(combined, value)\n    } else {\n      extension(combined, value)\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {void}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      if (key === 'canContainEols') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'transforms') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'enter' || key === 'exit') {\n        const right = extension[key]\n        if (right) {\n          Object.assign(combined[key], right)\n        }\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error(\n      'Cannot close `' +\n        left.type +\n        '` (' +\n        stringifyPosition({\n          start: left.start,\n          end: left.end\n        }) +\n        '): a different token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is open'\n    )\n  } else {\n    throw new Error(\n      'Cannot close document, a token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is still open'\n    )\n  }\n}\n"],"names":["own","hasOwnProperty","fromMarkdown","value","encoding","options","undefined","config","transforms","canContainEols","enter","autolink","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","heading","blockQuote","characterEscape","characterReference","codeFenced","codeFlow","codeFencedFenceInfo","buffer","codeFencedFenceMeta","codeIndented","codeText","codeTextData","data","codeFlowValue","definition","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","html","htmlFlowData","htmlText","htmlTextData","image","label","listItem","listItemValue","onenterlistitemvalue","listOrdered","list","onenterlistordered","listUnordered","paragraph","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","thematicBreak","exit","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","lineEnding","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","compile","events","tree","type","children","context","stack","tokenStack","resume","setData","getData","listStack","index","length","push","prepareList","pop","handler","call","Object","assign","sliceSerialize","tail","defaultOnError","position","start","point","line","column","offset","end","lineIndex","firstBlankLineIndex","atMarker","containerBalance","listSpread","event","tailIndex","tailEvent","_spread","splice","key","create","and","open","token","this","node","errorHandler","close","onExitError","Error","stringifyPosition","toString","Number","parseInt","lang","meta","replace","identifier","normalizeIdentifier","toLowerCase","title","url","depth","charCodeAt","text","includes","referenceType","string","ancestor","decodeString","fragment","alt","decodeNumericCharacterReference","decodeNamedCharacterReference","ordered","spread","checked","compiler","postprocess","parse","document","write","preprocess","d","combined","extensions","Array","isArray","extension","right","left"],"mappings":"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"}

package/dist/node_modules/react-markdown/node_modules/mdast-util-to-string/lib/index.js

@@ -1,2 +0,0 @@
-const n={};function t(t,r){const l=r||n;return e(t,"boolean"!=typeof l.includeImageAlt||l.includeImageAlt,"boolean"!=typeof l.includeHtml||l.includeHtml)}function e(n,t,e){if(function(n){return Boolean(n&&"object"==typeof n)}(n)){if("value"in n)return"html"!==n.type||e?n.value:"";if(t&&"alt"in n&&n.alt)return n.alt;if("children"in n)return r(n.children,t,e)}return Array.isArray(n)?r(n,t,e):""}function r(n,t,r){const l=[];let o=-1;for(;++o<n.length;)l[o]=e(n[o],t,r);return l.join("")}export{t as toString};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/mdast-util-to-string/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/react-markdown/node_modules/mdast-util-to-string/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s.\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML.\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} value\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Node}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n"],"names":["emptyOptions","toString","value","options","settings","one","includeImageAlt","includeHtml","Boolean","node","type","alt","all","children","Array","isArray","values","result","index","length","join"],"mappings":"AAYA,MAAMA,EAAe,CAAE,EAehB,SAASC,EAASC,EAAOC,GAC9B,MAAMC,EAAWD,GAAWH,EAQ5B,OAAOK,EAAIH,EAN2B,kBAA7BE,EAASE,iBACZF,EAASE,gBAGmB,kBAAzBF,EAASG,aAA4BH,EAASG,YAGzD,CAcA,SAASF,EAAIH,EAAOI,EAAiBC,GACnC,GAqDF,SAAcL,GACZ,OAAOM,QAAQN,GAA0B,iBAAVA,EACjC,CAvDMO,CAAKP,GAAQ,CACf,GAAI,UAAWA,EACb,MAAsB,SAAfA,EAAMQ,MAAoBH,EAAmBL,EAAMA,MAAX,GAGjD,GAAII,GAAmB,QAASJ,GAASA,EAAMS,IAC7C,OAAOT,EAAMS,IAGf,GAAI,aAAcT,EAChB,OAAOU,EAAIV,EAAMW,SAAUP,EAAiBC,EAE/C,CAED,OAAIO,MAAMC,QAAQb,GACTU,EAAIV,EAAOI,EAAiBC,GAG9B,EACT,CAcA,SAASK,EAAII,EAAQV,EAAiBC,GAEpC,MAAMU,EAAS,GACf,IAAIC,GAAS,EAEb,OAASA,EAAQF,EAAOG,QACtBF,EAAOC,GAASb,EAAIW,EAAOE,GAAQZ,EAAiBC,GAGtD,OAAOU,EAAOG,KAAK,GACrB"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/constructs.js

@@ -1,2 +0,0 @@
-import{attention as m}from"../../micromark-core-commonmark/lib/attention.js";import{autolink as r}from"../../micromark-core-commonmark/lib/autolink.js";import{blockQuote as o}from"../../micromark-core-commonmark/lib/block-quote.js";import{characterEscape as i}from"../../micromark-core-commonmark/lib/character-escape.js";import{characterReference as c}from"../../micromark-core-commonmark/lib/character-reference.js";import{codeFenced as a}from"../../micromark-core-commonmark/lib/code-fenced.js";import{codeIndented as e}from"../../micromark-core-commonmark/lib/code-indented.js";import{codeText as t}from"../../micromark-core-commonmark/lib/code-text.js";import{definition as k}from"../../micromark-core-commonmark/lib/definition.js";import{hardBreakEscape as l}from"../../micromark-core-commonmark/lib/hard-break-escape.js";import{headingAtx as n}from"../../micromark-core-commonmark/lib/heading-atx.js";import{htmlFlow as s}from"../../micromark-core-commonmark/lib/html-flow.js";import{htmlText as b}from"../../micromark-core-commonmark/lib/html-text.js";import{labelEnd as f}from"../../micromark-core-commonmark/lib/label-end.js";import{labelStartImage as p}from"../../micromark-core-commonmark/lib/label-start-image.js";import{labelStartLink as j}from"../../micromark-core-commonmark/lib/label-start-link.js";import{lineEnding as d}from"../../micromark-core-commonmark/lib/line-ending.js";import{list as h}from"../../micromark-core-commonmark/lib/list.js";import{setextUnderline as u}from"../../micromark-core-commonmark/lib/setext-underline.js";import{thematicBreak as x}from"../../micromark-core-commonmark/lib/thematic-break.js";import{resolver as g}from"./initialize/text.js";const q={42:h,43:h,45:h,48:h,49:h,50:h,51:h,52:h,53:h,54:h,55:h,56:h,57:h,62:o},w={91:k},z={[-2]:e,[-1]:e,32:e},v={35:n,42:x,45:[u,x],60:s,61:u,95:x,96:a,126:a},y={38:c,92:i},A={[-5]:d,[-4]:d,[-3]:d,33:p,38:c,42:m,60:[r,b],91:j,92:[l,i],93:f,95:m,96:t},B={null:[m,g]},C={null:[42,95]},D={null:[]};export{C as attentionMarkers,w as contentInitial,D as disable,q as document,v as flow,z as flowInitial,B as insideSpan,y as string,A as text};
-//# sourceMappingURL=constructs.js.map

package/dist/node_modules/react-markdown/node_modules/micromark/lib/constructs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constructs.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark/lib/constructs.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\n\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n}\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n}\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n}\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n}\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n}\n"],"names":["document","list","blockQuote","contentInitial","definition","flowInitial","codeIndented","flow","headingAtx","thematicBreak","setextUnderline","htmlFlow","codeFenced","string","characterReference","characterEscape","text","lineEnding","labelStartImage","attention","autolink","htmlText","labelStartLink","hardBreakEscape","labelEnd","codeText","insideSpan","null","resolveText","attentionMarkers","disable"],"mappings":"upDA6BY,MAACA,EAAW,CACtB,GAAMC,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMA,EACN,GAAMC,GAIKC,EAAiB,CAC5B,GAAMC,GAIKC,EAAc,CACzB,EAAE,GAAIC,EACN,EAAE,GAAIA,EACN,GAAMA,GAIKC,EAAO,CAClB,GAAMC,EACN,GAAMC,EACN,GAAM,CAACC,EAAiBD,GACxB,GAAME,EACN,GAAMD,EACN,GAAMD,EACN,GAAMG,EACN,IAAOA,GAIIC,EAAS,CACpB,GAAMC,EACN,GAAMC,GAIKC,EAAO,CAClB,EAAE,GAAIC,EACN,EAAE,GAAIA,EACN,EAAE,GAAIA,EACN,GAAMC,EACN,GAAMJ,EACN,GAAMK,EACN,GAAM,CAACC,EAAUC,GACjB,GAAMC,EACN,GAAM,CAACC,EAAiBR,GACxB,GAAMS,EACN,GAAML,EACN,GAAMM,GAIKC,EAAa,CACxBC,KAAM,CAACR,EAAWS,IAIPC,EAAmB,CAC9BF,KAAM,CAAC,GAAI,KAIAG,EAAU,CACrBH,KAAM"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/create-tokenizer.js

@@ -1,2 +0,0 @@
-import{markdownLineEnding as e}from"../../micromark-util-character/index.js";import{push as n,splice as t}from"../../micromark-util-chunked/index.js";import{resolveAll as r}from"../../micromark-util-resolve-all/index.js";function i(i,o,u){let s=Object.assign(u?Object.assign({},u):{line:1,column:1,offset:0},{_index:0,_bufferIndex:-1});const c={},f=[];let l=[],a=[];const d={consume:function(n){e(n)?(s.line++,s.column=1,s.offset+=-3===n?2:1,I()):-1!==n&&(s.column++,s.offset++);s._bufferIndex<0?s._index++:(s._bufferIndex++,s._bufferIndex===l[s._index].length&&(s._bufferIndex=-1,s._index++));x.previous=n},enter:function(e,n){const t=n||{};return t.type=e,t.start=_(),x.events.push(["enter",t,x]),a.push(t),t},exit:function(e){const n=a.pop();return n.end=_(),x.events.push(["exit",n,x]),n},attempt:g((function(e,n){k(e,n.from)})),check:g(b),interrupt:g(b,{interrupt:!0})},x={previous:null,code:null,containerState:{},events:[],parser:i,sliceStream:p,sliceSerialize:function(e,n){return function(e,n){let t=-1;const r=[];let i;for(;++t<e.length;){const o=e[t];let u;if("string"==typeof o)u=o;else switch(o){case-5:u="\r";break;case-4:u="\n";break;case-3:u="\r\n";break;case-2:u=n?" ":"\t";break;case-1:if(!n&&i)continue;u=" ";break;default:u=String.fromCharCode(o)}i=-2===o,r.push(u)}return r.join("")}(p(e),n)},now:_,defineSkip:function(e){c[e.line]=e.column,I()},write:function(e){if(l=n(l,e),h(),null!==l[l.length-1])return[];return k(o,0),x.events=r(f,x.events,x),x.events}};let m=o.tokenize.call(x,d);return o.resolveAll&&f.push(o),x;function p(e){return function(e,n){const t=n.start._index,r=n.start._bufferIndex,i=n.end._index,o=n.end._bufferIndex;let u;if(t===i)u=[e[t].slice(r,o)];else{if(u=e.slice(t,i),r>-1){const e=u[0];"string"==typeof e?u[0]=e.slice(r):u.shift()}o>0&&u.push(e[i].slice(0,o))}return u}(l,e)}function _(){const{line:e,column:n,offset:t,_index:r,_bufferIndex:i}=s;return{line:e,column:n,offset:t,_index:r,_bufferIndex:i}}function h(){let e;for(;s._index<l.length;){const n=l[s._index];if("string"==typeof n)for(e=s._index,s._bufferIndex<0&&(s._bufferIndex=0);s._index===e&&s._bufferIndex<n.length;)v(n.charCodeAt(s._bufferIndex));else v(n)}}function v(e){m=m(e)}function b(e,n){n.restore()}function g(e,n){return function(t,r,i){let o,u,c,f;return Array.isArray(t)?l(t):"tokenize"in t?l([t]):function(e){return n;function n(n){const t=null!==n&&e[n],r=null!==n&&e.null;return l([...Array.isArray(t)?t:t?[t]:[],...Array.isArray(r)?r:r?[r]:[]])(n)}}(t);function l(e){return o=e,u=0,0===e.length?i:m(e[u])}function m(e){return function(t){f=function(){const e=_(),n=x.previous,t=x.currentConstruct,r=x.events.length,i=Array.from(a);return{restore:o,from:r};function o(){s=e,x.previous=n,x.currentConstruct=t,x.events.length=r,a=i,I()}}(),c=e,e.partial||(x.currentConstruct=e);if(e.name&&x.parser.constructs.disable.null.includes(e.name))return h();return e.tokenize.call(n?Object.assign(Object.create(x),n):x,d,p,h)(t)}}function p(n){return e(c,f),r}function h(e){return f.restore(),++u<o.length?m(o[u]):i}}}function k(e,n){e.resolveAll&&!f.includes(e)&&f.push(e),e.resolve&&t(x.events,n,x.events.length-n,e.resolve(x.events.slice(n),x)),e.resolveTo&&(x.events=e.resolveTo(x.events,x))}function I(){s.line in c&&s.column<2&&(s.column=c[s.line],s.offset+=c[s.line]-1)}}export{i as createTokenizer};
-//# sourceMappingURL=create-tokenizer.js.map

package/dist/node_modules/react-markdown/node_modules/micromark/lib/create-tokenizer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-tokenizer.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark/lib/create-tokenizer.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenType} TokenType\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * @callback Restore\n * @returns {void}\n *\n * @typedef Info\n * @property {Restore} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\n  )\n  /** @type {Record<string, number>} */\n  const columnStart = {}\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = []\n  /** @type {Array<Chunk>} */\n  let chunks = []\n  /** @type {Array<Token>} */\n  let stack = []\n  /** @type {boolean | undefined} */\n  let consumed = true\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  }\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n\n  /**\n   * The state function.\n   *\n   * @type {State | void}\n   */\n  let state = initialize.tokenize.call(context, effects)\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n  return context\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main()\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n    addResult(initialize, 0)\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {line, column, offset, _index, _bufferIndex} = point\n    return {\n      line,\n      column,\n      offset,\n      _index,\n      _bufferIndex\n    }\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {void}\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index]\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {void}\n   */\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++\n\n      // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code\n\n    // Mark as consumed.\n    consumed = true\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   */\n  function constructFactory(onreturn, fields) {\n    return hook\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | Construct | ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State | undefined} [bogusState]\n     * @returns {State}\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Array<Construct>} */\n      let listOfConstructs\n      /** @type {number} */\n      let constructIndex\n      /** @type {Construct} */\n      let currentConstruct\n      /** @type {Info} */\n      let info\n      return Array.isArray(constructs) /* c8 ignore next 1 */\n        ? handleListOfConstructs(constructs)\n        : 'tokenize' in constructs\n        ? // @ts-expect-error Looks like a construct.\n          handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n      function handleMapOfConstructs(map) {\n        return start\n\n        /** @type {State} */\n        function start(code) {\n          const def = code !== null && map[code]\n          const all = code !== null && map.null\n          const list = [\n            // To do: add more extension tests.\n            /* c8 ignore next 2 */\n            ...(Array.isArray(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Array<Construct>} list\n       * @returns {State}\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n        if (list.length === 0) {\n          return bogusState\n        }\n        return handleConstruct(list[constructIndex])\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n      function handleConstruct(construct) {\n        return start\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          // Always populated by defaults.\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\n          }\n          return construct.tokenize.call(\n            // If we do have fields, create an object w/ `context` as its\n            // prototype.\n            // This allows a “live binding”, which is needed for `interrupt`.\n            fields ? Object.assign(Object.create(context), fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true\n        info.restore()\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n        return bogusState\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {void}\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\n  function store() {\n    const startPoint = now()\n    const startPrevious = context.previous\n    const startCurrentConstruct = context.currentConstruct\n    const startEventsIndex = context.events.length\n    const startStack = Array.from(stack)\n    return {\n      restore,\n      from: startEventsIndex\n    }\n\n    /**\n     * Restore state.\n     *\n     * @returns {void}\n     */\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {void}\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Array<Chunk>} chunks\n * @param {Pick<Token, 'end' | 'start'>} token\n * @returns {Array<Chunk>}\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index\n  const startBufferIndex = token.start._bufferIndex\n  const endIndex = token.end._index\n  const endBufferIndex = token.end._bufferIndex\n  /** @type {Array<Chunk>} */\n  let view\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n    if (startBufferIndex > -1) {\n      const head = view[0]\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex)\n      } else {\n        view.shift()\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n  return view\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Array<Chunk>} chunks\n * @param {boolean | undefined} [expandTabs=false]\n * @returns {string}\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {boolean | undefined} */\n  let atTab\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n    let value\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n        case -4: {\n          value = '\\n'\n          break\n        }\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n    atTab = chunk === -2\n    result.push(value)\n  }\n  return result.join('')\n}\n"],"names":["createTokenizer","parser","initialize","from","point","Object","assign","line","column","offset","_index","_bufferIndex","columnStart","resolveAllConstructs","chunks","stack","effects","consume","code","markdownLineEnding","accountForPotentialSkip","length","context","previous","enter","type","fields","token","start","now","events","push","exit","pop","end","attempt","constructFactory","construct","info","addResult","check","onsuccessfulcheck","interrupt","containerState","sliceStream","sliceSerialize","expandTabs","index","result","atTab","chunk","value","String","fromCharCode","join","serializeChunks","defineSkip","write","slice","main","resolveAll","state","tokenize","call","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","shift","sliceChunks","chunkIndex","go","charCodeAt","_","restore","onreturn","constructs","returnState","bogusState","listOfConstructs","constructIndex","currentConstruct","Array","isArray","handleListOfConstructs","map","def","all","null","handleMapOfConstructs","list","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","partial","name","disable","includes","nok","create","ok","resolve","splice","resolveTo"],"mappings":"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"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/initialize/content.js

@@ -1,2 +0,0 @@
-import{factorySpace as n}from"../../../micromark-factory-space/index.js";import{markdownLineEnding as t}from"../../../micromark-util-character/index.js";const e={tokenize:function(e){const r=e.attempt(this.parser.constructs.contentInitial,(function(t){if(null===t)return void e.consume(t);return e.enter("lineEnding"),e.consume(t),e.exit("lineEnding"),n(e,r,"linePrefix")}),(function(n){return e.enter("paragraph"),o(n)}));let i;return r;function o(n){const t=e.enter("chunkText",{contentType:"text",previous:i});return i&&(i.next=t),i=t,c(n)}function c(n){return null===n?(e.exit("chunkText"),e.exit("paragraph"),void e.consume(n)):t(n)?(e.consume(n),e.exit("chunkText"),o):(e.consume(n),c)}}};export{e as content};
-//# sourceMappingURL=content.js.map

package/dist/node_modules/react-markdown/node_modules/micromark/lib/initialize/content.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"content.js","sources":["../../../../../../../node_modules/react-markdown/node_modules/micromark/lib/initialize/content.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  /** @type {Token} */\n  let previous\n  return contentStart\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n    if (previous) {\n      previous.next = token\n    }\n    previous = token\n    return data(code)\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    }\n\n    // Data.\n    effects.consume(code)\n    return data\n  }\n}\n"],"names":["content","tokenize","effects","contentStart","attempt","this","parser","constructs","contentInitial","code","consume","enter","exit","factorySpace","lineStart","previous","token","contentType","next","data","markdownLineEnding"],"mappings":"yJAWY,MAACA,EAAU,CACrBC,SAOF,SAA2BC,GACzB,MAAMC,EAAeD,EAAQE,QAC3BC,KAAKC,OAAOC,WAAWC,gBASzB,SAAoCC,GAClC,GAAa,OAATA,EAEF,YADAP,EAAQQ,QAAQD,GAMlB,OAHAP,EAAQS,MAAM,cACdT,EAAQQ,QAAQD,GAChBP,EAAQU,KAAK,cACNC,EAAaX,EAASC,EAAc,aAC5C,IAGD,SAA0BM,GAExB,OADAP,EAAQS,MAAM,aACPG,EAAUL,EAClB,IAnBD,IAAIM,EACJ,OAAOZ,EAqBP,SAASW,EAAUL,GACjB,MAAMO,EAAQd,EAAQS,MAAM,YAAa,CACvCM,YAAa,OACbF,aAMF,OAJIA,IACFA,EAASG,KAAOF,GAElBD,EAAWC,EACJG,EAAKV,EACb,CAGD,SAASU,EAAKV,GACZ,OAAa,OAATA,GACFP,EAAQU,KAAK,aACbV,EAAQU,KAAK,kBACbV,EAAQQ,QAAQD,IAGdW,EAAmBX,IACrBP,EAAQQ,QAAQD,GAChBP,EAAQU,KAAK,aACNE,IAITZ,EAAQQ,QAAQD,GACTU,EACR,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/initialize/document.js

@@ -1,2 +0,0 @@
-import{factorySpace as e}from"../../../micromark-factory-space/index.js";import{markdownLineEnding as t}from"../../../micromark-util-character/index.js";import{splice as n}from"../../../micromark-util-chunked/index.js";const r={tokenize:function(e){const r=this,i=[];let c,s,u,l=0;return a;function a(t){if(l<i.length){const n=i[l];return r.containerState=n[1],e.attempt(n[0].continuation,f,v)(t)}return v(t)}function f(e){if(l++,r.containerState._closeFlow){r.containerState._closeFlow=void 0,c&&S();const t=r.events.length;let o,i=t;for(;i--;)if("exit"===r.events[i][0]&&"chunkFlow"===r.events[i][1].type){o=r.events[i][1].end;break}x(l);let s=t;for(;s<r.events.length;)r.events[s][1].end=Object.assign({},o),s++;return n(r.events,i+1,0,r.events.slice(t)),r.events.length=s,v(e)}return a(e)}function v(t){if(l===i.length){if(!c)return p(t);if(c.currentConstruct&&c.currentConstruct.concrete)return k(t);r.interrupt=Boolean(c.currentConstruct&&!c._gfmTableDynamicInterruptHack)}return r.containerState={},e.check(o,d,h)(t)}function d(e){return c&&S(),x(l),p(e)}function h(e){return r.parser.lazy[r.now().line]=l!==i.length,u=r.now().offset,k(e)}function p(t){return r.containerState={},e.attempt(o,m,k)(t)}function m(e){return l++,i.push([r.currentConstruct,r.containerState]),p(e)}function k(t){return null===t?(c&&S(),x(0),void e.consume(t)):(c=c||r.parser.flow(r.now()),e.enter("chunkFlow",{contentType:"flow",previous:s,_tokenizer:c}),g(t))}function g(n){return null===n?(w(e.exit("chunkFlow"),!0),x(0),void e.consume(n)):t(n)?(e.consume(n),w(e.exit("chunkFlow")),l=0,r.interrupt=void 0,a):(e.consume(n),g)}function w(e,t){const o=r.sliceStream(e);if(t&&o.push(null),e.previous=s,s&&(s.next=e),s=e,c.defineSkip(e.start),c.write(o),r.parser.lazy[e.start.line]){let e=c.events.length;for(;e--;)if(c.events[e][1].start.offset<u&&(!c.events[e][1].end||c.events[e][1].end.offset>u))return;const t=r.events.length;let o,i,s=t;for(;s--;)if("exit"===r.events[s][0]&&"chunkFlow"===r.events[s][1].type){if(o){i=r.events[s][1].end;break}o=!0}for(x(l),e=t;e<r.events.length;)r.events[e][1].end=Object.assign({},i),e++;n(r.events,s+1,0,r.events.slice(t)),r.events.length=e}}function x(t){let n=i.length;for(;n-- >t;){const t=i[n];r.containerState=t[1],t[0].exit.call(r,e)}i.length=t}function S(){c.write([null]),s=void 0,c=void 0,r.containerState._closeFlow=void 0}}},o={tokenize:function(t,n,r){return e(t,t.attempt(this.parser.constructs.document,n,r),"linePrefix",this.parser.constructs.disable.null.includes("codeIndented")?void 0:4)}};export{r as document};
-//# sourceMappingURL=document.js.map

package/dist/node_modules/react-markdown/node_modules/micromark/lib/initialize/document.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"document.js","sources":["../../../../../../../node_modules/react-markdown/node_modules/micromark/lib/initialize/document.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n}\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {Array<StackItem>} */\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext | undefined} */\n  let childFlow\n  /** @type {Token | undefined} */\n  let childToken\n  /** @type {number} */\n  let lineStartOffset\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued]\n      self.containerState = item[1]\n      return effects.attempt(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(code)\n    }\n\n    // Done.\n    return checkNewContainers(code)\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n      if (childFlow) {\n        closeFlow()\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          point = self.events[indexBeforeFlow][1].end\n          break\n        }\n      }\n      exitContainers(continued)\n\n      // Fix positions.\n      let index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n    return start(code)\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code)\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    }\n\n    // Check if there is a new container.\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length\n    lineStartOffset = self.now().offset\n    return flowStart(code)\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState])\n    // Try another.\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit('chunkFlow'), true)\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow'))\n      // Get ready for the next line.\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n    effects.consume(code)\n    return flowContinue\n  }\n\n  /**\n   * @param {Token} token\n   * @param {boolean | undefined} [eof]\n   * @returns {void}\n   */\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) stream.push(null)\n    token.previous = childToken\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.defineSkip(token.start)\n    childFlow.write(stream)\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset &&\n          // …and either is not ended yet…\n          (!childFlow.events[index][1].end ||\n            // …or ends after it.\n            childFlow.events[index][1].end.offset > lineStartOffset)\n        ) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean | undefined} */\n      let seen\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end\n            break\n          }\n          seen = true\n        }\n      }\n      exitContainers(continued)\n\n      // Fix positions.\n      index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n    }\n  }\n\n  /**\n   * @param {number} size\n   * @returns {void}\n   */\n  function exitContainers(size) {\n    let index = stack.length\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n    stack.length = size\n  }\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n"],"names":["document","tokenize","effects","self","this","stack","childFlow","childToken","lineStartOffset","continued","start","code","length","item","containerState","attempt","continuation","documentContinue","checkNewContainers","_closeFlow","undefined","closeFlow","indexBeforeExits","events","point","indexBeforeFlow","type","end","exitContainers","index","Object","assign","splice","slice","documentContinued","currentConstruct","concrete","flowStart","interrupt","Boolean","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","parser","lazy","now","line","offset","containerContinue","push","consume","flow","enter","contentType","previous","_tokenizer","flowContinue","writeToChild","exit","markdownLineEnding","token","eof","stream","sliceStream","next","defineSkip","write","seen","size","entry","call","ok","nok","factorySpace","constructs","disable","null","includes"],"mappings":"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"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/initialize/flow.js

@@ -1,2 +0,0 @@
-import{blankLine as r}from"../../../micromark-core-commonmark/lib/blank-line.js";import{factorySpace as n}from"../../../micromark-factory-space/index.js";import"../../../../../decode-named-character-reference/index.dom.js";import{content as t}from"../../../micromark-core-commonmark/lib/content.js";import"../../../micromark-core-commonmark/lib/label-start-image.js";import"../../../micromark-core-commonmark/lib/label-start-link.js";const e={tokenize:function(e){const o=this,i=e.attempt(r,(function(r){if(null===r)return void e.consume(r);return e.enter("lineEndingBlank"),e.consume(r),e.exit("lineEndingBlank"),o.currentConstruct=void 0,i}),e.attempt(this.parser.constructs.flowInitial,m,n(e,e.attempt(this.parser.constructs.flow,m,e.attempt(t,m)),"linePrefix")));return i;function m(r){if(null!==r)return e.enter("lineEnding"),e.consume(r),e.exit("lineEnding"),o.currentConstruct=void 0,i;e.consume(r)}}};export{e as flow};
-//# sourceMappingURL=flow.js.map

package/dist/node_modules/react-markdown/node_modules/micromark/lib/initialize/flow.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flow.js","sources":["../../../../../../../node_modules/react-markdown/node_modules/micromark/lib/initialize/flow.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding,\n    // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n"],"names":["flow","tokenize","effects","self","this","initial","attempt","blankLine","code","consume","enter","exit","currentConstruct","undefined","parser","constructs","flowInitial","afterConstruct","factorySpace","content"],"mappings":"kbAWY,MAACA,EAAO,CAClBC,SAOF,SAAwBC,GACtB,MAAMC,EAAOC,KACPC,EAAUH,EAAQI,QAEtBC,GAoBF,SAAuBC,GACrB,GAAa,OAATA,EAEF,YADAN,EAAQO,QAAQD,GAOlB,OAJAN,EAAQQ,MAAM,mBACdR,EAAQO,QAAQD,GAChBN,EAAQS,KAAK,mBACbR,EAAKS,sBAAmBC,EACjBR,CACR,GA3BCH,EAAQI,QACNF,KAAKU,OAAOC,WAAWC,YACvBC,EACAC,EACEhB,EACAA,EAAQI,QACNF,KAAKU,OAAOC,WAAWf,KACvBiB,EACAf,EAAQI,QAAQa,EAASF,IAE3B,gBAIN,OAAOZ,EAgBP,SAASY,EAAeT,GACtB,GAAa,OAATA,EAQJ,OAJAN,EAAQQ,MAAM,cACdR,EAAQO,QAAQD,GAChBN,EAAQS,KAAK,cACbR,EAAKS,sBAAmBC,EACjBR,EAPLH,EAAQO,QAAQD,EAQnB,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/initialize/text.js

@@ -1,2 +0,0 @@
-const e={resolveAll:i()},t=r("string"),n=r("text");function r(e){return{tokenize:function(t){const n=this,r=this.parser.constructs[e],i=t.attempt(r,o,s);return o;function o(e){return l(e)?i(e):s(e)}function s(e){if(null!==e)return t.enter("data"),t.consume(e),f;t.consume(e)}function f(e){return l(e)?(t.exit("data"),i(e)):(t.consume(e),f)}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}},resolveAll:i("text"===e?o:void 0)}}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,s=i.length,f=-1,l=0;for(;s--;){const e=i[s];if("string"==typeof e){for(f=e.length;32===e.charCodeAt(f-1);)l++,f--;if(f)break;f=-1}else if(-2===e)o=!0,l++;else if(-1!==e){s++;break}}if(l){const i={type:n===e.length||o||l<2?"lineSuffix":"hardBreakTrailing",start:{line:r.end.line,column:r.end.column-l,offset:r.end.offset-l,_index:r.start._index+s,_bufferIndex:s?f:r.start._bufferIndex+f},end:Object.assign({},r.end)};r.end=Object.assign({},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/react-markdown/node_modules/micromark/lib/initialize/text.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.js","sources":["../../../../../../../node_modules/react-markdown/node_modules/micromark/lib/initialize/text.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\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 * @returns {InitialConstruct}\n */\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  /**\n   * @this {TokenizeContext}\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     * @returns {boolean}\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 * @returns {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 (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\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      if (size) {\n        const token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n      eventIndex++\n    }\n  }\n  return events\n}\n"],"names":["resolver","resolveAll","createResolver","string","initializeFactory","text","field","tokenize","effects","self","this","constructs","parser","attempt","start","notText","code","atBreak","enter","consume","data","exit","list","index","length","item","previous","call","resolveAllLineSuffixes","undefined","extraResolver","events","context","type","end","splice","eventIndex","chunks","sliceStream","tabs","bufferIndex","size","chunk","charCodeAt","token","line","column","offset","_index","_bufferIndex","Object","assign"],"mappings":"AASY,MAACA,EAAW,CACtBC,WAAYC,KAEDC,EAASC,EAAkB,UAC3BC,EAAOD,EAAkB,QAMtC,SAASA,EAAkBE,GACzB,MAAO,CACLC,SAUF,SAAwBC,GACtB,MAAMC,EAAOC,KACPC,EAAaD,KAAKE,OAAOD,WAAWL,GACpCD,EAAOG,EAAQK,QAAQF,EAAYG,EAAOC,GAChD,OAAOD,EAGP,SAASA,EAAME,GACb,OAAOC,EAAQD,GAAQX,EAAKW,GAAQD,EAAQC,EAC7C,CAGD,SAASD,EAAQC,GACf,GAAa,OAATA,EAMJ,OAFAR,EAAQU,MAAM,QACdV,EAAQW,QAAQH,GACTI,EALLZ,EAAQW,QAAQH,EAMnB,CAGD,SAASI,EAAKJ,GACZ,OAAIC,EAAQD,IACVR,EAAQa,KAAK,QACNhB,EAAKW,KAIdR,EAAQW,QAAQH,GACTI,EACR,CAMD,SAASH,EAAQD,GACf,GAAa,OAATA,EACF,OAAO,EAET,MAAMM,EAAOX,EAAWK,GACxB,IAAIO,GAAS,EACb,GAAID,EAGF,OAASC,EAAQD,EAAKE,QAAQ,CAC5B,MAAMC,EAAOH,EAAKC,GAClB,IAAKE,EAAKC,UAAYD,EAAKC,SAASC,KAAKlB,EAAMA,EAAKiB,UAClD,OAAO,CAEV,CAEH,OAAO,CACR,CACF,EAjECzB,WAAYC,EACA,SAAVI,EAAmBsB,OAAyBC,GAiElD,CAMA,SAAS3B,EAAe4B,GACtB,OAGA,SAAwBC,EAAQC,GAC9B,IAEId,EAFAK,GAAS,EAMb,OAASA,GAASQ,EAAOP,aACTK,IAAVX,EACEa,EAAOR,IAAoC,SAA1BQ,EAAOR,GAAO,GAAGU,OACpCf,EAAQK,EACRA,KAEQQ,EAAOR,IAAoC,SAA1BQ,EAAOR,GAAO,GAAGU,OAExCV,IAAUL,EAAQ,IACpBa,EAAOb,GAAO,GAAGgB,IAAMH,EAAOR,EAAQ,GAAG,GAAGW,IAC5CH,EAAOI,OAAOjB,EAAQ,EAAGK,EAAQL,EAAQ,GACzCK,EAAQL,EAAQ,GAElBA,OAAQW,GAGZ,OAAOC,EAAgBA,EAAcC,EAAQC,GAAWD,CACzD,CACH,CAaA,SAASH,EAAuBG,EAAQC,GACtC,IAAII,EAAa,EAEjB,OAASA,GAAcL,EAAOP,QAC5B,IACGY,IAAeL,EAAOP,QACU,eAA/BO,EAAOK,GAAY,GAAGH,OACW,SAAnCF,EAAOK,EAAa,GAAG,GAAGH,KAC1B,CACA,MAAMb,EAAOW,EAAOK,EAAa,GAAG,GAC9BC,EAASL,EAAQM,YAAYlB,GACnC,IAIImB,EAJAhB,EAAQc,EAAOb,OACfgB,GAAe,EACfC,EAAO,EAGX,KAAOlB,KAAS,CACd,MAAMmB,EAAQL,EAAOd,GACrB,GAAqB,iBAAVmB,EAAoB,CAE7B,IADAF,EAAcE,EAAMlB,OACyB,KAAtCkB,EAAMC,WAAWH,EAAc,IACpCC,IACAD,IAEF,GAAIA,EAAa,MACjBA,GAAe,CAChB,MAEI,IAAe,IAAXE,EACPH,GAAO,EACPE,SACK,IAAe,IAAXC,EAEJ,CAELnB,IACA,KACD,CACF,CACD,GAAIkB,EAAM,CACR,MAAMG,EAAQ,CACZX,KACEG,IAAeL,EAAOP,QAAUe,GAAQE,EAAO,EAC3C,aACA,oBACN3B,MAAO,CACL+B,KAAMzB,EAAKc,IAAIW,KACfC,OAAQ1B,EAAKc,IAAIY,OAASL,EAC1BM,OAAQ3B,EAAKc,IAAIa,OAASN,EAC1BO,OAAQ5B,EAAKN,MAAMkC,OAASzB,EAC5B0B,aAAc1B,EACViB,EACApB,EAAKN,MAAMmC,aAAeT,GAEhCN,IAAKgB,OAAOC,OAAO,CAAA,EAAI/B,EAAKc,MAE9Bd,EAAKc,IAAMgB,OAAOC,OAAO,CAAE,EAAEP,EAAM9B,OAC/BM,EAAKN,MAAMiC,SAAW3B,EAAKc,IAAIa,OACjCG,OAAOC,OAAO/B,EAAMwB,IAEpBb,EAAOI,OACLC,EACA,EACA,CAAC,QAASQ,EAAOZ,GACjB,CAAC,OAAQY,EAAOZ,IAElBI,GAAc,EAEjB,CACDA,GACD,CAEH,OAAOL,CACT"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/parse.js

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

package/dist/node_modules/react-markdown/node_modules/micromark/lib/parse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark/lib/parse.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Create} Create\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\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 {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n * @returns {ParseContext}\n */\nexport function parse(options) {\n  const settings = options || {}\n  const constructs =\n    /** @type {FullNormalizedExtension} */\n    combineExtensions([defaultConstructs, ...(settings.extensions || [])])\n\n  /** @type {ParseContext} */\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n\n  /**\n   * @param {InitialConstruct} initial\n   */\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n"],"names":["parse","options","parser","defined","lazy","constructs","combineExtensions","defaultConstructs","extensions","content","create","document","flow","string","text","initial","from","createTokenizer"],"mappings":"yXAoBO,SAASA,EAAMC,GACpB,MAMMC,EAAS,CACbC,QAAS,GACTC,KAAM,CAAE,EACZC,WANIC,EAAkB,CAACC,MAHJN,GAAW,CAAE,GAGuBO,YAAc,KAOjEC,QAASC,EAAOD,GAChBE,SAAUD,EAAOC,GACjBC,KAAMF,EAAOE,GACbC,OAAQH,EAAOG,GACfC,KAAMJ,EAAOI,IAEf,OAAOZ,EAKP,SAASQ,EAAOK,GACd,OAEA,SAAiBC,GACf,OAAOC,EAAgBf,EAAQa,EAASC,EACzC,CACF,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark/lib/postprocess.js

@@ -1,2 +0,0 @@
-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/react-markdown/node_modules/micromark/lib/postprocess.js.map

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

package/dist/node_modules/react-markdown/node_modules/micromark/lib/preprocess.js

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

package/dist/node_modules/react-markdown/node_modules/micromark/lib/preprocess.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"preprocess.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark/lib/preprocess.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {boolean | null | undefined} [end=false]\n * @returns {Array<Chunk>}\n */\n\nconst search = /[\\0\\t\\n\\r]/g\n\n/**\n * @returns {Preprocessor}\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  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\n    // @ts-expect-error `Buffer` does allow an encoding.\n    value = buffer + value.toString(encoding)\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 =\n        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            chunks.push(65533)\n            column++\n            break\n          }\n          case 9: {\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            chunks.push(-4)\n            column = 1\n            break\n          }\n          default: {\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}\n"],"names":["search","preprocess","atCarriageReturn","column","buffer","start","value","encoding","end","chunks","match","next","startPosition","endPosition","code","toString","charCodeAt","undefined","length","lastIndex","exec","index","slice","push","Math","ceil"],"mappings":"AAeA,MAAMA,EAAS,cAKR,SAASC,IACd,IAKIC,EALAC,EAAS,EACTC,EAAS,GAETC,GAAQ,EAGZ,OAGA,SAAsBC,EAAOC,EAAUC,GAErC,MAAMC,EAAS,GAEf,IAAIC,EAEAC,EAEAC,EAEAC,EAEAC,EAGJR,EAAQF,EAASE,EAAMS,SAASR,GAChCK,EAAgB,EAChBR,EAAS,GACLC,IAE0B,QAAxBC,EAAMU,WAAW,IACnBJ,IAEFP,OAAQY,GAEV,KAAOL,EAAgBN,EAAMY,QAAQ,CAMnC,GALAlB,EAAOmB,UAAYP,EACnBF,EAAQV,EAAOoB,KAAKd,GACpBO,EACEH,QAAyBO,IAAhBP,EAAMW,MAAsBX,EAAMW,MAAQf,EAAMY,OAC3DJ,EAAOR,EAAMU,WAAWH,IACnBH,EAAO,CACVN,EAASE,EAAMgB,MAAMV,GACrB,KACD,CACD,GAAa,KAATE,GAAeF,IAAkBC,GAAeX,EAClDO,EAAOc,MAAM,GACbrB,OAAmBe,OAUnB,OARIf,IACFO,EAAOc,MAAM,GACbrB,OAAmBe,GAEjBL,EAAgBC,IAClBJ,EAAOc,KAAKjB,EAAMgB,MAAMV,EAAeC,IACvCV,GAAUU,EAAcD,GAElBE,GACN,KAAK,EACHL,EAAOc,KAAK,OACZpB,IACA,MAEF,KAAK,EAGH,IAFAQ,EAA+B,EAAxBa,KAAKC,KAAKtB,EAAS,GAC1BM,EAAOc,MAAM,GACNpB,IAAWQ,GAAMF,EAAOc,MAAM,GACrC,MAEF,KAAK,GACHd,EAAOc,MAAM,GACbpB,EAAS,EACT,MAEF,QACED,GAAmB,EACnBC,EAAS,EAIfS,EAAgBC,EAAc,CAC/B,CACGL,IACEN,GAAkBO,EAAOc,MAAM,GAC/BnB,GAAQK,EAAOc,KAAKnB,GACxBK,EAAOc,KAAK,OAEd,OAAOd,CACR,CACH"}

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

@@ -1,2 +0,0 @@
-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",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(c){if(c===i)return e.consume(c),a;const f=e.exit("attentionSequence"),u=n(c),l=!u||2===u&&o||s.includes(c),d=!o||2===o&&u||s.includes(r);return f._open=Boolean(42===i?l:l&&(o||!d)),f._close=Boolean(42===i?d:d&&(u||!l)),t(c)}},resolveAll:function(n,r){let i,a,c,f,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 g=Object.assign({},n[i][1].end),x=Object.assign({},n[m][1].start);o(g,-l),o(x,l),f={type:l>1?"strongSequence":"emphasisSequence",start:g,end:Object.assign({},n[i][1].end)},u={type:l>1?"strongSequence":"emphasisSequence",start:Object.assign({},n[m][1].start),end:x},c={type:l>1?"strongText":"emphasisText",start:Object.assign({},n[i][1].end),end:Object.assign({},n[m][1].start)},a={type:l>1?"strong":"emphasis",start:Object.assign({},f.start),end:Object.assign({},u.end)},n[i][1].end=Object.assign({},f.start),n[m][1].start=Object.assign({},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",f,r],["exit",f,r],["enter",c,r]]),d=e(d,s(r.parser.constructs.insideSpan.null,n.slice(i+1,m),r)),d=e(d,[["exit",c,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}};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/react-markdown/node_modules/micromark-core-commonmark/lib/attention.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attention.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-core-commonmark/lib/attention.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\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  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\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 (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\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 (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open &&\n          // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\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 (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          }\n\n          // Number of markers to use from the sequence.\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\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, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ])\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          )\n\n          // Closing.\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ])\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, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\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 * @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 =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !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 * @param {number} offset\n * @returns {void}\n */\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n"],"names":["attention","name","tokenize","effects","ok","attentionMarkers","this","parser","constructs","null","previous","before","classifyCharacter","marker","code","enter","inside","consume","token","exit","after","open","includes","close","_open","Boolean","_close","resolveAll","events","context","group","text","openingSequence","closingSequence","use","nextEvents","offset","index","length","type","sliceSerialize","charCodeAt","end","start","Object","assign","movePoint","push","insideSpan","slice","splice","point","column","_bufferIndex"],"mappings":"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"}

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

@@ -1,2 +0,0 @@
-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):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/react-markdown/node_modules/micromark-core-commonmark/lib/autolink.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"autolink.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-core-commonmark/lib/autolink.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n\n/**\n * @this {TokenizeContext}\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    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 (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\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}\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":"8HAcY,MAACA,EAAW,CACtBC,KAAM,WACNC,SAOF,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,GAEFC,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,IAKG,KAATV,GAAwB,KAATA,GAAwB,KAATA,GAAeQ,EAAkBR,KAChED,IAAS,IAETH,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/react-markdown/node_modules/micromark-core-commonmark/lib/blank-line.js

@@ -1,2 +0,0 @@
-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={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)}},partial:!0};export{i as blankLine};
-//# sourceMappingURL=blank-line.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-core-commonmark/lib/blank-line.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\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)\n      ? factorySpace(effects, after, 'linePrefix')(code)\n      : 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}\n"],"names":["blankLine","tokenize","effects","ok","nok","code","markdownSpace","factorySpace","after","markdownLineEnding","partial"],"mappings":"sKAUY,MAACA,EAAY,CACvBC,SAQF,SAA2BC,EAASC,EAAIC,GACtC,OAgBA,SAAeC,GACb,OAAOC,EAAcD,GACjBE,EAAaL,EAASM,EAAO,aAA7BD,CAA2CF,GAC3CG,EAAMH,EACX,EAgBD,SAASG,EAAMH,GACb,OAAgB,OAATA,GAAiBI,EAAmBJ,GAAQF,EAAGE,GAAQD,EAAIC,EACnE,CACH,EA/CEK,SAAS"}

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

@@ -1,2 +0,0 @@
-import{factorySpace as e}from"../../micromark-factory-space/index.js";import{markdownSpace as t}from"../../micromark-util-character/index.js";const n={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))}},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")}};export{n as blockQuote};
-//# sourceMappingURL=block-quote.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"block-quote.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-core-commonmark/lib/block-quote.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n\n/**\n * @this {TokenizeContext}\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 * @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(\n        effects,\n        contBefore,\n        'linePrefix',\n        self.parser.constructs.disable.null.includes('codeIndented')\n          ? undefined\n          : 4\n      )(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}\n"],"names":["blockQuote","name","tokenize","effects","ok","nok","self","this","code","state","containerState","open","enter","_container","consume","exit","after","markdownSpace","continuation","factorySpace","contBefore","parser","constructs","disable","null","includes","undefined","attempt"],"mappings":"8IAWY,MAACA,EAAa,CACxBC,KAAM,aACNC,SAWF,SAAiCC,EAASC,EAAIC,GAC5C,MAAMC,EAAOC,KACb,OAYA,SAAeC,GACb,GAAa,KAATA,EAAa,CACf,MAAMC,EAAQH,EAAKI,eAWnB,OAVKD,EAAME,OACTR,EAAQS,MAAM,aAAc,CAC1BC,YAAY,IAEdJ,EAAME,MAAO,GAEfR,EAAQS,MAAM,oBACdT,EAAQS,MAAM,oBACdT,EAAQW,QAAQN,GAChBL,EAAQY,KAAK,oBACNC,CACR,CACD,OAAOX,EAAIG,EACZ,EAYD,SAASQ,EAAMR,GACb,OAAIS,EAAcT,IAChBL,EAAQS,MAAM,8BACdT,EAAQW,QAAQN,GAChBL,EAAQY,KAAK,8BACbZ,EAAQY,KAAK,oBACNX,IAETD,EAAQY,KAAK,oBACNX,EAAGI,GACX,CACH,EA/DEU,aAAc,CACZhB,SA4EJ,SAAwCC,EAASC,EAAIC,GACnD,MAAMC,EAAOC,KACb,OAeA,SAAmBC,GACjB,GAAIS,EAAcT,GAGhB,OAAOW,EACLhB,EACAiB,EACA,aACAd,EAAKe,OAAOC,WAAWC,QAAQC,KAAKC,SAAS,qBACzCC,EACA,EANCP,CAOLX,GAEJ,OAAOY,EAAWZ,EACnB,EAeD,SAASY,EAAWZ,GAClB,OAAOL,EAAQwB,QAAQ3B,EAAYI,EAAIC,EAAhCF,CAAqCK,EAC7C,CACH,GA3HEO,KA8HF,SAAcZ,GACZA,EAAQY,KAAK,aACf"}

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

@@ -1,2 +0,0 @@
-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/react-markdown/node_modules/micromark-core-commonmark/lib/character-escape.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"character-escape.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-core-commonmark/lib/character-escape.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\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 * @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}\n"],"names":["characterEscape","name","tokenize","effects","ok","nok","code","enter","consume","exit","inside","asciiPunctuation"],"mappings":"2EASY,MAACA,EAAkB,CAC7BC,KAAM,kBACNC,SAOF,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/react-markdown/node_modules/micromark-core-commonmark/lib/character-reference.js

@@ -1,2 +0,0 @@
-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