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

package/dist/node_modules/mdast-util-to-hast/lib/handlers/html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/html.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').HTML} Html\n * @typedef {import('../state.js').State} State\n * @typedef {import('../../index.js').Raw} Raw\n */\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Raw | Element | null}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.dangerous) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  // To do: next major: return `undefined`.\n  return null\n}\n"],"names":["html","state","node","dangerous","result","type","value","patch","applyData"],"mappings":"AAkBO,SAASA,EAAKC,EAAOC,GAC1B,GAAID,EAAME,UAAW,CAEnB,MAAMC,EAAS,CAACC,KAAM,MAAOC,MAAOJ,EAAKI,OAEzC,OADAL,EAAMM,MAAML,EAAME,GACXH,EAAMO,UAAUN,EAAME,EAC9B,CAGD,OAAO,IACT"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/image-reference.js

@@ -0,0 +1,2 @@
+import{normalizeUri as t}from"../../node_modules/micromark-util-sanitize-uri/index.js";import{revert as e}from"../revert.js";function i(i,r){const n=i.definition(r.identifier);if(!n)return e(i,r);const o={src:t(n.url||""),alt:r.alt};null!==n.title&&void 0!==n.title&&(o.title=n.title);const l={type:"element",tagName:"img",properties:o,children:[]};return i.patch(r,l),i.applyData(r,l)}export{i as imageReference};
+//# sourceMappingURL=image-reference.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/image-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-reference.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js"],"sourcesContent":["/**\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {ElementContent | Array<ElementContent>}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const def = state.definition(node.identifier)\n\n  if (!def) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(def.url || ''), alt: node.alt}\n\n  if (def.title !== null && def.title !== undefined) {\n    properties.title = def.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["imageReference","state","node","def","definition","identifier","revert","properties","src","normalizeUri","url","alt","title","undefined","result","type","tagName","children","patch","applyData"],"mappings":"6HAqBO,SAASA,EAAeC,EAAOC,GACpC,MAAMC,EAAMF,EAAMG,WAAWF,EAAKG,YAElC,IAAKF,EACH,OAAOG,EAAOL,EAAOC,GAIvB,MAAMK,EAAa,CAACC,IAAKC,EAAaN,EAAIO,KAAO,IAAKC,IAAKT,EAAKS,KAE9C,OAAdR,EAAIS,YAAgCC,IAAdV,EAAIS,QAC5BL,EAAWK,MAAQT,EAAIS,OAIzB,MAAME,EAAS,CAACC,KAAM,UAAWC,QAAS,MAAOT,aAAYU,SAAU,IAEvE,OADAhB,EAAMiB,MAAMhB,EAAMY,GACXb,EAAMkB,UAAUjB,EAAMY,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/image.js

@@ -0,0 +1,2 @@
+import{normalizeUri as t}from"../../node_modules/micromark-util-sanitize-uri/index.js";function e(e,l){const i={src:t(l.url)};null!==l.alt&&void 0!==l.alt&&(i.alt=l.alt),null!==l.title&&void 0!==l.title&&(i.title=l.title);const r={type:"element",tagName:"img",properties:i,children:[]};return e.patch(l,r),e.applyData(l,r)}export{e as image};
+//# sourceMappingURL=image.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/image.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Image} Image\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["image","state","node","properties","src","normalizeUri","url","alt","undefined","title","result","type","tagName","children","patch","applyData"],"mappings":"uFAmBO,SAASA,EAAMC,EAAOC,GAE3B,MAAMC,EAAa,CAACC,IAAKC,EAAaH,EAAKI,MAE1B,OAAbJ,EAAKK,UAA6BC,IAAbN,EAAKK,MAC5BJ,EAAWI,IAAML,EAAKK,KAGL,OAAfL,EAAKO,YAAiCD,IAAfN,EAAKO,QAC9BN,EAAWM,MAAQP,EAAKO,OAI1B,MAAMC,EAAS,CAACC,KAAM,UAAWC,QAAS,MAAOT,aAAYU,SAAU,IAEvE,OADAZ,EAAMa,MAAMZ,EAAMQ,GACXT,EAAMc,UAAUb,EAAMQ,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/index.js

@@ -0,0 +1,2 @@
+import{blockquote as o}from"./blockquote.js";import{hardBreak as e}from"./break.js";import{code as r}from"./code.js";import{strikethrough as t}from"./delete.js";import{emphasis as m}from"./emphasis.js";import{footnoteReference as i}from"./footnote-reference.js";import{footnote as f}from"./footnote.js";import{heading as s}from"./heading.js";import{html as n}from"./html.js";import{imageReference as p}from"./image-reference.js";import{image as l}from"./image.js";import{inlineCode as a}from"./inline-code.js";import{linkReference as j}from"./link-reference.js";import{link as c}from"./link.js";import{listItem as b}from"./list-item.js";import{list as g}from"./list.js";import{paragraph as h}from"./paragraph.js";import{root as k}from"./root.js";import{strong as d}from"./strong.js";import{table as u}from"./table.js";import{tableRow as R}from"./table-row.js";import{tableCell as x}from"./table-cell.js";import{text as q}from"./text.js";import{thematicBreak as w}from"./thematic-break.js";const C={blockquote:o,break:e,code:r,delete:t,emphasis:m,footnoteReference:i,footnote:f,heading:s,html:n,imageReference:p,image:l,inlineCode:a,linkReference:j,link:c,listItem:b,list:g,paragraph:h,root:k,strong:d,table:u,tableCell:x,tableRow:R,text:q,thematicBreak:w,toml:y,yaml:y,definition:y,footnoteDefinition:y};function y(){return null}export{C as handlers};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/index.js"],"sourcesContent":["import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {footnote} from './footnote.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  footnote,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  // To do: next major: return `undefined`.\n  return null\n}\n"],"names":["handlers","blockquote","break","hardBreak","code","delete","strikethrough","emphasis","footnoteReference","footnote","heading","html","imageReference","image","inlineCode","linkReference","link","listItem","list","paragraph","root","strong","table","tableCell","tableRow","text","thematicBreak","toml","ignore","yaml","definition","footnoteDefinition"],"mappings":"69BA4BY,MAACA,EAAW,CACtBC,aACAC,MAAOC,EACPC,OACAC,OAAQC,EACRC,WACAC,oBACAC,WACAC,UACAC,OACAC,iBACAC,QACAC,aACAC,gBACAC,OACAC,WACAC,OACAC,YACAC,OACAC,SACAC,QACAC,YACAC,WACAC,OACAC,gBACAC,KAAMC,EACNC,KAAMD,EACNE,WAAYF,EACZG,mBAAoBH,GAItB,SAASA,IAEP,OAAO,IACT"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/inline-code.js

