@e-llm-studio/instant-learning 0.0.115 → 0.0.116

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,2 +0,0 @@
-import{labelEnd as e}from"./label-end.js";const n={name:"labelStartLink",tokenize:function(e,n,t){const r=this;return function(n){return e.enter("labelLink"),e.enter("labelMarker"),e.consume(n),e.exit("labelMarker"),e.exit("labelLink"),l};function l(e){return 94===e&&"_hiddenFootnoteSupport"in r.parser.constructs?t(e):n(e)}},resolveAll:e.resolveAll};export{n as labelStartLink};
-//# sourceMappingURL=label-start-link.js.map

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

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

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

@@ -1,2 +0,0 @@
-import{factorySpace as n}from"../../micromark-factory-space/index.js";const e={name:"lineEnding",tokenize:function(e,i){return function(r){return e.enter("lineEnding"),e.consume(r),e.exit("lineEnding"),n(e,i,"linePrefix")}}};export{e as lineEnding};
-//# sourceMappingURL=line-ending.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"line-ending.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-core-commonmark/lib/line-ending.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} from 'micromark-util-character'\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n"],"names":["lineEnding","name","tokenize","effects","ok","code","enter","consume","exit","factorySpace"],"mappings":"sEAUY,MAACA,EAAa,CACxBC,KAAM,aACNC,SAOF,SAA4BC,EAASC,GACnC,OAGA,SAAeC,GAIb,OAHAF,EAAQG,MAAM,cACdH,EAAQI,QAAQF,GAChBF,EAAQK,KAAK,cACNC,EAAaN,EAASC,EAAI,aAClC,CACH"}

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"setext-underline.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-core-commonmark/lib/setext-underline.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\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 * @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 setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length\n  /** @type {number | undefined} */\n  let content\n  /** @type {number | undefined} */\n  let text\n  /** @type {number | undefined} */\n  let definition\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = 'setextHeadingText'\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context])\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length\n    /** @type {boolean | undefined} */\n    let paragraph\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (\n        self.events[index][1].type !== 'lineEnding' &&\n        self.events[index][1].type !== 'linePrefix' &&\n        self.events[index][1].type !== 'content'\n      ) {\n        paragraph = self.events[index][1].type === 'paragraph'\n        break\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      marker = code\n      return before(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('setextHeadingLineSequence')\n    return inside(code)\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return inside\n    }\n    effects.exit('setextHeadingLineSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, after, 'lineSuffix')(code)\n      : after(code)\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n"],"names":["setextUnderline","name","tokenize","effects","ok","nok","self","this","marker","code","paragraph","index","events","length","type","parser","lazy","now","line","interrupt","enter","inside","before","consume","exit","markdownSpace","factorySpace","after","markdownLineEnding","resolveTo","context","content","text","definition","splice","heading","start","Object","assign","end","push"],"mappings":"sKAYY,MAACA,EAAkB,CAC7BC,KAAM,kBACNC,SAkEF,SAAiCC,EAASC,EAAIC,GAC5C,MAAMC,EAAOC,KAEb,IAAIC,EACJ,OAaA,SAAeC,GACb,IAEIC,EAFAC,EAAQL,EAAKM,OAAOC,OAIxB,KAAOF,KAGL,GACiC,eAA/BL,EAAKM,OAAOD,GAAO,GAAGG,MACS,eAA/BR,EAAKM,OAAOD,GAAO,GAAGG,MACS,YAA/BR,EAAKM,OAAOD,GAAO,GAAGG,KACtB,CACAJ,EAA2C,cAA/BJ,EAAKM,OAAOD,GAAO,GAAGG,KAClC,KACD,CAKH,IAAKR,EAAKS,OAAOC,KAAKV,EAAKW,MAAMC,QAAUZ,EAAKa,WAAaT,GAG3D,OAFAP,EAAQiB,MAAM,qBACdZ,EAASC,EAiBb,SAAgBA,GAEd,OADAN,EAAQiB,MAAM,6BACPC,EAAOZ,EACf,CAnBUa,CAAOb,GAEhB,OAAOJ,EAAII,EACZ,EA6BD,SAASY,EAAOZ,GACd,OAAIA,IAASD,GACXL,EAAQoB,QAAQd,GACTY,IAETlB,EAAQqB,KAAK,6BACNC,EAAchB,GACjBiB,EAAavB,EAASwB,EAAO,aAA7BD,CAA2CjB,GAC3CkB,EAAMlB,GACX,CAaD,SAASkB,EAAMlB,GACb,OAAa,OAATA,GAAiBmB,EAAmBnB,IACtCN,EAAQqB,KAAK,qBACNpB,EAAGK,IAELJ,EAAII,EACZ,CACH,EAtKEoB,UAIF,SAAkCjB,EAAQkB,GAExC,IAEIC,EAEAC,EAEAC,EANAtB,EAAQC,EAAOC,OAUnB,KAAOF,KACL,GAAyB,UAArBC,EAAOD,GAAO,GAAgB,CAChC,GAA8B,YAA1BC,EAAOD,GAAO,GAAGG,KAAoB,CACvCiB,EAAUpB,EACV,KACD,CAC6B,cAA1BC,EAAOD,GAAO,GAAGG,OACnBkB,EAAOrB,EAEV,KAG+B,YAA1BC,EAAOD,GAAO,GAAGG,MAEnBF,EAAOsB,OAAOvB,EAAO,GAElBsB,GAAwC,eAA1BrB,EAAOD,GAAO,GAAGG,OAClCmB,EAAatB,GAInB,MAAMwB,EAAU,CACdrB,KAAM,gBACNsB,MAAOC,OAAOC,OAAO,CAAE,EAAE1B,EAAOoB,GAAM,GAAGI,OACzCG,IAAKF,OAAOC,OAAO,CAAA,EAAI1B,EAAOA,EAAOC,OAAS,GAAG,GAAG0B,MAItD3B,EAAOoB,GAAM,GAAGlB,KAAO,oBAInBmB,GACFrB,EAAOsB,OAAOF,EAAM,EAAG,CAAC,QAASG,EAASL,IAC1ClB,EAAOsB,OAAOD,EAAa,EAAG,EAAG,CAAC,OAAQrB,EAAOmB,GAAS,GAAID,IAC9DlB,EAAOmB,GAAS,GAAGQ,IAAMF,OAAOC,OAAO,CAAA,EAAI1B,EAAOqB,GAAY,GAAGM,MAEjE3B,EAAOmB,GAAS,GAAKI,EAKvB,OADAvB,EAAO4B,KAAK,CAAC,OAAQL,EAASL,IACvBlB,CACT"}

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

