@e-llm-studio/instant-learning 0.0.202 → 0.0.204

package/dist/cjs/node_modules/mdast-util-to-hast/lib/revert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revert.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/revert.js"],"sourcesContent":["/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Reference} Reference\n * @typedef {import('mdast').Root} Root\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Reference>} References\n */\n\n// To do: next major: always return array.\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {References} node\n *   Reference node (image, link).\n * @returns {ElementContent | Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return {type: 'text', value: '![' + node.alt + suffix}\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n"],"names":["state","node","subtype","referenceType","suffix","label","identifier","type","value","alt","contents","all","head","unshift","tail","length","push"],"mappings":"mFA2BO,SAAgBA,EAAOC,GAC5B,MAAMC,EAAUD,EAAKE,cACrB,IAAIC,EAAS,IAQb,GANgB,cAAZF,EACFE,GAAU,KACW,SAAZF,IACTE,GAAU,KAAOH,EAAKI,OAASJ,EAAKK,YAAc,KAGlC,mBAAdL,EAAKM,KACP,MAAO,CAACA,KAAM,OAAQC,MAAO,KAAOP,EAAKQ,IAAML,GAGjD,MAAMM,EAAWV,EAAMW,IAAIV,GACrBW,EAAOF,EAAS,GAElBE,GAAsB,SAAdA,EAAKL,KACfK,EAAKJ,MAAQ,IAAMI,EAAKJ,MAExBE,EAASG,QAAQ,CAACN,KAAM,OAAQC,MAAO,MAGzC,MAAMM,EAAOJ,EAASA,EAASK,OAAS,GAQxC,OANID,GAAsB,SAAdA,EAAKP,KACfO,EAAKN,OAASJ,EAEdM,EAASM,KAAK,CAACT,KAAM,OAAQC,MAAOJ,IAG/BM,CACT"}

package/dist/cjs/node_modules/mdast-util-to-hast/lib/state.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../node_modules/unist-util-visit/lib/index.js"),t=require("../../unist-util-position/lib/index.js"),n=require("../../unist-util-generated/lib/index.js"),r=require("../../mdast-util-definitions/lib/index.js"),o=require("./handlers/index.js");const i={}.hasOwnProperty;function a(e,n){e.position&&(n.position=t.position(e))}function l(e,t){let n=t;if(e&&e.data){const t=e.data.hName,r=e.data.hChildren,o=e.data.hProperties;"string"==typeof t&&("element"===n.type?n.tagName=t:n={type:"element",tagName:t,properties:{},children:[]}),"element"===n.type&&o&&(n.properties={...n.properties,...o}),"children"in n&&n.children&&null!=r&&(n.children=r)}return n}function s(e,t,n){const r=t&&t.type;if(!r)throw new Error("Expected node, got `"+t+"`");return i.call(e.handlers,r)?e.handlers[r](e,t,n):e.passThrough&&e.passThrough.includes(r)?"children"in t?{...t,children:p(e,t)}:t:e.unknownHandler?e.unknownHandler(e,t,n):function(e,t){const n=t.data||{},r=!("value"in t)||i.call(n,"hProperties")||i.call(n,"hChildren")?{type:"element",tagName:"div",properties:{},children:p(e,t)}:{type:"text",value:t.value};return e.patch(t,r),e.applyData(t,r)}(e,t)}function p(e,t){const n=[];if("children"in t){const r=t.children;let o=-1;for(;++o<r.length;){const i=s(e,r[o],t);if(i){if(o&&"break"===r[o-1].type&&(Array.isArray(i)||"text"!==i.type||(i.value=i.value.replace(/^\s+/,"")),!Array.isArray(i)&&"element"===i.type)){const e=i.children[0];e&&"text"===e.type&&(e.value=e.value.replace(/^\s+/,""))}Array.isArray(i)?n.push(...i):n.push(i)}}}return n}function u(e,t){const n=[];let r=-1;for(t&&n.push({type:"text",value:"\n"});++r<e.length;)r&&n.push({type:"text",value:"\n"}),n.push(e[r]);return t&&e.length>0&&n.push({type:"text",value:"\n"}),n}exports.all=p,exports.createState=function(d,c){const h=c||{},f=h.allowDangerousHtml||!1,y={};return g.dangerous=f,g.clobberPrefix=void 0===h.clobberPrefix||null===h.clobberPrefix?"user-content-":h.clobberPrefix,g.footnoteLabel=h.footnoteLabel||"Footnotes",g.footnoteLabelTagName=h.footnoteLabelTagName||"h2",g.footnoteLabelProperties=h.footnoteLabelProperties||{className:["sr-only"]},g.footnoteBackLabel=h.footnoteBackLabel||"Back to content",g.unknownHandler=h.unknownHandler,g.passThrough=h.passThrough,g.handlers={...o.handlers,...h.handlers},g.definition=r.definitions(d),g.footnoteById=y,g.footnoteOrder=[],g.footnoteCounts={},g.patch=a,g.applyData=l,g.one=function(e,t){return s(g,e,t)},g.all=function(e){return p(g,e)},g.wrap=u,g.augment=m,e.visit(d,"footnoteDefinition",(e=>{const t=String(e.identifier).toUpperCase();i.call(y,t)||(y[t]=e)})),g;function m(e,r){if(e&&"data"in e&&e.data){const t=e.data;t.hName&&("element"!==r.type&&(r={type:"element",tagName:"",properties:{},children:[]}),r.tagName=t.hName),"element"===r.type&&t.hProperties&&(r.properties={...r.properties,...t.hProperties}),"children"in r&&r.children&&t.hChildren&&(r.children=t.hChildren)}if(e){const o="type"in e?e:{position:e};n.generated(o)||(r.position={start:t.pointStart(o),end:t.pointEnd(o)})}return r}function g(e,t,n,r){return Array.isArray(n)&&(r=n,n={}),m(e,{type:"element",tagName:t,properties:n||{},children:r||[]})}},exports.one=s,exports.wrap=u;
+//# sourceMappingURL=state.js.map