@@ -0,0 +1,2 @@
+function e(e,t){const a={type:"text",value:t.value.replace(/\r?\n|\r/g," ")};e.patch(t,a);const p={type:"element",tagName:"code",properties:{},children:[a]};return e.patch(t,p),e.applyData(t,p)}export{e as inlineCode};
+//# sourceMappingURL=inline-code.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/inline-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-code.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["inlineCode","state","node","text","type","value","replace","patch","result","tagName","properties","children","applyData"],"mappings":"AAiBO,SAASA,EAAWC,EAAOC,GAEhC,MAAMC,EAAO,CAACC,KAAM,OAAQC,MAAOH,EAAKG,MAAMC,QAAQ,YAAa,MACnEL,EAAMM,MAAML,EAAMC,GAGlB,MAAMK,EAAS,CACbJ,KAAM,UACNK,QAAS,OACTC,WAAY,CAAE,EACdC,SAAU,CAACR,IAGb,OADAF,EAAMM,MAAML,EAAMM,GACXP,EAAMW,UAAUV,EAAMM,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/link-reference.js

@@ -0,0 +1,2 @@
+import{normalizeUri as t}from"../../node_modules/micromark-util-sanitize-uri/index.js";import{revert as e}from"../revert.js";function i(i,r){const n=i.definition(r.identifier);if(!n)return e(i,r);const o={href:t(n.url||"")};null!==n.title&&void 0!==n.title&&(o.title=n.title);const l={type:"element",tagName:"a",properties:o,children:i.all(r)};return i.patch(r,l),i.applyData(r,l)}export{i as linkReference};
+//# sourceMappingURL=link-reference.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/link-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-reference.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {ElementContent | Array<ElementContent>}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const def = state.definition(node.identifier)\n\n  if (!def) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(def.url || '')}\n\n  if (def.title !== null && def.title !== undefined) {\n    properties.title = def.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["linkReference","state","node","def","definition","identifier","revert","properties","href","normalizeUri","url","title","undefined","result","type","tagName","children","all","patch","applyData"],"mappings":"6HAqBO,SAASA,EAAcC,EAAOC,GACnC,MAAMC,EAAMF,EAAMG,WAAWF,EAAKG,YAElC,IAAKF,EACH,OAAOG,EAAOL,EAAOC,GAIvB,MAAMK,EAAa,CAACC,KAAMC,EAAaN,EAAIO,KAAO,KAEhC,OAAdP,EAAIQ,YAAgCC,IAAdT,EAAIQ,QAC5BJ,EAAWI,MAAQR,EAAIQ,OAIzB,MAAME,EAAS,CACbC,KAAM,UACNC,QAAS,IACTR,aACAS,SAAUf,EAAMgB,IAAIf,IAGtB,OADAD,EAAMiB,MAAMhB,EAAMW,GACXZ,EAAMkB,UAAUjB,EAAMW,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/link.js

@@ -0,0 +1,2 @@
+import{normalizeUri as t}from"../../node_modules/micromark-util-sanitize-uri/index.js";function e(e,i){const l={href:t(i.url)};null!==i.title&&void 0!==i.title&&(l.title=i.title);const r={type:"element",tagName:"a",properties:l,children:e.all(i)};return e.patch(i,r),e.applyData(i,r)}export{e as link};
+//# sourceMappingURL=link.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/link.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["link","state","node","properties","href","normalizeUri","url","title","undefined","result","type","tagName","children","all","patch","applyData"],"mappings":"uFAmBO,SAASA,EAAKC,EAAOC,GAE1B,MAAMC,EAAa,CAACC,KAAMC,EAAaH,EAAKI,MAEzB,OAAfJ,EAAKK,YAAiCC,IAAfN,EAAKK,QAC9BJ,EAAWI,MAAQL,EAAKK,OAI1B,MAAME,EAAS,CACbC,KAAM,UACNC,QAAS,IACTR,aACAS,SAAUX,EAAMY,IAAIX,IAGtB,OADAD,EAAMa,MAAMZ,EAAMO,GACXR,EAAMc,UAAUb,EAAMO,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/list-item.js