@@ -1,2 +0,0 @@
-import{factorySpace as e}from"../../micromark-factory-space/index.js";import{markdownSpace as t,markdownLineEnding as r}from"../../micromark-util-character/index.js";const n={name:"thematicBreak",tokenize:function(n,c,i){let a,o=0;return function(e){return n.enter("thematicBreak"),function(e){return a=e,m(e)}(e)};function m(e){return e===a?(n.enter("thematicBreakSequence"),u(e)):o>=3&&(null===e||r(e))?(n.exit("thematicBreak"),c(e)):i(e)}function u(r){return r===a?(n.consume(r),o++,u):(n.exit("thematicBreakSequence"),t(r)?e(n,m,"whitespace")(r):m(r))}}};export{n as thematicBreak};
-//# sourceMappingURL=thematic-break.js.map

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

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

package/dist/node_modules/react-markdown/node_modules/micromark-factory-destination/index.js

@@ -1,2 +0,0 @@
-import{asciiControl as n,markdownLineEnding as e,markdownLineEndingOrSpace as t}from"../micromark-util-character/index.js";function r(r,u,i,c,o,m,s,x,f){const l=f||Number.POSITIVE_INFINITY;let g=0;return function(e){if(60===e)return r.enter(c),r.enter(o),r.enter(m),r.consume(e),r.exit(m),h;if(null===e||32===e||41===e||n(e))return i(e);return r.enter(c),r.enter(s),r.enter(x),r.enter("chunkString",{contentType:"string"}),S(e)};function h(n){return 62===n?(r.enter(m),r.consume(n),r.exit(m),r.exit(o),r.exit(c),u):(r.enter(x),r.enter("chunkString",{contentType:"string"}),k(n))}function k(n){return 62===n?(r.exit("chunkString"),r.exit(x),h(n)):null===n||60===n||e(n)?i(n):(r.consume(n),92===n?I:k)}function I(n){return 60===n||62===n||92===n?(r.consume(n),k):k(n)}function S(e){return g||null!==e&&41!==e&&!t(e)?g<l&&40===e?(r.consume(e),g++,S):41===e?(r.consume(e),g--,S):null===e||32===e||40===e||n(e)?i(e):(r.consume(e),92===e?p:S):(r.exit("chunkString"),r.exit(x),r.exit(s),r.exit(c),u(e))}function p(n){return 40===n||41===n||92===n?(r.consume(n),S):S(n)}}export{r as factoryDestination};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-factory-destination/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-factory-destination/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return enclosedBefore\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return raw(code)\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return enclosed(code)\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return enclosedBefore(code)\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? enclosedEscape : enclosed\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return enclosed\n    }\n    return enclosed(code)\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (\n      !balance &&\n      (code === null || code === 41 || markdownLineEndingOrSpace(code))\n    ) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code)\n      balance++\n      return raw\n    }\n    if (code === 41) {\n      effects.consume(code)\n      balance--\n      return raw\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? rawEscape : raw\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return raw\n    }\n    return raw(code)\n  }\n}\n"],"names":["factoryDestination","effects","ok","nok","type","literalType","literalMarkerType","rawType","stringType","max","limit","Number","POSITIVE_INFINITY","balance","code","enter","consume","exit","enclosedBefore","asciiControl","contentType","raw","enclosed","markdownLineEnding","enclosedEscape","markdownLineEndingOrSpace","rawEscape"],"mappings":"2HAgDO,SAASA,EACdC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,GAEA,MAAMC,EAAQD,GAAOE,OAAOC,kBAC5B,IAAIC,EAAU,EACd,OAcA,SAAeC,GACb,GAAa,KAATA,EAMF,OALAb,EAAQc,MAAMX,GACdH,EAAQc,MAAMV,GACdJ,EAAQc,MAAMT,GACdL,EAAQe,QAAQF,GAChBb,EAAQgB,KAAKX,GACNY,EAIT,GAAa,OAATJ,GAA0B,KAATA,GAAwB,KAATA,GAAeK,EAAaL,GAC9D,OAAOX,EAAIW,GAQb,OANAb,EAAQc,MAAMX,GACdH,EAAQc,MAAMR,GACdN,EAAQc,MAAMP,GACdP,EAAQc,MAAM,cAAe,CAC3BK,YAAa,WAERC,EAAIP,EACZ,EAYD,SAASI,EAAeJ,GACtB,OAAa,KAATA,GACFb,EAAQc,MAAMT,GACdL,EAAQe,QAAQF,GAChBb,EAAQgB,KAAKX,GACbL,EAAQgB,KAAKZ,GACbJ,EAAQgB,KAAKb,GACNF,IAETD,EAAQc,MAAMP,GACdP,EAAQc,MAAM,cAAe,CAC3BK,YAAa,WAERE,EAASR,GACjB,CAYD,SAASQ,EAASR,GAChB,OAAa,KAATA,GACFb,EAAQgB,KAAK,eACbhB,EAAQgB,KAAKT,GACNU,EAAeJ,IAEX,OAATA,GAA0B,KAATA,GAAeS,EAAmBT,GAC9CX,EAAIW,IAEbb,EAAQe,QAAQF,GACA,KAATA,EAAcU,EAAiBF,EACvC,CAYD,SAASE,EAAeV,GACtB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCb,EAAQe,QAAQF,GACTQ,GAEFA,EAASR,EACjB,CAYD,SAASO,EAAIP,GACX,OACGD,GACS,OAATC,GAA0B,KAATA,IAAeW,EAA0BX,GAQzDD,EAAUH,GAAkB,KAATI,GACrBb,EAAQe,QAAQF,GAChBD,IACOQ,GAEI,KAATP,GACFb,EAAQe,QAAQF,GAChBD,IACOQ,GAMI,OAATP,GAA0B,KAATA,GAAwB,KAATA,GAAeK,EAAaL,GACvDX,EAAIW,IAEbb,EAAQe,QAAQF,GACA,KAATA,EAAcY,EAAYL,IAxB/BpB,EAAQgB,KAAK,eACbhB,EAAQgB,KAAKT,GACbP,EAAQgB,KAAKV,GACbN,EAAQgB,KAAKb,GACNF,EAAGY,GAqBb,CAYD,SAASY,EAAUZ,GACjB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCb,EAAQe,QAAQF,GACTO,GAEFA,EAAIP,EACZ,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark-factory-label/index.js