package/dist/cjs/node_modules/mdast-util-to-hast/lib/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/state.js"],"sourcesContent":["/**\n * @typedef {import('hast').Content} HastContent\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Content} MdastContent\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Parent} MdastParent\n * @typedef {import('mdast').Root} MdastRoot\n */\n\n/**\n * @typedef {HastRoot | HastContent} HastNodes\n * @typedef {MdastRoot | MdastContent} MdastNodes\n * @typedef {Extract<MdastNodes, MdastParent>} MdastParents\n *\n * @typedef EmbeddedHastFields\n *   hast fields.\n * @property {string | null | undefined} [hName]\n *   Generate a specific element with this tag name instead.\n * @property {HastProperties | null | undefined} [hProperties]\n *   Generate an element with these properties instead.\n * @property {Array<HastElementContent> | null | undefined} [hChildren]\n *   Generate an element with this content instead.\n *\n * @typedef {Record<string, unknown> & EmbeddedHastFields} MdastData\n *   mdast data with embedded hast fields.\n *\n * @typedef {MdastNodes & {data?: MdastData | null | undefined}} MdastNodeWithData\n *   mdast node with embedded hast data.\n *\n * @typedef PointLike\n *   Point-like value.\n * @property {number | null | undefined} [line]\n *   Line.\n * @property {number | null | undefined} [column]\n *   Column.\n * @property {number | null | undefined} [offset]\n *   Offset.\n *\n * @typedef PositionLike\n *   Position-like value.\n * @property {PointLike | null | undefined} [start]\n *   Point-like value.\n * @property {PointLike | null | undefined} [end]\n *   Point-like value.\n *\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | null | undefined} parent\n *   Parent of `node`.\n * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n *   hast node.\n *\n * @callback HFunctionProps\n *   Signature of `state` for when props are passed.\n * @param {MdastNodes | PositionLike | null | undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {HastProperties} props\n *   Properties.\n * @param {Array<HastElementContent> | null | undefined} [children]\n *   hast content.\n * @returns {HastElement}\n *   Compiled element.\n *\n * @callback HFunctionNoProps\n *   Signature of `state` for when no props are passed.\n * @param {MdastNodes | PositionLike | null | undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {Array<HastElementContent> | null | undefined} [children]\n *   hast content.\n * @returns {HastElement}\n *   Compiled element.\n *\n * @typedef HFields\n *   Info on `state`.\n * @property {boolean} dangerous\n *   Whether HTML is allowed.\n * @property {string} clobberPrefix\n *   Prefix to use to prevent DOM clobbering.\n * @property {string} footnoteLabel\n *   Label to use to introduce the footnote section.\n * @property {string} footnoteLabelTagName\n *   HTML used for the footnote label.\n * @property {HastProperties} footnoteLabelProperties\n *   Properties on the HTML tag used for the footnote label.\n * @property {string} footnoteBackLabel\n *   Label to use from backreferences back to their footnote call.\n * @property {(identifier: string) => MdastDefinition | null} definition\n *   Definition cache.\n * @property {Record<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Record<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {Handler} unknownHandler\n *   Handler for any none not in `passThrough` or otherwise handled.\n * @property {(from: MdastNodes, node: HastNodes) => void} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => Type | HastElement} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {(node: MdastNodes, parent: MdastParents | null | undefined) => HastElementContent | Array<HastElementContent> | null | undefined} one\n *   Transform an mdast node to hast.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastContent>(nodes: Array<Type>, loose?: boolean | null | undefined) => Array<Type | HastText>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n * @property {(left: MdastNodeWithData | PositionLike | null | undefined, right: HastElementContent) => HastElementContent} augment\n *   Like `state` but lower-level and usable on non-elements.\n *   Deprecated: use `patch` and `applyData`.\n * @property {Array<string>} passThrough\n *   List of node types to pass through untouched (except for their children).\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree.\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` attribute on footnotes to prevent it from\n *   *clobbering*.\n * @property {string | null | undefined} [footnoteBackLabel='Back to content']\n *   Label to use from backreferences back to their footnote call (affects\n *   screen readers).\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Label to use for the footnotes section (affects screen readers).\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (note that `id: 'footnote-label'`\n *   is always added as footnote calls use it with `aria-describedby` to\n *   provide an accessible label).\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   Tag name to use for the footnote label.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes.\n * @property {Array<string> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes.\n *\n * @typedef {Record<string, Handler>} Handlers\n *   Handle nodes.\n *\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} State\n *   Info passed around.\n */\n\nimport {visit} from 'unist-util-visit'\nimport {position, pointStart, pointEnd} from 'unist-util-position'\nimport {generated} from 'unist-util-generated'\nimport {definitions} from 'mdast-util-definitions'\nimport {handlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || {}\n  const dangerous = settings.allowDangerousHtml || false\n  /** @type {Record<string, MdastFootnoteDefinition>} */\n  const footnoteById = {}\n\n  // To do: next major: add `options` to state, remove:\n  // `dangerous`, `clobberPrefix`, `footnoteLabel`, `footnoteLabelTagName`,\n  // `footnoteLabelProperties`, `footnoteBackLabel`, `passThrough`,\n  // `unknownHandler`.\n\n  // To do: next major: move to `state.options.allowDangerousHtml`.\n  state.dangerous = dangerous\n  // To do: next major: move to `state.options`.\n  state.clobberPrefix =\n    settings.clobberPrefix === undefined || settings.clobberPrefix === null\n      ? 'user-content-'\n      : settings.clobberPrefix\n  // To do: next major: move to `state.options`.\n  state.footnoteLabel = settings.footnoteLabel || 'Footnotes'\n  // To do: next major: move to `state.options`.\n  state.footnoteLabelTagName = settings.footnoteLabelTagName || 'h2'\n  // To do: next major: move to `state.options`.\n  state.footnoteLabelProperties = settings.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  // To do: next major: move to `state.options`.\n  state.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content'\n  // To do: next major: move to `state.options`.\n  state.unknownHandler = settings.unknownHandler\n  // To do: next major: move to `state.options`.\n  state.passThrough = settings.passThrough\n\n  state.handlers = {...handlers, ...settings.handlers}\n\n  // To do: next major: replace utility with `definitionById` object, so we\n  // only walk once (as we need footnotes too).\n  state.definition = definitions(tree)\n  state.footnoteById = footnoteById\n  /** @type {Array<string>} */\n  state.footnoteOrder = []\n  /** @type {Record<string, number>} */\n  state.footnoteCounts = {}\n\n  state.patch = patch\n  state.applyData = applyData\n  state.one = oneBound\n  state.all = allBound\n  state.wrap = wrap\n  // To do: next major: remove `augment`.\n  state.augment = augment\n\n  visit(tree, 'footnoteDefinition', (definition) => {\n    const id = String(definition.identifier).toUpperCase()\n\n    // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition\n    }\n  })\n\n  // @ts-expect-error Hush, it’s fine!\n  return state\n\n  /**\n   * Finalise the created `right`, a hast node, from `left`, an mdast node.\n   *\n   * @param {MdastNodeWithData | PositionLike | null | undefined} left\n   * @param {HastElementContent} right\n   * @returns {HastElementContent}\n   */\n  /* c8 ignore start */\n  // To do: next major: remove.\n  function augment(left, right) {\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && 'data' in left && left.data) {\n      /** @type {MdastData} */\n      const data = left.data\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          }\n        }\n\n        right.tagName = data.hName\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = {...right.properties, ...data.hProperties}\n      }\n\n      if ('children' in right && right.children && data.hChildren) {\n        right.children = data.hChildren\n      }\n    }\n\n    if (left) {\n      const ctx = 'type' in left ? left : {position: left}\n\n      if (!generated(ctx)) {\n        // @ts-expect-error: fine.\n        right.position = {start: pointStart(ctx), end: pointEnd(ctx)}\n      }\n    }\n\n    return right\n  }\n  /* c8 ignore stop */\n\n  /**\n   * Create an element for `node`.\n   *\n   * @type {HFunctionProps}\n   */\n  /* c8 ignore start */\n  // To do: next major: remove.\n  function state(node, tagName, props, children) {\n    if (Array.isArray(props)) {\n      children = props\n      props = {}\n    }\n\n    // @ts-expect-error augmenting an element yields an element.\n    return augment(node, {\n      type: 'element',\n      tagName,\n      properties: props || {},\n      children: children || []\n    })\n  }\n  /* c8 ignore stop */\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | null | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n   *   Resulting hast node.\n   */\n  function oneBound(node, parent) {\n    // @ts-expect-error: that’s a state :)\n    return one(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function allBound(parent) {\n    // @ts-expect-error: that’s a state :)\n    return all(state, parent)\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {void}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {Type | HastElement}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {Type | HastElement} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent is likely to keep the content around (otherwise: pass\n      // `hChildren`).\n      else {\n        result = {\n          type: 'element',\n          tagName: hName,\n          properties: {},\n          children: []\n        }\n\n        // To do: next major: take the children from the `root`, or inject the\n        // raw/text/comment or so into the element?\n        // if ('children' in node) {\n        //   // @ts-expect-error: assume `children` are allowed in elements.\n        //   result.children = node.children\n        // } else {\n        //   // @ts-expect-error: assume `node` is allowed in elements.\n        //   result.children.push(node)\n        // }\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      result.properties = {...result.properties, ...hProperties}\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      // @ts-expect-error: assume valid children are defined.\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an mdast node into a hast node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   mdast node.\n * @param {MdastParents | null | undefined} [parent]\n *   Parent of `node`.\n * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n *   Resulting hast node.\n */\n// To do: next major: do not expose, keep bound.\nexport function one(state, node, parent) {\n  const type = node && node.type\n\n  // Fail on non-nodes.\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n\n  if (own.call(state.handlers, type)) {\n    return state.handlers[type](state, node, parent)\n  }\n\n  if (state.passThrough && state.passThrough.includes(type)) {\n    // To do: next major: deep clone.\n    // @ts-expect-error: types of passed through nodes are expected to be added manually.\n    return 'children' in node ? {...node, children: all(state, node)} : node\n  }\n\n  if (state.unknownHandler) {\n    return state.unknownHandler(state, node, parent)\n  }\n\n  return defaultUnknownHandler(state, node)\n}\n\n/**\n * Transform the children of an mdast node into hast nodes.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} parent\n *   mdast node to compile\n * @returns {Array<HastElementContent>}\n *   Resulting hast nodes.\n */\n// To do: next major: do not expose, keep bound.\nexport function all(state, parent) {\n  /** @type {Array<HastElementContent>} */\n  const values = []\n\n  if ('children' in parent) {\n    const nodes = parent.children\n    let index = -1\n    while (++index < nodes.length) {\n      const result = one(state, nodes[index], parent)\n\n      // To do: see if we van clean this? Can we merge texts?\n      if (result) {\n        if (index && nodes[index - 1].type === 'break') {\n          if (!Array.isArray(result) && result.type === 'text') {\n            result.value = result.value.replace(/^\\s+/, '')\n          }\n\n          if (!Array.isArray(result) && result.type === 'element') {\n            const head = result.children[0]\n\n            if (head && head.type === 'text') {\n              head.value = head.value.replace(/^\\s+/, '')\n            }\n          }\n        }\n\n        if (Array.isArray(result)) {\n          values.push(...result)\n        } else {\n          values.push(result)\n        }\n      }\n    }\n  }\n\n  return values\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastText | HastElement}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastText | HastElement} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: all(state, node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | null | undefined} [loose=false]\n *   Whether to add line endings at start and end.\n * @returns {Array<Type | HastText>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<Type | HastText>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n"],"names":["own","hasOwnProperty","patch","from","to","position","applyData","result","data","hName","hChildren","hProperties","type","tagName","properties","children","one","state","node","parent","Error","call","handlers","passThrough","includes","all","unknownHandler","value","defaultUnknownHandler","values","nodes","index","length","Array","isArray","replace","head","push","wrap","loose","tree","options","settings","dangerous","allowDangerousHtml","footnoteById","clobberPrefix","undefined","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","className","footnoteBackLabel","definition","definitions","footnoteOrder","footnoteCounts","augment","visit","id","String","identifier","toUpperCase","left","right","ctx","generated","start","pointStart","end","pointEnd","props"],"mappings":"oUAuKA,MAAMA,EAAM,CAAE,EAACC,eA6Lf,SAASC,EAAMC,EAAMC,GACfD,EAAKE,WAAUD,EAAGC,SAAWA,EAAAA,SAASF,GAC5C,CAcA,SAASG,EAAUH,EAAMC,GAEvB,IAAIG,EAASH,EAGb,GAAID,GAAQA,EAAKK,KAAM,CACrB,MAAMC,EAAQN,EAAKK,KAAKC,MAClBC,EAAYP,EAAKK,KAAKE,UACtBC,EAAcR,EAAKK,KAAKG,YAET,iBAAVF,IAGW,YAAhBF,EAAOK,KACTL,EAAOM,QAAUJ,EAOjBF,EAAS,CACPK,KAAM,UACNC,QAASJ,EACTK,WAAY,CAAE,EACdC,SAAU,KAeI,YAAhBR,EAAOK,MAAsBD,IAC/BJ,EAAOO,WAAa,IAAIP,EAAOO,cAAeH,IAI9C,aAAcJ,GACdA,EAAOQ,UADP,MAEAL,IAIAH,EAAOQ,SAAWL,EAErB,CAED,OAAOH,CACT,CAeO,SAASS,EAAIC,EAAOC,EAAMC,GAC/B,MAAMP,EAAOM,GAAQA,EAAKN,KAG1B,IAAKA,EACH,MAAM,IAAIQ,MAAM,uBAAyBF,EAAO,KAGlD,OAAIlB,EAAIqB,KAAKJ,EAAMK,SAAUV,GACpBK,EAAMK,SAASV,GAAMK,EAAOC,EAAMC,GAGvCF,EAAMM,aAAeN,EAAMM,YAAYC,SAASZ,GAG3C,aAAcM,EAAO,IAAIA,EAAMH,SAAUU,EAAIR,EAAOC,IAASA,EAGlED,EAAMS,eACDT,EAAMS,eAAeT,EAAOC,EAAMC,GAiE7C,SAA+BF,EAAOC,GACpC,MAAMV,EAAOU,EAAKV,MAAQ,CAAE,EAEtBD,IACJ,UAAWW,IACTlB,EAAIqB,KAAKb,EAAM,gBAAkBR,EAAIqB,KAAKb,EAAM,aAE9C,CACEI,KAAM,UACNC,QAAS,MACTC,WAAY,CAAE,EACdC,SAAUU,EAAIR,EAAOC,IALvB,CAACN,KAAM,OAAQe,MAAOT,EAAKS,OASjC,OADAV,EAAMf,MAAMgB,EAAMX,GACXU,EAAMX,UAAUY,EAAMX,EAC/B,CA9ESqB,CAAsBX,EAAOC,EACtC,CAaO,SAASO,EAAIR,EAAOE,GAEzB,MAAMU,EAAS,GAEf,GAAI,aAAcV,EAAQ,CACxB,MAAMW,EAAQX,EAAOJ,SACrB,IAAIgB,GAAS,EACb,OAASA,EAAQD,EAAME,QAAQ,CAC7B,MAAMzB,EAASS,EAAIC,EAAOa,EAAMC,GAAQZ,GAGxC,GAAIZ,EAAQ,CACV,GAAIwB,GAAmC,UAA1BD,EAAMC,EAAQ,GAAGnB,OACvBqB,MAAMC,QAAQ3B,IAA2B,SAAhBA,EAAOK,OACnCL,EAAOoB,MAAQpB,EAAOoB,MAAMQ,QAAQ,OAAQ,MAGzCF,MAAMC,QAAQ3B,IAA2B,YAAhBA,EAAOK,MAAoB,CACvD,MAAMwB,EAAO7B,EAAOQ,SAAS,GAEzBqB,GAAsB,SAAdA,EAAKxB,OACfwB,EAAKT,MAAQS,EAAKT,MAAMQ,QAAQ,OAAQ,IAE3C,CAGCF,MAAMC,QAAQ3B,GAChBsB,EAAOQ,QAAQ9B,GAEfsB,EAAOQ,KAAK9B,EAEf,CACF,CACF,CAED,OAAOsB,CACT,CA0CO,SAASS,EAAKR,EAAOS,GAE1B,MAAMhC,EAAS,GACf,IAAIwB,GAAS,EAMb,IAJIQ,GACFhC,EAAO8B,KAAK,CAACzB,KAAM,OAAQe,MAAO,SAG3BI,EAAQD,EAAME,QACjBD,GAAOxB,EAAO8B,KAAK,CAACzB,KAAM,OAAQe,MAAO,OAC7CpB,EAAO8B,KAAKP,EAAMC,IAOpB,OAJIQ,GAAST,EAAME,OAAS,GAC1BzB,EAAO8B,KAAK,CAACzB,KAAM,OAAQe,MAAO,OAG7BpB,CACT,mCA7YO,SAAqBiC,EAAMC,GAChC,MAAMC,EAAWD,GAAW,CAAE,EACxBE,EAAYD,EAASE,qBAAsB,EAE3CC,EAAe,CAAE,EA2DvB,OAnDA5B,EAAM0B,UAAYA,EAElB1B,EAAM6B,mBACuBC,IAA3BL,EAASI,eAA0D,OAA3BJ,EAASI,cAC7C,gBACAJ,EAASI,cAEf7B,EAAM+B,cAAgBN,EAASM,eAAiB,YAEhD/B,EAAMgC,qBAAuBP,EAASO,sBAAwB,KAE9DhC,EAAMiC,wBAA0BR,EAASQ,yBAA2B,CAClEC,UAAW,CAAC,YAGdlC,EAAMmC,kBAAoBV,EAASU,mBAAqB,kBAExDnC,EAAMS,eAAiBgB,EAAShB,eAEhCT,EAAMM,YAAcmB,EAASnB,YAE7BN,EAAMK,SAAW,IAAIA,EAAQA,YAAKoB,EAASpB,UAI3CL,EAAMoC,WAAaC,EAAWA,YAACd,GAC/BvB,EAAM4B,aAAeA,EAErB5B,EAAMsC,cAAgB,GAEtBtC,EAAMuC,eAAiB,CAAE,EAEzBvC,EAAMf,MAAQA,EACde,EAAMX,UAAYA,EAClBW,EAAMD,IAsGN,SAAkBE,EAAMC,GAEtB,OAAOH,EAAIC,EAAOC,EAAMC,EACzB,EAxGDF,EAAMQ,IAkHN,SAAkBN,GAEhB,OAAOM,EAAIR,EAAOE,EACnB,EApHDF,EAAMqB,KAAOA,EAEbrB,EAAMwC,QAAUA,EAEhBC,EAAAA,MAAMlB,EAAM,sBAAuBa,IACjC,MAAMM,EAAKC,OAAOP,EAAWQ,YAAYC,cAIpC9D,EAAIqB,KAAKwB,EAAcc,KAC1Bd,EAAac,GAAMN,EACpB,IAIIpC,EAWP,SAASwC,EAAQM,EAAMC,GAErB,GAAID,GAAQ,SAAUA,GAAQA,EAAKvD,KAAM,CAEvC,MAAMA,EAAOuD,EAAKvD,KAEdA,EAAKC,QACY,YAAfuD,EAAMpD,OACRoD,EAAQ,CACNpD,KAAM,UACNC,QAAS,GACTC,WAAY,CAAE,EACdC,SAAU,KAIdiD,EAAMnD,QAAUL,EAAKC,OAGJ,YAAfuD,EAAMpD,MAAsBJ,EAAKG,cACnCqD,EAAMlD,WAAa,IAAIkD,EAAMlD,cAAeN,EAAKG,cAG/C,aAAcqD,GAASA,EAAMjD,UAAYP,EAAKE,YAChDsD,EAAMjD,SAAWP,EAAKE,UAEzB,CAED,GAAIqD,EAAM,CACR,MAAME,EAAM,SAAUF,EAAOA,EAAO,CAAC1D,SAAU0D,GAE1CG,EAAAA,UAAUD,KAEbD,EAAM3D,SAAW,CAAC8D,MAAOC,EAAUA,WAACH,GAAMI,IAAKC,WAASL,IAE3D,CAED,OAAOD,CACR,CAUD,SAAS/C,EAAMC,EAAML,EAAS0D,EAAOxD,GAOnC,OANIkB,MAAMC,QAAQqC,KAChBxD,EAAWwD,EACXA,EAAQ,CAAE,GAILd,EAAQvC,EAAM,CACnBN,KAAM,UACNC,UACAC,WAAYyD,GAAS,CAAE,EACvBxD,SAAUA,GAAY,IAEzB,CA8BH"}

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/micromark-util-character/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e=(r=/[\dA-Za-z]/,function(e){return null!==e&&r.test(String.fromCharCode(e))});var r;exports.asciiAlphanumeric=e;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/micromark-util-character/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../node_modules/mdast-util-to-hast/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":["asciiAlphanumeric","regex","code","test","String","fromCharCode"],"mappings":"oEAqCY,MAACA,GAkMOC,EAlMwB,aA6M1C,SAAeC,GACb,OAAgB,OAATA,GAAiBD,EAAME,KAAKC,OAAOC,aAAaH,GACxD,GAbH,IAAoBD"}

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/micromark-util-sanitize-uri/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../micromark-util-character/index.js");exports.normalizeUri=function(r){const o=[];let t=-1,i=0,c=0;for(;++t<r.length;){const n=r.charCodeAt(t);let a="";if(37===n&&e.asciiAlphanumeric(r.charCodeAt(t+1))&&e.asciiAlphanumeric(r.charCodeAt(t+2)))c=2;else if(n<128)/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(n))||(a=String.fromCharCode(n));else if(n>55295&&n<57344){const e=r.charCodeAt(t+1);n<56320&&e>56319&&e<57344?(a=String.fromCharCode(n,e),c=1):a="�"}else a=String.fromCharCode(n);a&&(o.push(r.slice(i,t),encodeURIComponent(a)),i=t+c+1,a=""),c&&(t+=c,c=0)}return o.join("")+r.slice(i)};
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/micromark-util-sanitize-uri/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../node_modules/mdast-util-to-hast/node_modules/micromark-util-sanitize-uri/index.js"],"sourcesContent":["import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n  if (!protocol) {\n    return value\n  }\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) ||\n    // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n  return ''\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n  let start = 0\n  let skip = 0\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n    let replace = ''\n\n    // A correct percent encoded value.\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    }\n    // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1)\n\n      // A correct surrogate pair.\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      }\n      // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n  return result.join('') + value.slice(start)\n}\n"],"names":["value","result","index","start","skip","length","code","charCodeAt","replace","asciiAlphanumeric","test","String","fromCharCode","next","push","slice","encodeURIComponent","join"],"mappings":"+IA2DO,SAAsBA,GAE3B,MAAMC,EAAS,GACf,IAAIC,GAAS,EACTC,EAAQ,EACRC,EAAO,EACX,OAASF,EAAQF,EAAMK,QAAQ,CAC7B,MAAMC,EAAON,EAAMO,WAAWL,GAE9B,IAAIM,EAAU,GAGd,GACW,KAATF,GACAG,EAAAA,kBAAkBT,EAAMO,WAAWL,EAAQ,KAC3CO,EAAAA,kBAAkBT,EAAMO,WAAWL,EAAQ,IAE3CE,EAAO,OAGJ,GAAIE,EAAO,IACT,oBAAoBI,KAAKC,OAAOC,aAAaN,MAChDE,EAAUG,OAAOC,aAAaN,SAI7B,GAAIA,EAAO,OAASA,EAAO,MAAO,CACrC,MAAMO,EAAOb,EAAMO,WAAWL,EAAQ,GAGlCI,EAAO,OAASO,EAAO,OAASA,EAAO,OACzCL,EAAUG,OAAOC,aAAaN,EAAMO,GACpCT,EAAO,GAIPI,EAAU,GAEb,MAGCA,EAAUG,OAAOC,aAAaN,GAE5BE,IACFP,EAAOa,KAAKd,EAAMe,MAAMZ,EAAOD,GAAQc,mBAAmBR,IAC1DL,EAAQD,EAAQE,EAAO,EACvBI,EAAU,IAERJ,IACFF,GAASE,EACTA,EAAO,EAEV,CACD,OAAOH,EAAOgB,KAAK,IAAMjB,EAAMe,MAAMZ,EACvC"}

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-is/lib/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t=function(e){if(null==e)return r;if("string"==typeof e)return function(t){return n(r);function r(n){return n&&n.type===t}}(e);if("object"==typeof e)return Array.isArray(e)?function(r){const e=[];let o=-1;for(;++o<r.length;)e[o]=t(r[o]);return n(u);function u(...t){let n=-1;for(;++n<e.length;)if(e[n].call(this,...t))return!0;return!1}}(e):function(t){return n(r);function r(n){let r;for(r in t)if(n[r]!==t[r])return!1;return!0}}(e);if("function"==typeof e)return n(e);throw new Error("Expected function, string, or object as test")};function n(t){return function(n,...r){return Boolean(n&&"object"==typeof n&&"type"in n&&Boolean(t.call(this,n,...r)))}}function r(){return!0}exports.convert=t;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-is/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/mdast-util-to-hast/node_modules/unist-util-is/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @typedef {Record<string, unknown>} Props\n * @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test\n *   Check for an arbitrary node, unaware of TypeScript inferral.\n *\n * @callback TestFunctionAnything\n *   Check if a node passes a test, unaware of TypeScript inferral.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | void}\n *   Whether this node passes the test.\n */\n\n/**\n * @template {Node} Kind\n *   Node type.\n * @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest\n *   Check for a node that can be inferred by TypeScript.\n */\n\n/**\n * Check if a node passes a certain test.\n *\n * @template {Node} Kind\n *   Node type.\n * @callback TestFunctionPredicate\n *   Complex test function for a node that can be inferred by TypeScript.\n * @param {Node} node\n *   A node.\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {node is Kind}\n *   Whether this node passes the test.\n */\n\n/**\n * @callback AssertAnything\n *   Check that an arbitrary value is a node, unaware of TypeScript inferral.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n */\n\n/**\n * Check if a node is a node and passes a certain node test.\n *\n * @template {Node} Kind\n *   Node type.\n * @callback AssertPredicate\n *   Check that an arbitrary value is a specific node, aware of TypeScript.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {node is Kind}\n *   Whether this is a node and passes a test.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param node\n *   Thing to check, typically `Node`.\n * @param test\n *   A check for a specific node.\n * @param index\n *   The node’s position in its parent.\n * @param parent\n *   The node’s parent.\n * @returns\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  /**\n   * @type {(\n   *   (() => false) &\n   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index: number, parent: Parent, context?: unknown) => node is Kind) &\n   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index?: null | undefined, parent?: null | undefined, context?: unknown) => node is Kind) &\n   *   ((node: unknown, test: Test, index: number, parent: Parent, context?: unknown) => boolean) &\n   *   ((node: unknown, test?: Test, index?: null | undefined, parent?: null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function is(node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      // @ts-expect-error Looks like a node.\n      return node && node.type && typeof node.type === 'string'\n        ? Boolean(check.call(context, node, index, parent))\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns\n *   An assertion.\n */\nexport const convert =\n  /**\n   * @type {(\n   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &\n   *   ((test?: Test) => AssertAnything)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {AssertAnything}\n     */\n    function (test) {\n      if (test === undefined || test === null) {\n        return ok\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<string | Props | TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<AssertAnything>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @param {Array<unknown>} parameters\n   * @returns {boolean}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\nfunction propsFactory(check) {\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {AssertAnything}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n  return assertion\n\n  /**\n   * @this {unknown}\n   * @param {unknown} node\n   * @param {Array<unknown>} parameters\n   * @returns {boolean}\n   */\n  function assertion(node, ...parameters) {\n    return Boolean(\n      node &&\n        typeof node === 'object' &&\n        'type' in node &&\n        // @ts-expect-error: fine.\n        Boolean(check.call(this, node, ...parameters))\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n"],"names":["convert","test","ok","check","castFactory","type","node","typeFactory","Array","isArray","tests","checks","index","length","any","parameters","call","this","anyFactory","all","key","propsFactory","Error","Boolean"],"mappings":"oEAqKY,MAACA,EAOb,SAKcC,GACR,GAAIA,QACF,OAAOC,EAGT,GAAoB,iBAATD,EACT,OA8ER,SAAqBE,GACnB,OAAOC,EAAYC,GAKnB,SAASA,EAAKC,GACZ,OAAOA,GAAQA,EAAKD,OAASF,CAC9B,CACH,CAvFeI,CAAYN,GAGrB,GAAoB,iBAATA,EACT,OAAOO,MAAMC,QAAQR,GAe7B,SAAoBS,GAElB,MAAMC,EAAS,GACf,IAAIC,GAAS,EAEb,OAASA,EAAQF,EAAMG,QACrBF,EAAOC,GAASZ,EAAQU,EAAME,IAGhC,OAAOR,EAAYU,GAOnB,SAASA,KAAOC,GACd,IAAIH,GAAS,EAEb,OAASA,EAAQD,EAAOE,QACtB,GAAIF,EAAOC,GAAOI,KAAKC,QAASF,GAAa,OAAO,EAGtD,OAAO,CACR,CACH,CAxCqCG,CAAWjB,GAgDhD,SAAsBE,GACpB,OAAOC,EAAYe,GAMnB,SAASA,EAAIb,GAEX,IAAIc,EAEJ,IAAKA,KAAOjB,EAEV,GAAIG,EAAKc,KAASjB,EAAMiB,GAAM,OAAO,EAGvC,OAAO,CACR,CACH,CAlEwDC,CAAapB,GAG/D,GAAoB,mBAATA,EACT,OAAOG,EAAYH,GAGrB,MAAM,IAAIqB,MAAM,+CAEnB,EAkFH,SAASlB,EAAYD,GACnB,OAQA,SAAmBG,KAASS,GAC1B,OAAOQ,QACLjB,GACkB,iBAATA,GACP,SAAUA,GAEViB,QAAQpB,EAAMa,KAAKC,KAAMX,KAASS,IAEvC,CACH,CAEA,SAASb,IACP,OAAO,CACT"}

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-visit/lib/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("../../unist-util-visit-parents/lib/index.js");exports.CONTINUE=t.CONTINUE,exports.EXIT=t.EXIT,exports.SKIP=t.SKIP,exports.visit=function(e,n,i,r){"function"==typeof n&&"function"!=typeof i&&(r=i,i=n,n=null),t.visitParents(e,n,(function(t,e){const n=e[e.length-1];return i(t,n?n.children.indexOf(t):null,n)}),r)};
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-visit/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/mdast-util-to-hast/node_modules/unist-util-visit/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * Check if `Child` can be a child of `Ancestor`.\n *\n * Returns the ancestor when `Child` can be a child of `Ancestor`, or returns\n * `never`.\n *\n * @template {Node} Ancestor\n *   Node type.\n * @template {Node} Child\n *   Node type.\n * @typedef {(\n *   Ancestor extends Parent\n *     ? Child extends Ancestor['children'][number]\n *       ? Ancestor\n *       : never\n *     : never\n * )} ParentsOf\n */\n\n/**\n * @template {Node} [Visited=Node]\n *   Visited node type.\n * @template {Parent} [Ancestor=Parent]\n *   Ancestor type.\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends Node ? number | null : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends Node ? Ancestor | null : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n */\n\n/**\n * Build a typed `Visitor` function from a node and all possible parents.\n *\n * It will infer which values are passed as `node` and which as `parent`.\n *\n * @template {Node} Visited\n *   Node type.\n * @template {Parent} Ancestor\n *   Parent type.\n * @typedef {Visitor<Visited, ParentsOf<Ancestor, Visited>>} BuildVisitorFromMatch\n */\n\n/**\n * Build a typed `Visitor` function from a list of descendants and a test.\n *\n * It will infer which values are passed as `node` and which as `parent`.\n *\n * @template {Node} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     import('unist-util-visit-parents/complex-types.js').Matches<Descendant, Check>,\n *     Extract<Descendant, Parent>\n *   >\n * )} BuildVisitorFromDescendants\n */\n\n/**\n * Build a typed `Visitor` function from a tree and a test.\n *\n * It will infer which values are passed as `node` and which as `parent`.\n *\n * @template {Node} [Tree=Node]\n *   Node type.\n * @template {Test} [Check=string]\n *   Test type.\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     import('unist-util-visit-parents/complex-types.js').InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @param tree\n *   Tree to traverse.\n * @param test\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Handle each node.\n * @param reverse\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns\n *   Nothing.\n */\nexport const visit =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {Visitor} visitor\n     * @param {boolean | null | undefined} [reverse]\n     * @returns {void}\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        visitor = test\n        test = null\n      }\n\n      visitParents(tree, test, overload, reverse)\n\n      /**\n       * @param {Node} node\n       * @param {Array<Parent>} parents\n       */\n      function overload(node, parents) {\n        const parent = parents[parents.length - 1]\n        return visitor(\n          node,\n          parent ? parent.children.indexOf(node) : null,\n          parent\n        )\n      }\n    }\n  )\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n"],"names":["tree","test","visitor","reverse","visitParents","node","parents","parent","length","children","indexOf"],"mappings":"mNAqJA,SAQcA,EAAMC,EAAMC,EAASC,GACT,mBAATF,GAA0C,mBAAZC,IACvCC,EAAUD,EACVA,EAAUD,EACVA,EAAO,MAGTG,EAAAA,aAAaJ,EAAMC,GAMnB,SAAkBI,EAAMC,GACtB,MAAMC,EAASD,EAAQA,EAAQE,OAAS,GACxC,OAAON,EACLG,EACAE,EAASA,EAAOE,SAASC,QAAQL,GAAQ,KACzCE,EAEH,GAbkCJ,EAezC"}

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-visit-parents/lib/color.browser.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.color=function(e){return e};
+//# sourceMappingURL=color.browser.js.map

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-visit-parents/lib/color.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.browser.js","sources":["../../../../../../../node_modules/mdast-util-to-hast/node_modules/unist-util-visit-parents/lib/color.browser.js"],"sourcesContent":["/**\n * @param {string} d\n * @returns {string}\n */\nexport function color(d) {\n  return d\n}\n"],"names":["d"],"mappings":"kFAIO,SAAeA,GACpB,OAAOA,CACT"}

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-visit-parents/lib/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../unist-util-is/lib/index.js"),t=require("./color.browser.js");const r=!0,n=!1,o="skip";exports.CONTINUE=r,exports.EXIT=n,exports.SKIP=o,exports.visitParents=function(i,u,s,c){"function"==typeof u&&"function"!=typeof s&&(c=s,s=u,u=null);const f=e.convert(u),l=c?-1:1;!function e(i,p,a){const y=i&&"object"==typeof i?i:{};if("string"==typeof y.type){const e="string"==typeof y.tagName?y.tagName:"string"==typeof y.name?y.name:void 0;Object.defineProperty(d,"name",{value:"node ("+t.color(i.type+(e?"<"+e+">":""))+")"})}return d;function d(){let t,y,d,g=[];if((!u||f(i,p,a[a.length-1]||null))&&(g=function(e){if(Array.isArray(e))return e;if("number"==typeof e)return[r,e];return[e]}(s(i,a)),g[0]===n))return g;if(i.children&&g[0]!==o)for(y=(c?i.children.length:-1)+l,d=a.concat(i);y>-1&&y<i.children.length;){if(t=e(i.children[y],y,d)(),t[0]===n)return t;y="number"==typeof t[1]?t[1]:y+l}return g}}(i,void 0,[])()};
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/mdast-util-to-hast/node_modules/unist-util-visit-parents/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/mdast-util-to-hast/node_modules/unist-util-visit-parents/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n */\n\n/**\n * @typedef {boolean | 'skip'} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @template {Node} [Visited=Node]\n *   Visited node type.\n * @template {Parent} [Ancestor=Parent]\n *   Ancestor type.\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<Ancestor>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   Tree type.\n * @template {Test} [Check=string]\n *   Test type.\n * @typedef {Visitor<import('./complex-types.js').Matches<import('./complex-types.js').InclusiveDescendant<Tree>, Check>, Extract<import('./complex-types.js').InclusiveDescendant<Tree>, Parent>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from './color.js'\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @param tree\n *   Tree to traverse.\n * @param test\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Handle each node.\n * @param reverse\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns\n *   Nothing.\n */\nexport const visitParents =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {Visitor<Node>} visitor\n     * @param {boolean | null | undefined} [reverse]\n     * @returns {void}\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        // @ts-expect-error no visitor given, so `visitor` is test.\n        visitor = test\n        test = null\n      }\n\n      const is = convert(test)\n      const step = reverse ? -1 : 1\n\n      factory(tree, undefined, [])()\n\n      /**\n       * @param {Node} node\n       * @param {number | undefined} index\n       * @param {Array<Parent>} parents\n       */\n      function factory(node, index, parents) {\n        /** @type {Record<string, unknown>} */\n        // @ts-expect-error: hush\n        const value = node && typeof node === 'object' ? node : {}\n\n        if (typeof value.type === 'string') {\n          const name =\n            // `hast`\n            typeof value.tagName === 'string'\n              ? value.tagName\n              : // `xast`\n              typeof value.name === 'string'\n              ? value.name\n              : undefined\n\n          Object.defineProperty(visit, 'name', {\n            value:\n              'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n          })\n        }\n\n        return visit\n\n        function visit() {\n          /** @type {ActionTuple} */\n          let result = []\n          /** @type {ActionTuple} */\n          let subresult\n          /** @type {number} */\n          let offset\n          /** @type {Array<Parent>} */\n          let grandparents\n\n          if (!test || is(node, index, parents[parents.length - 1] || null)) {\n            result = toResult(visitor(node, parents))\n\n            if (result[0] === EXIT) {\n              return result\n            }\n          }\n\n          // @ts-expect-error looks like a parent.\n          if (node.children && result[0] !== SKIP) {\n            // @ts-expect-error looks like a parent.\n            offset = (reverse ? node.children.length : -1) + step\n            // @ts-expect-error looks like a parent.\n            grandparents = parents.concat(node)\n\n            // @ts-expect-error looks like a parent.\n            while (offset > -1 && offset < node.children.length) {\n              // @ts-expect-error looks like a parent.\n              subresult = factory(node.children[offset], offset, grandparents)()\n\n              if (subresult[0] === EXIT) {\n                return subresult\n              }\n\n              offset =\n                typeof subresult[1] === 'number' ? subresult[1] : offset + step\n            }\n          }\n\n          return result\n        }\n      }\n    }\n  )\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {ActionTuple}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return [value]\n}\n"],"names":["CONTINUE","EXIT","SKIP","tree","test","visitor","reverse","is","convert","step","factory","node","index","parents","value","type","name","tagName","undefined","Object","defineProperty","visit","color","subresult","offset","grandparents","result","length","Array","isArray","toResult","children","concat"],"mappings":"sJAgFY,MAACA,GAAW,EAKXC,GAAO,EAKPC,EAAO,6EAsCpB,SAQcC,EAAMC,EAAMC,EAASC,GACT,mBAATF,GAA0C,mBAAZC,IACvCC,EAAUD,EAEVA,EAAUD,EACVA,EAAO,MAGT,MAAMG,EAAKC,EAAOA,QAACJ,GACbK,EAAOH,GAAW,EAAI,GAS5B,SAASI,EAAQC,EAAMC,EAAOC,GAG5B,MAAMC,EAAQH,GAAwB,iBAATA,EAAoBA,EAAO,CAAE,EAE1D,GAA0B,iBAAfG,EAAMC,KAAmB,CAClC,MAAMC,EAEqB,iBAAlBF,EAAMG,QACTH,EAAMG,QAEc,iBAAfH,EAAME,KACXF,EAAME,UACNE,EAENC,OAAOC,eAAeC,EAAO,OAAQ,CACnCP,MACE,SAAWQ,EAAKA,MAACX,EAAKI,MAAQC,EAAO,IAAMA,EAAO,IAAM,KAAO,KAEpE,CAED,OAAOK,EAEP,SAASA,IAEP,IAEIE,EAEAC,EAEAC,EANAC,EAAS,GAQb,KAAKtB,GAAQG,EAAGI,EAAMC,EAAOC,EAAQA,EAAQc,OAAS,IAAM,SAC1DD,EA0CZ,SAAkBZ,GAChB,GAAIc,MAAMC,QAAQf,GAChB,OAAOA,EAGT,GAAqB,iBAAVA,EACT,MAAO,CAACd,EAAUc,GAGpB,MAAO,CAACA,EACV,CApDqBgB,CAASzB,EAAQM,EAAME,IAE5Ba,EAAO,KAAOzB,GAChB,OAAOyB,EAKX,GAAIf,EAAKoB,UAAYL,EAAO,KAAOxB,EAOjC,IALAsB,GAAUlB,EAAUK,EAAKoB,SAASJ,QAAU,GAAKlB,EAEjDgB,EAAeZ,EAAQmB,OAAOrB,GAGvBa,GAAU,GAAKA,EAASb,EAAKoB,SAASJ,QAAQ,CAInD,GAFAJ,EAAYb,EAAQC,EAAKoB,SAASP,GAASA,EAAQC,EAAvCf,GAERa,EAAU,KAAOtB,EACnB,OAAOsB,EAGTC,EAC0B,iBAAjBD,EAAU,GAAkBA,EAAU,GAAKC,EAASf,CAC9D,CAGH,OAAOiB,CACR,CACF,CAvEDhB,CAAQP,OAAMe,EAAW,GAAzBR,EAyEH"}

package/dist/cjs/node_modules/react-markdown/node_modules/comma-separated-tokens/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.stringify=function(t,e){const r=e||{};return(""===t[t.length-1]?[...t,""]:t).join((r.padRight?" ":"")+","+(!1===r.padLeft?"":" ")).trim()};
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/react-markdown/node_modules/comma-separated-tokens/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../node_modules/react-markdown/node_modules/comma-separated-tokens/index.js"],"sourcesContent":["/**\n * @typedef Options\n *   Configuration for `stringify`.\n * @property {boolean} [padLeft=true]\n *   Whether to pad a space before a token.\n * @property {boolean} [padRight=false]\n *   Whether to pad a space after a token.\n */\n\n/**\n * @typedef {Options} StringifyOptions\n *   Please use `StringifyOptions` instead.\n */\n\n/**\n * Parse comma-separated tokens to an array.\n *\n * @param {string} value\n *   Comma-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  /** @type {Array<string>} */\n  const tokens = []\n  const input = String(value || '')\n  let index = input.indexOf(',')\n  let start = 0\n  /** @type {boolean} */\n  let end = false\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    const token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings or numbers to comma-separated tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @param {Options} [options]\n *   Configuration for `stringify` (optional).\n * @returns {string}\n *   Comma-separated tokens.\n */\nexport function stringify(values, options) {\n  const settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  const input = values[values.length - 1] === '' ? [...values, ''] : values\n\n  return input\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n"],"names":["values","options","settings","length","join","padRight","padLeft","trim"],"mappings":"sFA4DO,SAAmBA,EAAQC,GAChC,MAAMC,EAAWD,GAAW,CAAE,EAK9B,OAF4C,KAA9BD,EAAOA,EAAOG,OAAS,GAAY,IAAIH,EAAQ,IAAMA,GAGhEI,MACEF,EAASG,SAAW,IAAM,IACzB,MACsB,IAArBH,EAASI,QAAoB,GAAK,MAEtCC,MACL"}

package/dist/cjs/node_modules/react-markdown/node_modules/is-plain-obj/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=function(t){if("object"!=typeof t||null===t)return!1;const e=Object.getPrototypeOf(t);return!(null!==e&&e!==Object.prototype&&null!==Object.getPrototypeOf(e)||Symbol.toStringTag in t||Symbol.iterator in t)};
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/react-markdown/node_modules/is-plain-obj/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../node_modules/react-markdown/node_modules/is-plain-obj/index.js"],"sourcesContent":["export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n"],"names":["value","prototype","Object","getPrototypeOf","Symbol","toStringTag","iterator"],"mappings":"oFAAe,SAAuBA,GACrC,GAAqB,iBAAVA,GAAgC,OAAVA,EAChC,OAAO,EAGR,MAAMC,EAAYC,OAAOC,eAAeH,GACxC,QAAsB,OAAdC,GAAsBA,IAAcC,OAAOD,WAAkD,OAArCC,OAAOC,eAAeF,IAA0BG,OAAOC,eAAeL,GAAYI,OAAOE,YAAYN,EACtK"}

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/react-markdown/node_modules/mdast-util-to-string/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s.\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML.\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} value\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Node}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n"],"names":["emptyOptions","one","value","includeImageAlt","includeHtml","Boolean","node","type","alt","all","children","Array","isArray","values","result","index","length","join","options","settings"],"mappings":"oEAYA,MAAMA,EAAe,CAAE,EAuCvB,SAASC,EAAIC,EAAOC,EAAiBC,GACnC,GAqDF,SAAcF,GACZ,OAAOG,QAAQH,GAA0B,iBAAVA,EACjC,CAvDMI,CAAKJ,GAAQ,CACf,GAAI,UAAWA,EACb,MAAsB,SAAfA,EAAMK,MAAoBH,EAAmBF,EAAMA,MAAX,GAGjD,GAAIC,GAAmB,QAASD,GAASA,EAAMM,IAC7C,OAAON,EAAMM,IAGf,GAAI,aAAcN,EAChB,OAAOO,EAAIP,EAAMQ,SAAUP,EAAiBC,EAE/C,CAED,OAAIO,MAAMC,QAAQV,GACTO,EAAIP,EAAOC,EAAiBC,GAG9B,EACT,CAcA,SAASK,EAAII,EAAQV,EAAiBC,GAEpC,MAAMU,EAAS,GACf,IAAIC,GAAS,EAEb,OAASA,EAAQF,EAAOG,QACtBF,EAAOC,GAASd,EAAIY,EAAOE,GAAQZ,EAAiBC,GAGtD,OAAOU,EAAOG,KAAK,GACrB,kBApEO,SAAkBf,EAAOgB,GAC9B,MAAMC,EAAWD,GAAWlB,EAQ5B,OAAOC,EAAIC,EAN2B,kBAA7BiB,EAAShB,iBACZgB,EAAShB,gBAGmB,kBAAzBgB,EAASf,aAA4Be,EAASf,YAGzD"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"constructs.js","sources":["../../../../../../../node_modules/react-markdown/node_modules/micromark/lib/constructs.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\n\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n}\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n}\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n}\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n}\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n}\n"],"names":["document","list","blockQuote","contentInitial","definition","flowInitial","codeIndented","flow","headingAtx","thematicBreak","setextUnderline","htmlFlow","codeFenced","string","characterReference","characterEscape","text","lineEnding","labelStartImage","attention","autolink","htmlText","labelStartLink","hardBreakEscape","labelEnd","codeText","insideSpan","null","resolveText"],"mappings":"63CA6BY,MAACA,EAAW,CACtB,GAAMC,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMC,EAAUA,YAILC,EAAiB,CAC5B,GAAMC,EAAUA,YAILC,EAAc,CACzB,EAAE,GAAIC,EAAYA,aAClB,EAAE,GAAIA,EAAYA,aAClB,GAAMA,EAAYA,cAIPC,EAAO,CAClB,GAAMC,EAAUA,WAChB,GAAMC,EAAaA,cACnB,GAAM,CAACC,EAAeA,gBAAED,iBACxB,GAAME,EAAQA,SACd,GAAMD,EAAeA,gBACrB,GAAMD,EAAaA,cACnB,GAAMG,EAAUA,WAChB,IAAOA,EAAUA,YAINC,EAAS,CACpB,GAAMC,EAAkBA,mBACxB,GAAMC,EAAeA,iBAIVC,EAAO,CAClB,EAAE,GAAIC,EAAUA,WAChB,EAAE,GAAIA,EAAUA,WAChB,EAAE,GAAIA,EAAUA,WAChB,GAAMC,EAAeA,gBACrB,GAAMJ,EAAkBA,mBACxB,GAAMK,EAASA,UACf,GAAM,CAACC,EAAQA,SAAEC,YACjB,GAAMC,EAAcA,eACpB,GAAM,CAACC,EAAeA,gBAAER,mBACxB,GAAMS,EAAQA,SACd,GAAML,EAASA,UACf,GAAMM,EAAQA,UAIHC,EAAa,CACxBC,KAAM,CAACR,EAASA,UAAES,sCAIY,CAC9BD,KAAM,CAAC,GAAI,8CAIU,CACrBA,KAAM"}

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

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

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

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

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

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

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

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

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

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