@@ -0,0 +1,2 @@
+function e(e,n,l){const p=e.all(n),a=l?function(e){let n=!1;if("list"===e.type){n=e.spread||!1;const l=e.children;let p=-1;for(;!n&&++p<l.length;)n=t(l[p])}return n}(l):t(n),c={},h=[];if("boolean"==typeof n.checked){const e=p[0];let t;e&&"element"===e.type&&"p"===e.tagName?t=e:(t={type:"element",tagName:"p",properties:{},children:[]},p.unshift(t)),t.children.length>0&&t.children.unshift({type:"text",value:" "}),t.children.unshift({type:"element",tagName:"input",properties:{type:"checkbox",checked:n.checked,disabled:!0},children:[]}),c.className=["task-list-item"]}let i=-1;for(;++i<p.length;){const e=p[i];(a||0!==i||"element"!==e.type||"p"!==e.tagName)&&h.push({type:"text",value:"\n"}),"element"!==e.type||"p"!==e.tagName||a?h.push(e):h.push(...e.children)}const r=p[p.length-1];r&&(a||"element"!==r.type||"p"!==r.tagName)&&h.push({type:"text",value:"\n"});const s={type:"element",tagName:"li",properties:c,children:h};return e.patch(n,s),e.applyData(n,s)}function t(e){const t=e.spread;return null==t?e.children.length>1:t}export{e as listItem};
+//# sourceMappingURL=list-item.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/list-item.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Parent>} Parents\n */\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | null | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === undefined || spread === null\n    ? node.children.length > 1\n    : spread\n}\n"],"names":["listItem","state","node","parent","results","all","loose","type","spread","children","index","length","listItemLoose","listLoose","properties","checked","head","paragraph","tagName","unshift","value","disabled","className","child","push","tail","result","patch","applyData"],"mappings":"AA4BO,SAASA,EAASC,EAAOC,EAAMC,GACpC,MAAMC,EAAUH,EAAMI,IAAIH,GACpBI,EAAQH,EAyEhB,SAAmBD,GACjB,IAAII,GAAQ,EACZ,GAAkB,SAAdJ,EAAKK,KAAiB,CACxBD,EAAQJ,EAAKM,SAAU,EACvB,MAAMC,EAAWP,EAAKO,SACtB,IAAIC,GAAS,EAEb,MAAQJ,KAAWI,EAAQD,EAASE,QAClCL,EAAQM,EAAcH,EAASC,GAElC,CAED,OAAOJ,CACT,CAtFyBO,CAAUV,GAAUS,EAAcV,GAEnDY,EAAa,CAAE,EAEfL,EAAW,GAEjB,GAA4B,kBAAjBP,EAAKa,QAAuB,CACrC,MAAMC,EAAOZ,EAAQ,GAErB,IAAIa,EAEAD,GAAsB,YAAdA,EAAKT,MAAuC,MAAjBS,EAAKE,QAC1CD,EAAYD,GAEZC,EAAY,CAACV,KAAM,UAAWW,QAAS,IAAKJ,WAAY,CAAA,EAAIL,SAAU,IACtEL,EAAQe,QAAQF,IAGdA,EAAUR,SAASE,OAAS,GAC9BM,EAAUR,SAASU,QAAQ,CAACZ,KAAM,OAAQa,MAAO,MAGnDH,EAAUR,SAASU,QAAQ,CACzBZ,KAAM,UACNW,QAAS,QACTJ,WAAY,CAACP,KAAM,WAAYQ,QAASb,EAAKa,QAASM,UAAU,GAChEZ,SAAU,KAKZK,EAAWQ,UAAY,CAAC,iBACzB,CAED,IAAIZ,GAAS,EAEb,OAASA,EAAQN,EAAQO,QAAQ,CAC/B,MAAMY,EAAQnB,EAAQM,IAIpBJ,GACU,IAAVI,GACe,YAAfa,EAAMhB,MACY,MAAlBgB,EAAML,UAENT,EAASe,KAAK,CAACjB,KAAM,OAAQa,MAAO,OAGnB,YAAfG,EAAMhB,MAAwC,MAAlBgB,EAAML,SAAoBZ,EAGxDG,EAASe,KAAKD,GAFdd,EAASe,QAAQD,EAAMd,SAI1B,CAED,MAAMgB,EAAOrB,EAAQA,EAAQO,OAAS,GAGlCc,IAASnB,GAAuB,YAAdmB,EAAKlB,MAAuC,MAAjBkB,EAAKP,UACpDT,EAASe,KAAK,CAACjB,KAAM,OAAQa,MAAO,OAItC,MAAMM,EAAS,CAACnB,KAAM,UAAWW,QAAS,KAAMJ,aAAYL,YAE5D,OADAR,EAAM0B,MAAMzB,EAAMwB,GACXzB,EAAM2B,UAAU1B,EAAMwB,EAC/B,CAyBA,SAASd,EAAcV,GACrB,MAAMM,EAASN,EAAKM,OAEpB,OAAOA,QACHN,EAAKO,SAASE,OAAS,EACvBH,CACN"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/list.js