@@ -1,2 +0,0 @@
-import{markdownLineEnding as n,markdownSpace as e}from"../micromark-util-character/index.js";function t(t,r,i,u,o,c){const s=this;let m,l=0;return function(n){return t.enter(u),t.enter(o),t.consume(n),t.exit(o),t.enter(c),x};function x(e){return l>999||null===e||91===e||93===e&&!m||94===e&&!l&&"_hiddenFootnoteSupport"in s.parser.constructs?i(e):93===e?(t.exit(c),t.enter(o),t.consume(e),t.exit(o),t.exit(u),r):n(e)?(t.enter("lineEnding"),t.consume(e),t.exit("lineEnding"),x):(t.enter("chunkString",{contentType:"string"}),f(e))}function f(r){return null===r||91===r||93===r||n(r)||l++>999?(t.exit("chunkString"),x(r)):(t.consume(r),m||(m=!e(r)),92===r?p:f)}function p(n){return 91===n||92===n||93===n?(t.consume(n),l++,f):f(n)}}export{t as factoryLabel};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-factory-label/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-factory-label/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (\n      size > 999 ||\n      code === null ||\n      code === 91 ||\n      (code === 93 && !seen) ||\n      // To do: remove in the future once we’ve switched from\n      // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n      // which doesn’t need this.\n      // Hidden footnotes hook.\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return labelInside(code)\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    if (!seen) seen = !markdownSpace(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return labelInside\n    }\n    return labelInside(code)\n  }\n}\n"],"names":["factoryLabel","effects","ok","nok","type","markerType","stringType","self","this","seen","size","code","enter","consume","exit","atBreak","parser","constructs","markdownLineEnding","contentType","labelInside","markdownSpace","labelEscape"],"mappings":"6FAuCO,SAASA,EAAaC,EAASC,EAAIC,EAAKC,EAAMC,EAAYC,GAC/D,MAAMC,EAAOC,KACb,IAEIC,EAFAC,EAAO,EAGX,OAYA,SAAeC,GAMb,OALAV,EAAQW,MAAMR,GACdH,EAAQW,MAAMP,GACdJ,EAAQY,QAAQF,GAChBV,EAAQa,KAAKT,GACbJ,EAAQW,MAAMN,GACPS,CACR,EAYD,SAASA,EAAQJ,GACf,OACED,EAAO,KACE,OAATC,GACS,KAATA,GACU,KAATA,IAAgBF,GAMP,KAATE,IACED,GACD,2BAA4BH,EAAKS,OAAOC,WAEnCd,EAAIQ,GAEA,KAATA,GACFV,EAAQa,KAAKR,GACbL,EAAQW,MAAMP,GACdJ,EAAQY,QAAQF,GAChBV,EAAQa,KAAKT,GACbJ,EAAQa,KAAKV,GACNF,GAILgB,EAAmBP,IACrBV,EAAQW,MAAM,cACdX,EAAQY,QAAQF,GAChBV,EAAQa,KAAK,cACNC,IAETd,EAAQW,MAAM,cAAe,CAC3BO,YAAa,WAERC,EAAYT,GACpB,CAYD,SAASS,EAAYT,GACnB,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACAO,EAAmBP,IACnBD,IAAS,KAETT,EAAQa,KAAK,eACNC,EAAQJ,KAEjBV,EAAQY,QAAQF,GACXF,IAAMA,GAAQY,EAAcV,IACjB,KAATA,EAAcW,EAAcF,EACpC,CAYD,SAASE,EAAYX,GACnB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCV,EAAQY,QAAQF,GAChBD,IACOU,GAEFA,EAAYT,EACpB,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark-factory-space/index.js

@@ -1,2 +0,0 @@
-import{markdownSpace as r}from"../micromark-util-character/index.js";function t(t,n,e,u){const i=u?u-1:Number.POSITIVE_INFINITY;let o=0;return function(u){if(r(u))return t.enter(e),c(u);return n(u)};function c(u){return r(u)&&o++<i?(t.consume(u),c):(t.exit(e),n(u))}}export{t as factorySpace};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-factory-space/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-factory-space/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n    return ok(code)\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n    effects.exit(type)\n    return ok(code)\n  }\n}\n"],"names":["factorySpace","effects","ok","type","max","limit","Number","POSITIVE_INFINITY","size","code","markdownSpace","enter","prefix","consume","exit"],"mappings":"qEA0CO,SAASA,EAAaC,EAASC,EAAIC,EAAMC,GAC9C,MAAMC,EAAQD,EAAMA,EAAM,EAAIE,OAAOC,kBACrC,IAAIC,EAAO,EACX,OAGA,SAAeC,GACb,GAAIC,EAAcD,GAEhB,OADAR,EAAQU,MAAMR,GACPS,EAAOH,GAEhB,OAAOP,EAAGO,EACX,EAGD,SAASG,EAAOH,GACd,OAAIC,EAAcD,IAASD,IAASH,GAClCJ,EAAQY,QAAQJ,GACTG,IAETX,EAAQa,KAAKX,GACND,EAAGO,GACX,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark-factory-title/index.js