@@ -0,0 +1,2 @@
+function t(t,e){const a={},r=t.all(e);let s=-1;for("number"==typeof e.start&&1!==e.start&&(a.start=e.start);++s<r.length;){const t=r[s];if("element"===t.type&&"li"===t.tagName&&t.properties&&Array.isArray(t.properties.className)&&t.properties.className.includes("task-list-item")){a.className=["contains-task-list"];break}}const l={type:"element",tagName:e.ordered?"ol":"ul",properties:a,children:t.wrap(r,!0)};return t.patch(e,l),t.applyData(e,l)}export{t as list};
+//# sourceMappingURL=list.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/list.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["list","state","node","properties","results","all","index","start","length","child","type","tagName","Array","isArray","className","includes","result","ordered","children","wrap","patch","applyData"],"mappings":"AAiBO,SAASA,EAAKC,EAAOC,GAE1B,MAAMC,EAAa,CAAE,EACfC,EAAUH,EAAMI,IAAIH,GAC1B,IAAII,GAAS,EAOb,IAL0B,iBAAfJ,EAAKK,OAAqC,IAAfL,EAAKK,QACzCJ,EAAWI,MAAQL,EAAKK,SAIjBD,EAAQF,EAAQI,QAAQ,CAC/B,MAAMC,EAAQL,EAAQE,GAEtB,GACiB,YAAfG,EAAMC,MACY,OAAlBD,EAAME,SACNF,EAAMN,YACNS,MAAMC,QAAQJ,EAAMN,WAAWW,YAC/BL,EAAMN,WAAWW,UAAUC,SAAS,kBACpC,CACAZ,EAAWW,UAAY,CAAC,sBACxB,KACD,CACF,CAGD,MAAME,EAAS,CACbN,KAAM,UACNC,QAAST,EAAKe,QAAU,KAAO,KAC/Bd,aACAe,SAAUjB,EAAMkB,KAAKf,GAAS,IAGhC,OADAH,EAAMmB,MAAMlB,EAAMc,GACXf,EAAMoB,UAAUnB,EAAMc,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/paragraph.js

@@ -0,0 +1,2 @@
+function e(e,t){const p={type:"element",tagName:"p",properties:{},children:e.all(t)};return e.patch(t,p),e.applyData(t,p)}export{e as paragraph};
+//# sourceMappingURL=paragraph.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/paragraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["paragraph","state","node","result","type","tagName","properties","children","all","patch","applyData"],"mappings":"AAgBO,SAASA,EAAUC,EAAOC,GAE/B,MAAMC,EAAS,CACbC,KAAM,UACNC,QAAS,IACTC,WAAY,CAAE,EACdC,SAAUN,EAAMO,IAAIN,IAGtB,OADAD,EAAMQ,MAAMP,EAAMC,GACXF,EAAMS,UAAUR,EAAMC,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/root.js

@@ -0,0 +1,2 @@
+function t(t,a){const p={type:"root",children:t.wrap(t.all(a))};return t.patch(a,p),t.applyData(a,p)}export{t as root};
+//# sourceMappingURL=root.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/root.js"],"sourcesContent":["/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastRoot | HastElement}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["root","state","node","result","type","children","wrap","all","patch","applyData"],"mappings":"AAiBO,SAASA,EAAKC,EAAOC,GAE1B,MAAMC,EAAS,CAACC,KAAM,OAAQC,SAAUJ,EAAMK,KAAKL,EAAMM,IAAIL,KAE7D,OADAD,EAAMO,MAAMN,EAAMC,GACXF,EAAMQ,UAAUP,EAAMC,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/strong.js

@@ -0,0 +1,2 @@
+function t(t,e){const a={type:"element",tagName:"strong",properties:{},children:t.all(e)};return t.patch(e,a),t.applyData(e,a)}export{t as strong};
+//# sourceMappingURL=strong.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/strong.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/strong.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["strong","state","node","result","type","tagName","properties","children","all","patch","applyData"],"mappings":"AAgBO,SAASA,EAAOC,EAAOC,GAE5B,MAAMC,EAAS,CACbC,KAAM,UACNC,QAAS,SACTC,WAAY,CAAE,EACdC,SAAUN,EAAMO,IAAIN,IAGtB,OADAD,EAAMQ,MAAMP,EAAMC,GACXF,EAAMS,UAAUR,EAAMC,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/table-cell.js

@@ -0,0 +1,2 @@
+function t(t,e){const a={type:"element",tagName:"td",properties:{},children:t.all(e)};return t.patch(e,a),t.applyData(e,a)}export{t as tableCell};
+//# sourceMappingURL=table-cell.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/table-cell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-cell.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["tableCell","state","node","result","type","tagName","properties","children","all","patch","applyData"],"mappings":"AAgBO,SAASA,EAAUC,EAAOC,GAI/B,MAAMC,EAAS,CACbC,KAAM,UACNC,QAAS,KACTC,WAAY,CAAE,EACdC,SAAUN,EAAMO,IAAIN,IAGtB,OADAD,EAAMQ,MAAMP,EAAMC,GACXF,EAAMS,UAAUR,EAAMC,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/table-row.js

@@ -0,0 +1,2 @@
+function e(e,t,n){const l=n?n.children:void 0,a=0===(l?l.indexOf(t):1)?"th":"td",p=n&&"table"===n.type?n.align:void 0,r=p?p.length:t.children.length;let i=-1;const c=[];for(;++i<r;){const n=t.children[i],l={},r=p?p[i]:void 0;r&&(l.align=r);let h={type:"element",tagName:a,properties:l,children:[]};n&&(h.children=e.all(n),e.patch(n,h),h=e.applyData(t,h)),c.push(h)}const h={type:"element",tagName:"tr",properties:{},children:e.wrap(c,!0)};return e.patch(t,h),e.applyData(t,h)}export{e as tableRow};
+//# sourceMappingURL=table-row.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/table-row.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-row.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js"],"sourcesContent":["/**\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Parent>} Parents\n */\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | null | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(node, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["tableRow","state","node","parent","siblings","children","undefined","tagName","indexOf","align","type","length","cellIndex","cells","cell","properties","alignValue","result","all","patch","applyData","push","wrap"],"mappings":"AA4BO,SAASA,EAASC,EAAOC,EAAMC,GACpC,MAAMC,EAAWD,EAASA,EAAOE,cAAWC,EAGtCC,EAAuB,KADZH,EAAWA,EAASI,QAAQN,GAAQ,GACpB,KAAO,KAClCO,EAAQN,GAA0B,UAAhBA,EAAOO,KAAmBP,EAAOM,WAAQH,EAC3DK,EAASF,EAAQA,EAAME,OAAST,EAAKG,SAASM,OACpD,IAAIC,GAAa,EAEjB,MAAMC,EAAQ,GAEd,OAASD,EAAYD,GAAQ,CAE3B,MAAMG,EAAOZ,EAAKG,SAASO,GAErBG,EAAa,CAAE,EACfC,EAAaP,EAAQA,EAAMG,QAAaN,EAE1CU,IACFD,EAAWN,MAAQO,GAIrB,IAAIC,EAAS,CAACP,KAAM,UAAWH,UAASQ,aAAYV,SAAU,IAE1DS,IACFG,EAAOZ,SAAWJ,EAAMiB,IAAIJ,GAC5Bb,EAAMkB,MAAML,EAAMG,GAClBA,EAAShB,EAAMmB,UAAUlB,EAAMe,IAGjCJ,EAAMQ,KAAKJ,EACZ,CAGD,MAAMA,EAAS,CACbP,KAAM,UACNH,QAAS,KACTQ,WAAY,CAAE,EACdV,SAAUJ,EAAMqB,KAAKT,GAAO,IAG9B,OADAZ,EAAMkB,MAAMjB,EAAMe,GACXhB,EAAMmB,UAAUlB,EAAMe,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/table.js

@@ -0,0 +1,2 @@
+import{pointStart as e,pointEnd as t}from"../../../unist-util-position/lib/index.js";function n(n,i){const p=n.all(i),r=p.shift(),l=[];if(r){const e={type:"element",tagName:"thead",properties:{},children:n.wrap([r],!0)};n.patch(i.children[0],e),l.push(e)}if(p.length>0){const r={type:"element",tagName:"tbody",properties:{},children:n.wrap(p,!0)},a=e(i.children[1]),o=t(i.children[i.children.length-1]);a.line&&o.line&&(r.position={start:a,end:o}),l.push(r)}const a={type:"element",tagName:"table",properties:{},children:n.wrap(l,!0)};return n.patch(i,a),n.applyData(i,a)}export{n as table};
+//# sourceMappingURL=table.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/table.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointStart, pointEnd} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start.line && end.line) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["table","state","node","rows","all","firstRow","shift","tableContent","head","type","tagName","properties","children","wrap","patch","push","length","body","start","pointStart","end","pointEnd","line","position","result","applyData"],"mappings":"qFAkBO,SAASA,EAAMC,EAAOC,GAC3B,MAAMC,EAAOF,EAAMG,IAAIF,GACjBG,EAAWF,EAAKG,QAEhBC,EAAe,GAErB,GAAIF,EAAU,CAEZ,MAAMG,EAAO,CACXC,KAAM,UACNC,QAAS,QACTC,WAAY,CAAE,EACdC,SAAUX,EAAMY,KAAK,CAACR,IAAW,IAEnCJ,EAAMa,MAAMZ,EAAKU,SAAS,GAAIJ,GAC9BD,EAAaQ,KAAKP,EACnB,CAED,GAAIL,EAAKa,OAAS,EAAG,CAEnB,MAAMC,EAAO,CACXR,KAAM,UACNC,QAAS,QACTC,WAAY,CAAE,EACdC,SAAUX,EAAMY,KAAKV,GAAM,IAGvBe,EAAQC,EAAWjB,EAAKU,SAAS,IACjCQ,EAAMC,EAASnB,EAAKU,SAASV,EAAKU,SAASI,OAAS,IACtDE,EAAMI,MAAQF,EAAIE,OAAML,EAAKM,SAAW,CAACL,QAAOE,QACpDb,EAAaQ,KAAKE,EACnB,CAGD,MAAMO,EAAS,CACbf,KAAM,UACNC,QAAS,QACTC,WAAY,CAAE,EACdC,SAAUX,EAAMY,KAAKN,GAAc,IAGrC,OADAN,EAAMa,MAAMZ,EAAMsB,GACXvB,EAAMwB,UAAUvB,EAAMsB,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/text.js

@@ -0,0 +1,2 @@
+import{trimLines as t}from"../../../trim-lines/index.js";function e(e,n){const r={type:"text",value:t(String(n.value))};return e.patch(n,r),e.applyData(n,r)}export{e as text};
+//# sourceMappingURL=text.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/text.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastText | HastElement}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["text","state","node","result","type","value","trimLines","String","patch","applyData"],"mappings":"yDAmBO,SAASA,EAAKC,EAAOC,GAE1B,MAAMC,EAAS,CAACC,KAAM,OAAQC,MAAOC,EAAUC,OAAOL,EAAKG,SAE3D,OADAJ,EAAMO,MAAMN,EAAMC,GACXF,EAAMQ,UAAUP,EAAMC,EAC/B"}

package/dist/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js

@@ -0,0 +1,2 @@
+function e(e,t){const p={type:"element",tagName:"hr",properties:{},children:[]};return e.patch(t,p),e.applyData(t,p)}export{e as thematicBreak};
+//# sourceMappingURL=thematic-break.js.map

package/dist/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thematic-break.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["thematicBreak","state","node","result","type","tagName","properties","children","patch","applyData"],"mappings":"AAgBO,SAASA,EAAcC,EAAOC,GAEnC,MAAMC,EAAS,CACbC,KAAM,UACNC,QAAS,KACTC,WAAY,CAAE,EACdC,SAAU,IAGZ,OADAN,EAAMO,MAAMN,EAAMC,GACXF,EAAMQ,UAAUP,EAAMC,EAC/B"}

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