@@ -1,2 +0,0 @@
-import{factorySpace as n}from"../micromark-factory-space/index.js";import{markdownLineEnding as e}from"../micromark-util-character/index.js";function t(t,r,i,u,c,o){let m;return function(n){if(34===n||39===n||40===n)return t.enter(u),t.enter(c),t.consume(n),t.exit(c),m=40===n?41:n,f;return i(n)};function f(n){return n===m?(t.enter(c),t.consume(n),t.exit(c),t.exit(u),r):(t.enter(o),x(n))}function x(r){return r===m?(t.exit(o),f(m)):null===r?i(r):e(r)?(t.enter("lineEnding"),t.consume(r),t.exit("lineEnding"),n(t,x,"linePrefix")):(t.enter("chunkString",{contentType:"string"}),l(r))}function l(n){return n===m||null===n||e(n)?(t.exit("chunkString"),x(n)):(t.consume(n),92===n?s:l)}function s(n){return n===m||92===n?(t.consume(n),l):l(n)}}export{t as factoryTitle};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-factory-title/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-factory-title/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      marker = code === 40 ? 41 : code\n      return begin\n    }\n    return nok(code)\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    return atBreak(code)\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return begin(marker)\n    }\n    if (code === null) {\n      return nok(code)\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atBreak, 'linePrefix')\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return inside(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? escape : inside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return inside\n    }\n    return inside(code)\n  }\n}\n"],"names":["factoryTitle","effects","ok","nok","type","markerType","stringType","marker","code","enter","consume","exit","begin","atBreak","markdownLineEnding","factorySpace","contentType","inside","escape"],"mappings":"6IAwCO,SAASA,EAAaC,EAASC,EAAIC,EAAKC,EAAMC,EAAYC,GAE/D,IAAIC,EACJ,OAYA,SAAeC,GACb,GAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EAMhC,OALAP,EAAQQ,MAAML,GACdH,EAAQQ,MAAMJ,GACdJ,EAAQS,QAAQF,GAChBP,EAAQU,KAAKN,GACbE,EAAkB,KAATC,EAAc,GAAKA,EACrBI,EAET,OAAOT,EAAIK,EACZ,EAcD,SAASI,EAAMJ,GACb,OAAIA,IAASD,GACXN,EAAQQ,MAAMJ,GACdJ,EAAQS,QAAQF,GAChBP,EAAQU,KAAKN,GACbJ,EAAQU,KAAKP,GACNF,IAETD,EAAQQ,MAAMH,GACPO,EAAQL,GAChB,CAYD,SAASK,EAAQL,GACf,OAAIA,IAASD,GACXN,EAAQU,KAAKL,GACNM,EAAML,IAEF,OAATC,EACKL,EAAIK,GAITM,EAAmBN,IAErBP,EAAQQ,MAAM,cACdR,EAAQS,QAAQF,GAChBP,EAAQU,KAAK,cACNI,EAAad,EAASY,EAAS,gBAExCZ,EAAQQ,MAAM,cAAe,CAC3BO,YAAa,WAERC,EAAOT,GACf,CAOD,SAASS,EAAOT,GACd,OAAIA,IAASD,GAAmB,OAATC,GAAiBM,EAAmBN,IACzDP,EAAQU,KAAK,eACNE,EAAQL,KAEjBP,EAAQS,QAAQF,GACA,KAATA,EAAcU,EAASD,EAC/B,CAYD,SAASC,EAAOV,GACd,OAAIA,IAASD,GAAmB,KAATC,GACrBP,EAAQS,QAAQF,GACTS,GAEFA,EAAOT,EACf,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark-factory-whitespace/index.js

@@ -1,2 +0,0 @@
-import{factorySpace as r}from"../micromark-factory-space/index.js";import{markdownLineEnding as i,markdownSpace as n}from"../micromark-util-character/index.js";function e(e,t){let o;return function f(c){if(i(c))return e.enter("lineEnding"),e.consume(c),e.exit("lineEnding"),o=!0,f;if(n(c))return r(e,f,o?"linePrefix":"lineSuffix")(c);return t(c)}}export{e as factoryWhitespace};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-factory-whitespace/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-factory-whitespace/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n    return ok(code)\n  }\n}\n"],"names":["factoryWhitespace","effects","ok","seen","start","code","markdownLineEnding","enter","consume","exit","markdownSpace","factorySpace"],"mappings":"gKAyBO,SAASA,EAAkBC,EAASC,GAEzC,IAAIC,EACJ,OAGA,SAASC,EAAMC,GACb,GAAIC,EAAmBD,GAKrB,OAJAJ,EAAQM,MAAM,cACdN,EAAQO,QAAQH,GAChBJ,EAAQQ,KAAK,cACbN,GAAO,EACAC,EAET,GAAIM,EAAcL,GAChB,OAAOM,EACLV,EACAG,EACAD,EAAO,aAAe,aAHjBQ,CAILN,GAEJ,OAAOH,EAAGG,EACX,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-character/index.js