@@ -0,0 +1,2 @@
+import{footer as r}from"./footer.js";import{createState as t}from"./state.js";function o(o,e){const n=t(o,e),i=n.one(o,null),p=r(n);return p&&i.children.push({type:"text",value:"\n"},p),Array.isArray(i)?{type:"root",children:i}:i}export{o as toHast};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/mdast-util-to-hast/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('hast').Content} HastContent\n * @typedef {import('hast').Root} HastRoot\n *\n * @typedef {import('mdast').Content} MdastContent\n * @typedef {import('mdast').Root} MdastRoot\n *\n * @typedef {import('./state.js').Options} Options\n */\n\n/**\n * @typedef {HastRoot | HastContent} HastNodes\n * @typedef {MdastRoot | MdastContent} MdastNodes\n */\n\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {HastNodes | null | undefined}\n *   hast tree.\n */\n// To do: next major: always return a single `root`.\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, null)\n  const foot = footer(state)\n\n  if (foot) {\n    // @ts-expect-error If there’s a footer, there were definitions, meaning block\n    // content.\n    // So assume `node` is a parent node.\n    node.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  // To do: next major: always return root?\n  return Array.isArray(node) ? {type: 'root', children: node} : node\n}\n"],"names":["toHast","tree","options","state","createState","node","one","foot","footer","children","push","type","value","Array","isArray"],"mappings":"8EAgGO,SAASA,EAAOC,EAAMC,GAC3B,MAAMC,EAAQC,EAAYH,EAAMC,GAC1BG,EAAOF,EAAMG,IAAIL,EAAM,MACvBM,EAAOC,EAAOL,GAUpB,OARII,GAIFF,EAAKI,SAASC,KAAK,CAACC,KAAM,OAAQC,MAAO,MAAOL,GAI3CM,MAAMC,QAAQT,GAAQ,CAACM,KAAM,OAAQF,SAAUJ,GAAQA,CAChE"}

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

@@ -0,0 +1,2 @@
+function e(e,t){const l=t.referenceType;let n="]";if("collapsed"===l?n+="[]":"full"===l&&(n+="["+(t.label||t.identifier)+"]"),"imageReference"===t.type)return{type:"text",value:"!["+t.alt+n};const u=e.all(t),a=u[0];a&&"text"===a.type?a.value="["+a.value:u.unshift({type:"text",value:"["});const p=u[u.length-1];return p&&"text"===p.type?p.value+=n:u.push({type:"text",value:n}),u}export{e as revert};
+//# sourceMappingURL=revert.js.map

package/dist/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":["revert","state","node","subtype","referenceType","suffix","label","identifier","type","value","alt","contents","all","head","unshift","tail","length","push"],"mappings":"AA2BO,SAASA,EAAOC,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/node_modules/mdast-util-to-hast/lib/state.js

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

package/dist/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","createState","tree","options","settings","dangerous","allowDangerousHtml","footnoteById","state","clobberPrefix","undefined","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","className","footnoteBackLabel","unknownHandler","passThrough","handlers","definition","definitions","footnoteOrder","footnoteCounts","patch","applyData","one","node","parent","all","wrap","augment","visit","id","String","identifier","toUpperCase","call","left","right","data","hName","type","tagName","properties","children","hProperties","hChildren","ctx","position","generated","start","pointStart","end","pointEnd","props","Array","isArray","from","to","result","Error","includes","value","defaultUnknownHandler","values","nodes","index","length","replace","head","push","loose"],"mappings":"iWAuKA,MAAMA,EAAM,CAAE,EAACC,eAYR,SAASC,EAAYC,EAAMC,GAChC,MAAMC,EAAWD,GAAW,CAAE,EACxBE,EAAYD,EAASE,qBAAsB,EAE3CC,EAAe,CAAE,EA2DvB,OAnDAC,EAAMH,UAAYA,EAElBG,EAAMC,mBACuBC,IAA3BN,EAASK,eAA0D,OAA3BL,EAASK,cAC7C,gBACAL,EAASK,cAEfD,EAAMG,cAAgBP,EAASO,eAAiB,YAEhDH,EAAMI,qBAAuBR,EAASQ,sBAAwB,KAE9DJ,EAAMK,wBAA0BT,EAASS,yBAA2B,CAClEC,UAAW,CAAC,YAGdN,EAAMO,kBAAoBX,EAASW,mBAAqB,kBAExDP,EAAMQ,eAAiBZ,EAASY,eAEhCR,EAAMS,YAAcb,EAASa,YAE7BT,EAAMU,SAAW,IAAIA,KAAad,EAASc,UAI3CV,EAAMW,WAAaC,EAAYlB,GAC/BM,EAAMD,aAAeA,EAErBC,EAAMa,cAAgB,GAEtBb,EAAMc,eAAiB,CAAE,EAEzBd,EAAMe,MAAQA,EACdf,EAAMgB,UAAYA,EAClBhB,EAAMiB,IAsGN,SAAkBC,EAAMC,GAEtB,OAAOF,EAAIjB,EAAOkB,EAAMC,EACzB,EAxGDnB,EAAMoB,IAkHN,SAAkBD,GAEhB,OAAOC,EAAIpB,EAAOmB,EACnB,EApHDnB,EAAMqB,KAAOA,EAEbrB,EAAMsB,QAAUA,EAEhBC,EAAM7B,EAAM,sBAAuBiB,IACjC,MAAMa,EAAKC,OAAOd,EAAWe,YAAYC,cAIpCpC,EAAIqC,KAAK7B,EAAcyB,KAC1BzB,EAAayB,GAAMb,EACpB,IAIIX,EAWP,SAASsB,EAAQO,EAAMC,GAErB,GAAID,GAAQ,SAAUA,GAAQA,EAAKE,KAAM,CAEvC,MAAMA,EAAOF,EAAKE,KAEdA,EAAKC,QACY,YAAfF,EAAMG,OACRH,EAAQ,CACNG,KAAM,UACNC,QAAS,GACTC,WAAY,CAAE,EACdC,SAAU,KAIdN,EAAMI,QAAUH,EAAKC,OAGJ,YAAfF,EAAMG,MAAsBF,EAAKM,cACnCP,EAAMK,WAAa,IAAIL,EAAMK,cAAeJ,EAAKM,cAG/C,aAAcP,GAASA,EAAMM,UAAYL,EAAKO,YAChDR,EAAMM,SAAWL,EAAKO,UAEzB,CAED,GAAIT,EAAM,CACR,MAAMU,EAAM,SAAUV,EAAOA,EAAO,CAACW,SAAUX,GAE1CY,EAAUF,KAEbT,EAAMU,SAAW,CAACE,MAAOC,EAAWJ,GAAMK,IAAKC,EAASN,IAE3D,CAED,OAAOT,CACR,CAUD,SAAS9B,EAAMkB,EAAMgB,EAASY,EAAOV,GAOnC,OANIW,MAAMC,QAAQF,KAChBV,EAAWU,EACXA,EAAQ,CAAE,GAILxB,EAAQJ,EAAM,CACnBe,KAAM,UACNC,UACAC,WAAYW,GAAS,CAAE,EACvBV,SAAUA,GAAY,IAEzB,CA8BH,CAYA,SAASrB,EAAMkC,EAAMC,GACfD,EAAKT,WAAUU,EAAGV,SAAWA,EAASS,GAC5C,CAcA,SAASjC,EAAUiC,EAAMC,GAEvB,IAAIC,EAASD,EAGb,GAAID,GAAQA,EAAKlB,KAAM,CACrB,MAAMC,EAAQiB,EAAKlB,KAAKC,MAClBM,EAAYW,EAAKlB,KAAKO,UACtBD,EAAcY,EAAKlB,KAAKM,YAET,iBAAVL,IAGW,YAAhBmB,EAAOlB,KACTkB,EAAOjB,QAAUF,EAOjBmB,EAAS,CACPlB,KAAM,UACNC,QAASF,EACTG,WAAY,CAAE,EACdC,SAAU,KAeI,YAAhBe,EAAOlB,MAAsBI,IAC/Bc,EAAOhB,WAAa,IAAIgB,EAAOhB,cAAeE,IAI9C,aAAcc,GACdA,EAAOf,UADP,MAEAE,IAIAa,EAAOf,SAAWE,EAErB,CAED,OAAOa,CACT,CAeO,SAASlC,EAAIjB,EAAOkB,EAAMC,GAC/B,MAAMc,EAAOf,GAAQA,EAAKe,KAG1B,IAAKA,EACH,MAAM,IAAImB,MAAM,uBAAyBlC,EAAO,KAGlD,OAAI3B,EAAIqC,KAAK5B,EAAMU,SAAUuB,GACpBjC,EAAMU,SAASuB,GAAMjC,EAAOkB,EAAMC,GAGvCnB,EAAMS,aAAeT,EAAMS,YAAY4C,SAASpB,GAG3C,aAAcf,EAAO,IAAIA,EAAMkB,SAAUhB,EAAIpB,EAAOkB,IAASA,EAGlElB,EAAMQ,eACDR,EAAMQ,eAAeR,EAAOkB,EAAMC,GAiE7C,SAA+BnB,EAAOkB,GACpC,MAAMa,EAAOb,EAAKa,MAAQ,CAAE,EAEtBoB,IACJ,UAAWjC,IACT3B,EAAIqC,KAAKG,EAAM,gBAAkBxC,EAAIqC,KAAKG,EAAM,aAE9C,CACEE,KAAM,UACNC,QAAS,MACTC,WAAY,CAAE,EACdC,SAAUhB,EAAIpB,EAAOkB,IALvB,CAACe,KAAM,OAAQqB,MAAOpC,EAAKoC,OASjC,OADAtD,EAAMe,MAAMG,EAAMiC,GACXnD,EAAMgB,UAAUE,EAAMiC,EAC/B,CA9ESI,CAAsBvD,EAAOkB,EACtC,CAaO,SAASE,EAAIpB,EAAOmB,GAEzB,MAAMqC,EAAS,GAEf,GAAI,aAAcrC,EAAQ,CACxB,MAAMsC,EAAQtC,EAAOiB,SACrB,IAAIsB,GAAS,EACb,OAASA,EAAQD,EAAME,QAAQ,CAC7B,MAAMR,EAASlC,EAAIjB,EAAOyD,EAAMC,GAAQvC,GAGxC,GAAIgC,EAAQ,CACV,GAAIO,GAAmC,UAA1BD,EAAMC,EAAQ,GAAGzB,OACvBc,MAAMC,QAAQG,IAA2B,SAAhBA,EAAOlB,OACnCkB,EAAOG,MAAQH,EAAOG,MAAMM,QAAQ,OAAQ,MAGzCb,MAAMC,QAAQG,IAA2B,YAAhBA,EAAOlB,MAAoB,CACvD,MAAM4B,EAAOV,EAAOf,SAAS,GAEzByB,GAAsB,SAAdA,EAAK5B,OACf4B,EAAKP,MAAQO,EAAKP,MAAMM,QAAQ,OAAQ,IAE3C,CAGCb,MAAMC,QAAQG,GAChBK,EAAOM,QAAQX,GAEfK,EAAOM,KAAKX,EAEf,CACF,CACF,CAED,OAAOK,CACT,CA0CO,SAASnC,EAAKoC,EAAOM,GAE1B,MAAMZ,EAAS,GACf,IAAIO,GAAS,EAMb,IAJIK,GACFZ,EAAOW,KAAK,CAAC7B,KAAM,OAAQqB,MAAO,SAG3BI,EAAQD,EAAME,QACjBD,GAAOP,EAAOW,KAAK,CAAC7B,KAAM,OAAQqB,MAAO,OAC7CH,EAAOW,KAAKL,EAAMC,IAOpB,OAJIK,GAASN,EAAME,OAAS,GAC1BR,EAAOW,KAAK,CAAC7B,KAAM,OAAQqB,MAAO,OAG7BH,CACT"}

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