@@ -1,2 +0,0 @@
-import{unicodePunctuationRegex as n}from"./lib/unicode-punctuation-regex.js";const t=A(/[A-Za-z]/),r=A(/[\dA-Za-z]/),u=A(/[#-'*+\--9=?A-Z^-~]/);function o(n){return null!==n&&(n<32||127===n)}const e=A(/\d/),c=A(/[\dA-Fa-f]/),i=A(/[!-/:-@[-`{-~]/);function f(n){return null!==n&&n<-2}function l(n){return null!==n&&(n<0||32===n)}function s(n){return-2===n||-1===n||32===n}const a=A(n),d=A(/\s/);function A(n){return function(t){return null!==t&&n.test(String.fromCharCode(t))}}export{t as asciiAlpha,r as asciiAlphanumeric,u as asciiAtext,o as asciiControl,e as asciiDigit,c as asciiHexDigit,i as asciiPunctuation,f as markdownLineEnding,l as markdownLineEndingOrSpace,s as markdownSpace,a as unicodePunctuation,d as unicodeWhitespace};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-character/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-character/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/)\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n"],"names":["asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","code","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodePunctuationRegex","unicodeWhitespace","regex","test","String","fromCharCode"],"mappings":"6EAuBY,MAACA,EAAaC,EAAW,YAcxBC,EAAoBD,EAAW,cAuB/BE,EAAaF,EAAW,uBAa9B,SAASG,EAAaC,GAC3B,OAGW,OAATA,IAAkBA,EAAO,IAAe,MAATA,EAEnC,CAaY,MAACC,EAAaL,EAAW,MAoBxBM,EAAgBN,EAAW,cAe3BO,EAAmBP,EAAW,kBAiBpC,SAASQ,EAAmBJ,GACjC,OAAgB,OAATA,GAAiBA,GAAQ,CAClC,CAWO,SAASK,EAA0BL,GACxC,OAAgB,OAATA,IAAkBA,EAAO,GAAc,KAATA,EACvC,CAiBO,SAASM,EAAcN,GAC5B,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,CACvC,CAuBY,MAACO,EAAqBX,EAAWY,GAsBhCC,EAAoBb,EAAW,MAQ5C,SAASA,EAAWc,GAClB,OAUA,SAAeV,GACb,OAAgB,OAATA,GAAiBU,EAAMC,KAAKC,OAAOC,aAAab,GACxD,CACH"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js

@@ -1,2 +0,0 @@
-const u=/[!-\/:-@\[-`\{-~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/;export{u as unicodePunctuationRegex};
-//# sourceMappingURL=unicode-punctuation-regex.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unicode-punctuation-regex.js","sources":["../../../../../../node_modules/react-markdown/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js"],"sourcesContent":["// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n"],"names":["unicodePunctuationRegex"],"mappings":"AAUY,MAACA,EACX"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-chunked/index.js

@@ -1,2 +0,0 @@
-function e(e,n,t,l){const i=e.length;let s,c=0;if(n=n<0?-n>i?0:i+n:n>i?i:n,t=t>0?t:0,l.length<1e4)s=Array.from(l),s.unshift(n,t),e.splice(...s);else for(t&&e.splice(n,t);c<l.length;)s=l.slice(c,c+1e4),s.unshift(n,0),e.splice(...s),c+=1e4,n+=1e4}function n(n,t){return n.length>0?(e(n,n.length,0,t),n):t}export{n as push,e as splice};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-chunked/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-chunked/index.js"],"sourcesContent":["/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {void}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {Array<unknown>} */\n  let parameters\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n  remove = remove > 0 ? remove : 0\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove)\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n  return items\n}\n"],"names":["splice","list","start","remove","items","end","length","parameters","chunkStart","Array","from","unshift","slice","push"],"mappings":"AAsBO,SAASA,EAAOC,EAAMC,EAAOC,EAAQC,GAC1C,MAAMC,EAAMJ,EAAKK,OACjB,IAEIC,EAFAC,EAAa,EAajB,GAPEN,EADEA,EAAQ,GACDA,EAAQG,EAAM,EAAIA,EAAMH,EAEzBA,EAAQG,EAAMA,EAAMH,EAE9BC,EAASA,EAAS,EAAIA,EAAS,EAG3BC,EAAME,OAAS,IACjBC,EAAaE,MAAMC,KAAKN,GACxBG,EAAWI,QAAQT,EAAOC,GAE1BF,EAAKD,UAAUO,QAMf,IAHIJ,GAAQF,EAAKD,OAAOE,EAAOC,GAGxBK,EAAaJ,EAAME,QACxBC,EAAaH,EAAMQ,MAAMJ,EAAYA,EAAa,KAClDD,EAAWI,QAAQT,EAAO,GAE1BD,EAAKD,UAAUO,GACfC,GAAc,IACdN,GAAS,GAGf,CAkBO,SAASW,EAAKZ,EAAMG,GACzB,OAAIH,EAAKK,OAAS,GAChBN,EAAOC,EAAMA,EAAKK,OAAQ,EAAGF,GACtBH,GAEFG,CACT"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-classify-character/index.js

@@ -1,2 +0,0 @@
-import{markdownLineEndingOrSpace as r,unicodeWhitespace as i,unicodePunctuation as o}from"../micromark-util-character/index.js";function t(t){return null===t||r(t)||i(t)?1:o(t)?2:void 0}export{t as classifyCharacter};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-classify-character/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-classify-character/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n"],"names":["classifyCharacter","code","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation"],"mappings":"gIAuBO,SAASA,EAAkBC,GAChC,OACW,OAATA,GACAC,EAA0BD,IAC1BE,EAAkBF,GAEX,EAELG,EAAmBH,GACd,OADT,CAGF"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-combine-extensions/index.js

@@ -1,2 +0,0 @@
-import{splice as t}from"../micromark-util-chunked/index.js";const n={}.hasOwnProperty;function o(t){const n={};let o=-1;for(;++o<t.length;)r(n,t[o]);return n}function r(t,o){let r;for(r in o){const e=(n.call(t,r)?t[r]:void 0)||(t[r]={}),i=o[r];let l;if(i)for(l in i){n.call(e,l)||(e[l]=[]);const t=i[l];c(e[l],Array.isArray(t)?t:t?[t]:[])}}}function c(n,o){let r=-1;const c=[];for(;++r<o.length;)("after"===o[r].add?n:c).push(o[r]);t(n,0,0,c)}export{o as combineExtensions};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-combine-extensions/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-combine-extensions/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Handles} Handles\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {Array<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n * @param {Array<unknown>} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {Array<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   A single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {void}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n"],"names":["hasOwnProperty","combineExtensions","extensions","all","index","length","syntaxExtension","extension","hook","left","call","undefined","right","code","value","constructs","Array","isArray","existing","list","before","add","push","splice"],"mappings":"4DASA,MAAMA,EAAiB,CAAE,EAACA,eAUnB,SAASC,EAAkBC,GAEhC,MAAMC,EAAM,CAAE,EACd,IAAIC,GAAS,EAEb,OAASA,EAAQF,EAAWG,QAC1BC,EAAgBH,EAAKD,EAAWE,IAGlC,OAAOD,CACT,CAWA,SAASG,EAAgBH,EAAKI,GAE5B,IAAIC,EAEJ,IAAKA,KAAQD,EAAW,CACtB,MAEME,GAFQT,EAAeU,KAAKP,EAAKK,GAAQL,EAAIK,QAAQG,KAEpCR,EAAIK,GAAQ,CAAA,GAE7BI,EAAQL,EAAUC,GAExB,IAAIK,EAEJ,GAAID,EACF,IAAKC,KAAQD,EAAO,CACbZ,EAAeU,KAAKD,EAAMI,KAAOJ,EAAKI,GAAQ,IACnD,MAAMC,EAAQF,EAAMC,GACpBE,EAEEN,EAAKI,GACLG,MAAMC,QAAQH,GAASA,EAAQA,EAAQ,CAACA,GAAS,GAEpD,CAEJ,CACH,CAUA,SAASC,EAAWG,EAAUC,GAC5B,IAAIf,GAAS,EAEb,MAAMgB,EAAS,GAEf,OAAShB,EAAQe,EAAKd,SAEE,UAApBc,EAAKf,GAAOiB,IAAkBH,EAAWE,GAAQE,KAAKH,EAAKf,IAG/DmB,EAAOL,EAAU,EAAG,EAAGE,EACzB"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-decode-numeric-character-reference/index.js

@@ -1,2 +0,0 @@
-function r(r,n){const t=Number.parseInt(r,n);return t<9||11===t||t>13&&t<32||t>126&&t<160||t>55295&&t<57344||t>64975&&t<65008||!(65535&~t)||65534==(65535&t)||t>1114111?"�":String.fromCharCode(t)}export{r as decodeNumericCharacterReference};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-decode-numeric-character-reference/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-decode-numeric-character-reference/index.js"],"sourcesContent":["/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCharCode(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base)\n  if (\n    // C0 except for HT, LF, FF, CR, space.\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) ||\n    // Control character (DEL) of C0, and C1 controls.\n    (code > 126 && code < 160) ||\n    // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) ||\n    // Noncharacters.\n    (code > 64975 && code < 65008) /* eslint-disable no-bitwise */ ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 /* eslint-enable no-bitwise */ ||\n    // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n  return String.fromCharCode(code)\n}\n"],"names":["decodeNumericCharacterReference","value","base","code","Number","parseInt","String","fromCharCode"],"mappings":"AAcO,SAASA,EAAgCC,EAAOC,GACrD,MAAMC,EAAOC,OAAOC,SAASJ,EAAOC,GACpC,OAEEC,EAAO,GACE,KAATA,GACCA,EAAO,IAAMA,EAAO,IAEpBA,EAAO,KAAOA,EAAO,KAErBA,EAAO,OAASA,EAAO,OAEvBA,EAAO,OAASA,EAAO,SACL,OAAlBA,IACkB,QAAX,MAAPA,IAEDA,EAAO,QAEA,IAEFG,OAAOC,aAAaJ,EAC7B"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-decode-string/index.js

@@ -1,2 +0,0 @@
-import{decodeNamedCharacterReference as e}from"../../../decode-named-character-reference/index.dom.js";import{decodeNumericCharacterReference as r}from"../micromark-util-decode-numeric-character-reference/index.js";const c=/\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;function n(e){return e.replace(c,t)}function t(c,n,t){if(n)return n;if(35===t.charCodeAt(0)){const e=t.charCodeAt(1),c=120===e||88===e;return r(t.slice(c?2:1),c?16:10)}return e(t)||c}export{n as decodeString};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-decode-string/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-decode-string/index.js"],"sourcesContent":["import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0)\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n  return decodeNamedCharacterReference($2) || $0\n}\n"],"names":["characterEscapeOrReference","decodeString","value","replace","decode","$0","$1","$2","charCodeAt","head","hex","decodeNumericCharacterReference","slice","decodeNamedCharacterReference"],"mappings":"uNAEA,MAAMA,EACJ,oEAcK,SAASC,EAAaC,GAC3B,OAAOA,EAAMC,QAAQH,EAA4BI,EACnD,CAQA,SAASA,EAAOC,EAAIC,EAAIC,GACtB,GAAID,EAEF,OAAOA,EAKT,GAAa,KADAC,EAAGC,WAAW,GACV,CACf,MAAMC,EAAOF,EAAGC,WAAW,GACrBE,EAAe,MAATD,GAAyB,KAATA,EAC5B,OAAOE,EAAgCJ,EAAGK,MAAMF,EAAM,EAAI,GAAIA,EAAM,GAAK,GAC1E,CACD,OAAOG,EAA8BN,IAAOF,CAC9C"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-html-tag-name/index.js

@@ -1,2 +0,0 @@
-const e=["address","article","aside","base","basefont","blockquote","body","caption","center","col","colgroup","dd","details","dialog","dir","div","dl","dt","fieldset","figcaption","figure","footer","form","frame","frameset","h1","h2","h3","h4","h5","h6","head","header","hr","html","iframe","legend","li","link","main","menu","menuitem","nav","noframes","ol","optgroup","option","p","param","search","section","summary","table","tbody","td","tfoot","th","thead","title","tr","track","ul"],t=["pre","script","style","textarea"];export{e as htmlBlockNames,t as htmlRawNames};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-html-tag-name/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-html-tag-name/index.js"],"sourcesContent":["/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n"],"names":["htmlBlockNames","htmlRawNames"],"mappings":"AAeY,MAACA,EAAiB,CAC5B,UACA,UACA,QACA,OACA,WACA,aACA,OACA,UACA,SACA,MACA,WACA,KACA,UACA,SACA,MACA,MACA,KACA,KACA,WACA,aACA,SACA,SACA,OACA,QACA,WACA,KACA,KACA,KACA,KACA,KACA,KACA,OACA,SACA,KACA,OACA,SACA,SACA,KACA,OACA,OACA,OACA,WACA,MACA,WACA,KACA,WACA,SACA,IACA,QACA,SACA,UACA,UACA,QACA,QACA,KACA,QACA,KACA,QACA,QACA,KACA,QACA,MAeWC,EAAe,CAAC,MAAO,SAAU,QAAS"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-normalize-identifier/index.js

@@ -1,2 +0,0 @@
-function e(e){return e.replace(/[\t\n\r ]+/g," ").replace(/^ | $/g,"").toLowerCase().toUpperCase()}export{e as normalizeIdentifier};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-normalize-identifier/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-normalize-identifier/index.js"],"sourcesContent":["/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value\n      // Collapse markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ')\n      // Trim.\n      .replace(/^ | $/g, '')\n      // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n"],"names":["normalizeIdentifier","value","replace","toLowerCase","toUpperCase"],"mappings":"AAmBO,SAASA,EAAoBC,GAClC,OACEA,EAEGC,QAAQ,cAAe,KAEvBA,QAAQ,SAAU,IAOlBC,cACAC,aAEP"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-resolve-all/index.js

@@ -1,2 +0,0 @@
-function e(e,n,t){const l=[];let o=-1;for(;++o<e.length;){const r=e[o].resolveAll;r&&!l.includes(r)&&(n=r(n,t),l.push(r))}return n}export{e as resolveAll};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-resolve-all/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-resolve-all/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {Array<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n"],"names":["resolveAll","constructs","events","context","called","index","length","resolve","includes","push"],"mappings":"AAkBO,SAASA,EAAWC,EAAYC,EAAQC,GAE7C,MAAMC,EAAS,GACf,IAAIC,GAAS,EAEb,OAASA,EAAQJ,EAAWK,QAAQ,CAClC,MAAMC,EAAUN,EAAWI,GAAOL,WAE9BO,IAAYH,EAAOI,SAASD,KAC9BL,EAASK,EAAQL,EAAQC,GACzBC,EAAOK,KAAKF,GAEf,CAED,OAAOL,CACT"}

package/dist/node_modules/react-markdown/node_modules/micromark-util-subtokenize/index.js

@@ -1,2 +0,0 @@
-import{splice as t}from"../micromark-util-chunked/index.js";function e(e){const i={};let s,o,r,l,p,f,c,g=-1;for(;++g<e.length;){for(;g in i;)g=i[g];if(s=e[g],g&&"chunkFlow"===s[1].type&&"listItemPrefix"===e[g-1][1].type&&(f=s[1]._tokenizer.events,r=0,r<f.length&&"lineEndingBlank"===f[r][1].type&&(r+=2),r<f.length&&"content"===f[r][1].type))for(;++r<f.length&&"content"!==f[r][1].type;)"chunkText"===f[r][1].type&&(f[r][1]._isInFirstContentOfListItem=!0,r++);if("enter"===s[0])s[1].contentType&&(Object.assign(i,n(e,g)),g=i[g],c=!0);else if(s[1]._container){for(r=g,o=void 0;r--&&(l=e[r],"lineEnding"===l[1].type||"lineEndingBlank"===l[1].type);)"enter"===l[0]&&(o&&(e[o][1].type="lineEndingBlank"),l[1].type="lineEnding",o=r);o&&(s[1].end=Object.assign({},e[o][1].start),p=e.slice(o,g),p.unshift(s),t(e,o,g-o+1,p))}}return!c}function n(e,n){const i=e[n][1],s=e[n][2];let o=n-1;const r=[],l=i._tokenizer||s.parser[i.contentType](i.start),p=l.events,f=[],c={};let g,d,h=-1,u=i,a=0,k=0;const y=[k];for(;u;){for(;e[++o][1]!==u;);r.push(o),u._tokenizer||(g=s.sliceStream(u),u.next||g.push(null),d&&l.defineSkip(u.start),u._isInFirstContentOfListItem&&(l._gfmTasklistFirstContentOfListItem=!0),l.write(g),u._isInFirstContentOfListItem&&(l._gfmTasklistFirstContentOfListItem=void 0)),d=u,u=u.next}for(u=i;++h<p.length;)"exit"===p[h][0]&&"enter"===p[h-1][0]&&p[h][1].type===p[h-1][1].type&&p[h][1].start.line!==p[h][1].end.line&&(k=h+1,y.push(k),u._tokenizer=void 0,u.previous=void 0,u=u.next);for(l.events=[],u?(u._tokenizer=void 0,u.previous=void 0):y.pop(),h=y.length;h--;){const n=p.slice(y[h],y[h+1]),i=r.pop();f.unshift([i,i+n.length-1]),t(e,i,2,n)}for(h=-1;++h<f.length;)c[a+f[h][0]]=a+f[h][1],a+=f[h][1]-f[h][0]-1;return c}export{e as subtokenize};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/micromark-util-subtokenize/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/micromark-util-subtokenize/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n */\n\nimport {splice} from 'micromark-util-chunked'\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} events\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n  let event\n  /** @type {number | undefined} */\n  let lineIndex\n  /** @type {number} */\n  let otherIndex\n  /** @type {Event} */\n  let otherEvent\n  /** @type {Array<Event>} */\n  let parameters\n  /** @type {Array<Event>} */\n  let subevents\n  /** @type {boolean | undefined} */\n  let more\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n    event = events[index]\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start)\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n  return !more\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {Array<Event>} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {Array<number>} */\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {Array<[number, number]>} */\n  const jumps = []\n  /** @type {Record<string, number>} */\n  const gaps = {}\n  /** @type {Array<Chunk>} */\n  let stream\n  /** @type {Token | undefined} */\n  let previous\n  let index = -1\n  /** @type {Token | undefined} */\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start]\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition)\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n      if (!current.next) {\n        stream.push(null)\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n      tokenizer.write(stream)\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    }\n\n    // Unravel the next token.\n    previous = current\n    current = current.next\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start)\n      // Help GC.\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = []\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n  index = -1\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n  return gaps\n}\n"],"names":["subtokenize","events","jumps","event","lineIndex","otherIndex","otherEvent","parameters","subevents","more","index","length","type","_tokenizer","_isInFirstContentOfListItem","contentType","Object","assign","subcontent","_container","undefined","end","start","slice","unshift","splice","eventIndex","token","context","startPosition","startPositions","tokenizer","parser","childEvents","gaps","stream","previous","current","adjust","breaks","push","sliceStream","next","defineSkip","_gfmTasklistFirstContentOfListItem","write","line","pop"],"mappings":"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"}

package/dist/node_modules/react-markdown/node_modules/property-information/index.js

@@ -1,2 +0,0 @@
-import{merge as i}from"./lib/util/merge.js";import{xlink as m}from"./lib/xlink.js";import{xml as o}from"./lib/xml.js";import{xmlns as r}from"./lib/xmlns.js";import{aria as l}from"./lib/aria.js";import{html as t}from"./lib/html.js";import{svg as s}from"./lib/svg.js";import"./lib/util/defined-info.js";import"./lib/util/info.js";const f=i([o,m,r,l,t],"html"),p=i([o,m,r,l,s],"svg");export{f as html,p as svg};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/react-markdown/node_modules/property-information/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../node_modules/react-markdown/node_modules/property-information/index.js"],"sourcesContent":["/**\n * @typedef {import('./lib/util/info.js').Info} Info\n * @typedef {import('./lib/util/schema.js').Schema} Schema\n */\n\nimport {merge} from './lib/util/merge.js'\nimport {xlink} from './lib/xlink.js'\nimport {xml} from './lib/xml.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\n\nexport {find} from './lib/find.js'\nexport {hastToReact} from './lib/hast-to-react.js'\nexport {normalize} from './lib/normalize.js'\nexport const html = merge([xml, xlink, xmlns, aria, htmlBase], 'html')\nexport const svg = merge([xml, xlink, xmlns, aria, svgBase], 'svg')\n"],"names":["html","merge","xml","xlink","xmlns","aria","htmlBase","svg","svgBase"],"mappings":"wUAgBY,MAACA,EAAOC,EAAM,CAACC,EAAKC,EAAOC,EAAOC,EAAMC,GAAW,QAClDC,EAAMN,EAAM,CAACC,EAAKC,EAAOC,EAAOC,EAAMG,GAAU"}

package/dist/node_modules/react-markdown/node_modules/property-information/lib/aria.js

@@ -1,2 +0,0 @@
-import{booleanish as a,number as r,spaceSeparated as i}from"./util/types.js";import{create as e}from"./util/create.js";const l=e({transform:(a,r)=>"role"===r?r:"aria-"+r.slice(4).toLowerCase(),properties:{ariaActiveDescendant:null,ariaAtomic:a,ariaAutoComplete:null,ariaBusy:a,ariaChecked:a,ariaColCount:r,ariaColIndex:r,ariaColSpan:r,ariaControls:i,ariaCurrent:null,ariaDescribedBy:i,ariaDetails:null,ariaDisabled:a,ariaDropEffect:i,ariaErrorMessage:null,ariaExpanded:a,ariaFlowTo:i,ariaGrabbed:a,ariaHasPopup:null,ariaHidden:a,ariaInvalid:null,ariaKeyShortcuts:null,ariaLabel:null,ariaLabelledBy:i,ariaLevel:r,ariaLive:null,ariaModal:a,ariaMultiLine:a,ariaMultiSelectable:a,ariaOrientation:null,ariaOwns:i,ariaPlaceholder:null,ariaPosInSet:r,ariaPressed:a,ariaReadOnly:a,ariaRelevant:null,ariaRequired:a,ariaRoleDescription:i,ariaRowCount:r,ariaRowIndex:r,ariaRowSpan:r,ariaSelected:a,ariaSetSize:r,ariaSort:null,ariaValueMax:r,ariaValueMin:r,ariaValueNow:r,ariaValueText:null,role:null}});export{l as aria};
-//# sourceMappingURL=aria.js.map