@@ -0,0 +1,2 @@
+const r=(t=/[\dA-Za-z]/,function(r){return null!==r&&t.test(String.fromCharCode(r))});var t;export{r as asciiAlphanumeric};
+//# sourceMappingURL=index.js.map

package/dist/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":"AAqCY,MAACA,GAkMOC,EAlMwB,aA6M1C,SAAeC,GACb,OAAgB,OAATA,GAAiBD,EAAME,KAAKC,OAAOC,aAAaH,GACxD,GAbH,IAAoBD"}

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

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

package/dist/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":["normalizeUri","value","result","index","start","skip","length","code","charCodeAt","replace","asciiAlphanumeric","test","String","fromCharCode","next","push","slice","encodeURIComponent","join"],"mappings":"yEA2DO,SAASA,EAAaC,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,EAAkBT,EAAMO,WAAWL,EAAQ,KAC3CO,EAAkBT,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/node_modules/mdast-util-to-hast/node_modules/unist-util-is/lib/index.js

@@ -0,0 +1,2 @@
+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}export{t as convert};
+//# sourceMappingURL=index.js.map

package/dist/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":"AAqKY,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/node_modules/mdast-util-to-hast/node_modules/unist-util-visit/lib/index.js

@@ -0,0 +1,2 @@
+import{visitParents as n}from"../../unist-util-visit-parents/lib/index.js";export{CONTINUE,EXIT,SKIP}from"../../unist-util-visit-parents/lib/index.js";const t=function(t,i,o,e){"function"==typeof i&&"function"!=typeof o&&(e=o,o=i,i=null),n(t,i,(function(n,t){const i=t[t.length-1];return o(n,i?i.children.indexOf(n):null,i)}),e)};export{t as visit};
+//# sourceMappingURL=index.js.map

package/dist/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":["visit","tree","test","visitor","reverse","visitParents","node","parents","parent","length","children","indexOf"],"mappings":"uJA8IY,MAACA,EAOb,SAQcC,EAAMC,EAAMC,EAASC,GACT,mBAATF,GAA0C,mBAAZC,IACvCC,EAAUD,EACVA,EAAUD,EACVA,EAAO,MAGTG,EAAaJ,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/node_modules/mdast-util-to-hast/node_modules/unist-util-visit-parents/lib/color.browser.js

@@ -0,0 +1,2 @@
+function n(n){return n}export{n as color};
+//# sourceMappingURL=color.browser.js.map

package/dist/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":["color","d"],"mappings":"AAIO,SAASA,EAAMC,GACpB,OAAOA,CACT"}

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

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

package/dist/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","visitParents","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":"sGAgFY,MAACA,GAAW,EAKXC,GAAO,EAKPC,EAAO,OA+BPC,EAOb,SAQcC,EAAMC,EAAMC,EAASC,GACT,mBAATF,GAA0C,mBAAZC,IACvCC,EAAUD,EAEVA,EAAUD,EACVA,EAAO,MAGT,MAAMG,EAAKC,EAAQJ,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,EAAMX,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,CAACf,EAAUe,GAGpB,MAAO,CAACA,EACV,CApDqBgB,CAASzB,EAAQM,EAAME,IAE5Ba,EAAO,KAAO1B,GAChB,OAAO0B,EAKX,GAAIf,EAAKoB,UAAYL,EAAO,KAAOzB,EAOjC,IALAuB,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,KAAOvB,EACnB,OAAOuB,EAGTC,EAC0B,iBAAjBD,EAAU,GAAkBA,EAAU,GAAKC,EAASf,CAC9D,CAGH,OAAOiB,CACR,CACF,CAvEDhB,CAAQP,OAAMe,EAAW,GAAzBR,EAyEH"}

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

@@ -0,0 +1,2 @@
+function t(t,n){const e=n||{};return(""===t[t.length-1]?[...t,""]:t).join((e.padRight?" ":"")+","+(!1===e.padLeft?"":" ")).trim()}export{t as stringify};
+//# sourceMappingURL=index.js.map

package/dist/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":["stringify","values","options","settings","length","join","padRight","padLeft","trim"],"mappings":"AA4DO,SAASA,EAAUC,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/node_modules/react-markdown/node_modules/is-plain-obj/index.js

@@ -0,0 +1,2 @@
+function t(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)}export{t as default};
+//# sourceMappingURL=index.js.map

package/dist/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":["isPlainObject","value","prototype","Object","getPrototypeOf","Symbol","toStringTag","iterator"],"mappings":"AAAe,SAASA,EAAcC,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/node_modules/react-markdown/node_modules/mdast-util-from-markdown/lib/index.js

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