@viswa-test/audit-log 0.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"code.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/code.js"],"sourcesContent":["/**\n * @import {Element, Properties} from 'hast'\n * @import {Code} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  /** @type {Properties} */\n  const properties = {}\n  // Someone can write `js&#x20;python&#x9;ruby`.\n  const language = node.lang ? node.lang.split(/\\s+/) : []\n\n  // GH/CM still drop the non-first languages.\n  if (language.length > 0) {\n    properties.className = ['language-' + language[0]]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n"],"names":["code","state","node","value","properties","language","lang","split","length","className","result","type","tagName","children","meta","data","patch","applyData"],"mappings":"AAgBO,SAASA,EAAKC,EAAOC,GAC1B,MAAMC,EAAQD,EAAKC,MAAQD,EAAKC,MAAQ,KAAO,GAEzCC,EAAa,CAAE,EAEfC,EAAWH,EAAKI,KAAOJ,EAAKI,KAAKC,MAAM,OAAS,GAGlDF,EAASG,OAAS,IACpBJ,EAAWK,UAAY,CAAC,YAAcJ,EAAS,KAKjD,IAAIK,EAAS,CACXC,KAAM,UACNC,QAAS,OACTR,aACAS,SAAU,CAAC,CAACF,KAAM,OAAQR,WAa5B,OAVID,EAAKY,OACPJ,EAAOK,KAAO,CAACD,KAAMZ,EAAKY,OAG5Bb,EAAMe,MAAMd,EAAMQ,GAClBA,EAAST,EAAMgB,UAAUf,EAAMQ,GAG/BA,EAAS,CAACC,KAAM,UAAWC,QAAS,MAAOR,WAAY,GAAIS,SAAU,CAACH,IACtET,EAAMe,MAAMd,EAAMQ,GACXA,CACT"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/delete.js"],"sourcesContent":["/**\n * @import {Element} from 'hast'\n * @import {Delete} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["strikethrough","state","node","result","type","tagName","properties","children","all","patch","applyData"],"mappings":"AAgBO,SAASA,EAAcC,EAAOC,GAEnC,MAAMC,EAAS,CACbC,KAAM,UACNC,QAAS,MACTC,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/emphasis.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"emphasis.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js"],"sourcesContent":["/**\n * @import {Element} from 'hast'\n * @import {Emphasis} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["emphasis","state","node","result","type","tagName","properties","children","all","patch","applyData"],"mappings":"AAgBO,SAASA,EAASC,EAAOC,GAE9B,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/footnote-reference.js

@@ -0,0 +1,2 @@
+import{normalizeUri as e}from"../../../micromark-util-sanitize-uri/index.js";function t(t,o){const r="string"==typeof t.options.clobberPrefix?t.options.clobberPrefix:"user-content-",n=String(o.identifier).toUpperCase(),i=e(n.toLowerCase()),a=t.footnoteOrder.indexOf(n);let p,s=t.footnoteCounts.get(n);void 0===s?(s=0,t.footnoteOrder.push(n),p=t.footnoteOrder.length):p=a+1,s+=1,t.footnoteCounts.set(n,s);const f={type:"element",tagName:"a",properties:{href:"#"+r+"fn-"+i,id:r+"fnref-"+i+(s>1?"-"+s:""),dataFootnoteRef:!0,ariaDescribedBy:["footnote-label"]},children:[{type:"text",value:String(p)}]};t.patch(o,f);const c={type:"element",tagName:"sup",properties:{},children:[f]};return t.patch(o,c),t.applyData(o,c)}export{t as footnoteReference};
+//# sourceMappingURL=footnote-reference.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"footnote-reference.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js"],"sourcesContent":["/**\n * @import {Element} from 'hast'\n * @import {FootnoteReference} from 'mdast'\n * @import {State} from '../state.js'\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  let reuseCounter = state.footnoteCounts.get(id)\n\n  if (reuseCounter === undefined) {\n    reuseCounter = 0\n    state.footnoteOrder.push(id)\n    counter = state.footnoteOrder.length\n  } else {\n    counter = index + 1\n  }\n\n  reuseCounter += 1\n  state.footnoteCounts.set(id, reuseCounter)\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + clobberPrefix + 'fn-' + safeId,\n      id:\n        clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n"],"names":["footnoteReference","state","node","clobberPrefix","options","id","String","identifier","toUpperCase","safeId","normalizeUri","toLowerCase","index","footnoteOrder","indexOf","counter","reuseCounter","footnoteCounts","get","undefined","push","length","set","link","type","tagName","properties","href","dataFootnoteRef","ariaDescribedBy","children","value","patch","sup","applyData"],"mappings":"6EAkBO,SAASA,EAAkBC,EAAOC,GACvC,MAAMC,EACmC,iBAAhCF,EAAMG,QAAQD,cACjBF,EAAMG,QAAQD,cACd,gBACAE,EAAKC,OAAOJ,EAAKK,YAAYC,cAC7BC,EAASC,EAAaL,EAAGM,eACzBC,EAAQX,EAAMY,cAAcC,QAAQT,GAE1C,IAAIU,EAEAC,EAAef,EAAMgB,eAAeC,IAAIb,QAEvBc,IAAjBH,GACFA,EAAe,EACff,EAAMY,cAAcO,KAAKf,GACzBU,EAAUd,EAAMY,cAAcQ,QAE9BN,EAAUH,EAAQ,EAGpBI,GAAgB,EAChBf,EAAMgB,eAAeK,IAAIjB,EAAIW,GAG7B,MAAMO,EAAO,CACXC,KAAM,UACNC,QAAS,IACTC,WAAY,CACVC,KAAM,IAAMxB,EAAgB,MAAQM,EACpCJ,GACEF,EACA,SACAM,GACCO,EAAe,EAAI,IAAMA,EAAe,IAC3CY,iBAAiB,EACjBC,gBAAiB,CAAC,mBAEpBC,SAAU,CAAC,CAACN,KAAM,OAAQO,MAAOzB,OAAOS,MAE1Cd,EAAM+B,MAAM9B,EAAMqB,GAGlB,MAAMU,EAAM,CACVT,KAAM,UACNC,QAAS,MACTC,WAAY,CAAE,EACdI,SAAU,CAACP,IAGb,OADAtB,EAAM+B,MAAM9B,EAAM+B,GACXhC,EAAMiC,UAAUhC,EAAM+B,EAC/B"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"heading.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/handlers/heading.js"],"sourcesContent":["/**\n * @import {Element} from 'hast'\n * @import {Heading} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["heading","state","node","result","type","tagName","depth","properties","children","all","patch","applyData"],"mappings":"AAgBO,SAASA,EAAQC,EAAOC,GAE7B,MAAMC,EAAS,CACbC,KAAM,UACNC,QAAS,IAAMH,EAAKI,MACpBC,WAAY,CAAE,EACdC,SAAUP,EAAMQ,IAAIP,IAGtB,OADAD,EAAMS,MAAMR,EAAMC,GACXF,EAAMU,UAAUT,EAAMC,EAC/B"}

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

@@ -0,0 +1,2 @@
+function a(a,t){if(a.options.allowDangerousHtml){const o={type:"raw",value:t.value};return a.patch(t,o),a.applyData(t,o)}}export{a as html};
+//# sourceMappingURL=html.js.map

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 * @import {Element} from 'hast'\n * @import {Html} from 'mdast'\n * @import {State} from '../state.js'\n * @import {Raw} from '../../index.js'\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 {Element | Raw | undefined}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.options.allowDangerousHtml) {\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  return undefined\n}\n"],"names":["html","state","node","options","allowDangerousHtml","result","type","value","patch","applyData"],"mappings":"AAkBO,SAASA,EAAKC,EAAOC,GAC1B,GAAID,EAAME,QAAQC,mBAAoB,CAEpC,MAAMC,EAAS,CAACC,KAAM,MAAOC,MAAOL,EAAKK,OAEzC,OADAN,EAAMO,MAAMN,EAAMG,GACXJ,EAAMQ,UAAUP,EAAMG,EAC9B,CAGH"}

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

@@ -0,0 +1,2 @@
+import{normalizeUri as t}from"../../../micromark-util-sanitize-uri/index.js";import{revert as e}from"../revert.js";function i(i,r){const n=String(r.identifier).toUpperCase(),o=i.definitionById.get(n);if(!o)return e(i,r);const l={src:t(o.url||""),alt:r.alt};null!==o.title&&void 0!==o.title&&(l.title=o.title);const a={type:"element",tagName:"img",properties:l,children:[]};return i.patch(r,a),i.applyData(r,a)}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 * @import {ElementContent, Element, Properties} from 'hast'\n * @import {ImageReference} from 'mdast'\n * @import {State} from '../state.js'\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 {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.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","id","String","identifier","toUpperCase","definition","definitionById","get","revert","properties","src","normalizeUri","url","alt","title","undefined","result","type","tagName","children","patch","applyData"],"mappings":"mHAmBO,SAASA,EAAeC,EAAOC,GACpC,MAAMC,EAAKC,OAAOF,EAAKG,YAAYC,cAC7BC,EAAaN,EAAMO,eAAeC,IAAIN,GAE5C,IAAKI,EACH,OAAOG,EAAOT,EAAOC,GAIvB,MAAMS,EAAa,CAACC,IAAKC,EAAaN,EAAWO,KAAO,IAAKC,IAAKb,EAAKa,KAE9C,OAArBR,EAAWS,YAAuCC,IAArBV,EAAWS,QAC1CL,EAAWK,MAAQT,EAAWS,OAIhC,MAAME,EAAS,CAACC,KAAM,UAAWC,QAAS,MAAOT,aAAYU,SAAU,IAEvE,OADApB,EAAMqB,MAAMpB,EAAMgB,GACXjB,EAAMsB,UAAUrB,EAAMgB,EAC/B"}

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

@@ -0,0 +1,2 @@
+import{normalizeUri as t}from"../../../micromark-util-sanitize-uri/index.js";function i(i,l){const e={src:t(l.url)};null!==l.alt&&void 0!==l.alt&&(e.alt=l.alt),null!==l.title&&void 0!==l.title&&(e.title=l.title);const r={type:"element",tagName:"img",properties:e,children:[]};return i.patch(l,r),i.applyData(l,r)}export{i 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 * @import {Element, Properties} from 'hast'\n * @import {Image} from 'mdast'\n * @import {State} from '../state.js'\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":"6EAkBO,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{heading as f}from"./heading.js";import{html as s}from"./html.js";import{imageReference as p}from"./image-reference.js";import{image as l}from"./image.js";import{inlineCode as n}from"./inline-code.js";import{linkReference as a}from"./link-reference.js";import{link as j}from"./link.js";import{listItem as c}from"./list-item.js";import{list as b}from"./list.js";import{paragraph as g}from"./paragraph.js";import{root as h}from"./root.js";import{strong as k}from"./strong.js";import{table as d}from"./table.js";import{tableRow as R}from"./table-row.js";import{tableCell as u}from"./table-cell.js";import{text as x}from"./text.js";import{thematicBreak as q}from"./thematic-break.js";const w={blockquote:o,break:e,code:r,delete:t,emphasis:m,footnoteReference:i,heading:f,html:s,imageReference:p,image:l,inlineCode:n,linkReference:a,link:j,listItem:c,list:b,paragraph:g,root:h,strong:k,table:d,tableCell:u,tableRow:R,text:x,thematicBreak:q,toml:C,yaml:C,definition:C,footnoteDefinition:C};function C(){}export{w 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":["/**\n * @import {Handlers} from '../state.js'\n */\n\nimport {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 {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 *\n * @satisfies {Handlers}\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  // @ts-expect-error: root is different, but hard to type.\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  return undefined\n}\n"],"names":["handlers","blockquote","break","hardBreak","code","delete","strikethrough","emphasis","footnoteReference","heading","html","imageReference","image","inlineCode","linkReference","link","listItem","list","paragraph","root","strong","table","tableCell","tableRow","text","thematicBreak","toml","ignore","yaml","definition","footnoteDefinition"],"mappings":"o7BAiCY,MAACA,EAAW,CACtBC,aACAC,MAAOC,EACPC,OACAC,OAAQC,EACRC,WACAC,oBACAC,UACAC,OACAC,iBACAC,QACAC,aACAC,gBACAC,OACAC,WACAC,OACAC,YAEAC,OACAC,SACAC,QACAC,YACAC,WACAC,OACAC,gBACAC,KAAMC,EACNC,KAAMD,EACNE,WAAYF,EACZG,mBAAoBH,GAItB,SAASA,IAET"}

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 * @import {Element, Text} from 'hast'\n * @import {InlineCode} from 'mdast'\n * @import {State} from '../state.js'\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":"AAgBO,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"../../../micromark-util-sanitize-uri/index.js";import{revert as e}from"../revert.js";function i(i,r){const n=String(r.identifier).toUpperCase(),o=i.definitionById.get(n);if(!o)return e(i,r);const l={href:t(o.url||"")};null!==o.title&&void 0!==o.title&&(l.title=o.title);const a={type:"element",tagName:"a",properties:l,children:i.all(r)};return i.patch(r,a),i.applyData(r,a)}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 * @import {ElementContent, Element, Properties} from 'hast'\n * @import {LinkReference} from 'mdast'\n * @import {State} from '../state.js'\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 {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(definition.url || '')}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.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","id","String","identifier","toUpperCase","definition","definitionById","get","revert","properties","href","normalizeUri","url","title","undefined","result","type","tagName","children","all","patch","applyData"],"mappings":"mHAmBO,SAASA,EAAcC,EAAOC,GACnC,MAAMC,EAAKC,OAAOF,EAAKG,YAAYC,cAC7BC,EAAaN,EAAMO,eAAeC,IAAIN,GAE5C,IAAKI,EACH,OAAOG,EAAOT,EAAOC,GAIvB,MAAMS,EAAa,CAACC,KAAMC,EAAaN,EAAWO,KAAO,KAEhC,OAArBP,EAAWQ,YAAuCC,IAArBT,EAAWQ,QAC1CJ,EAAWI,MAAQR,EAAWQ,OAIhC,MAAME,EAAS,CACbC,KAAM,UACNC,QAAS,IACTR,aACAS,SAAUnB,EAAMoB,IAAInB,IAGtB,OADAD,EAAMqB,MAAMpB,EAAMe,GACXhB,EAAMsB,UAAUrB,EAAMe,EAC/B"}

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

@@ -0,0 +1,2 @@
+import{normalizeUri as t}from"../../../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 * @import {Element, Properties} from 'hast'\n * @import {Link} from 'mdast'\n * @import {State} from '../state.js'\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":"6EAkBO,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 * @import {ElementContent, Element, Properties} from 'hast'\n * @import {ListItem, Parents} from 'mdast'\n * @import {State} from '../state.js'\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 | 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 === null || spread === undefined\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":"AAkBO,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 * @import {Element, Properties} from 'hast'\n * @import {List} from 'mdast'\n * @import {State} from '../state.js'\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":"AAgBO,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 * @import {Element} from 'hast'\n * @import {Paragraph} from 'mdast'\n * @import {State} from '../state.js'\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 * @import {Parents as HastParents, Root as HastRoot} from 'hast'\n * @import {Root as MdastRoot} from 'mdast'\n * @import {State} from '../state.js'\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 {HastParents}\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":"AAgBO,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 * @import {Element} from 'hast'\n * @import {Strong} from 'mdast'\n * @import {State} from '../state.js'\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 * @import {Element} from 'hast'\n * @import {TableCell} from 'mdast'\n * @import {State} from '../state.js'\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(n,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 * @import {Element, ElementContent, Properties} from 'hast'\n * @import {Parents, TableRow} from 'mdast'\n * @import {State} from '../state.js'\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 | 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  // To do: option to use `style`?\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(cell, 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":"AAkBO,SAASA,EAASC,EAAOC,EAAMC,GACpC,MAAMC,EAAWD,EAASA,EAAOE,cAAWC,EAGtCC,EAAuB,KADZH,EAAWA,EAASI,QAAQN,GAAQ,GACpB,KAAO,KAElCO,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,UAAUN,EAAMG,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(),a=[];if(r){const e={type:"element",tagName:"thead",properties:{},children:n.wrap([r],!0)};n.patch(i.children[0],e),a.push(e)}if(p.length>0){const r={type:"element",tagName:"tbody",properties:{},children:n.wrap(p,!0)},l=e(i.children[1]),o=t(i.children[i.children.length-1]);l&&o&&(r.position={start:l,end:o}),a.push(r)}const l={type:"element",tagName:"table",properties:{},children:n.wrap(a,!0)};return n.patch(i,l),n.applyData(i,l)}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 * @import {Table} from 'mdast'\n * @import {Element} from 'hast'\n * @import {State} from '../state.js'\n */\n\nimport {pointEnd, pointStart} 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 && end) 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","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,GAASE,IAAKH,EAAKK,SAAW,CAACJ,QAAOE,QAC1Cb,EAAaQ,KAAKE,EACnB,CAGD,MAAMM,EAAS,CACbd,KAAM,UACNC,QAAS,QACTC,WAAY,CAAE,EACdC,SAAUX,EAAMY,KAAKN,GAAc,IAGrC,OADAN,EAAMa,MAAMZ,EAAMqB,GACXtB,EAAMuB,UAAUtB,EAAMqB,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 * @import {Element as HastElement, Text as HastText} from 'hast'\n * @import {Text as MdastText} from 'mdast'\n * @import {State} from '../state.js'\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 {HastElement | HastText}\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":"yDAkBO,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 * @import {Element} from 'hast'\n * @import {ThematicBreak} from 'mdast'\n * @import {State} from '../state.js'\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,void 0),p=r(n),s=Array.isArray(i)?{type:"root",children:i}:i||{type:"root",children:[]};return p&&s.children.push({type:"text",value:"\n"},p),s}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 * @import {Nodes as HastNodes} from 'hast'\n * @import {Nodes as MdastNodes} from 'mdast'\n * @import {Options} from './state.js'\n */\n\nimport {ok as assert} from 'devlop'\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 (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n"],"names":["toHast","tree","options","state","createState","node","one","undefined","foot","footer","result","Array","isArray","type","children","push","value"],"mappings":"8EAuFO,SAASA,EAAOC,EAAMC,GAC3B,MAAMC,EAAQC,EAAYH,EAAMC,GAC1BG,EAAOF,EAAMG,IAAIL,OAAMM,GACvBC,EAAOC,EAAON,GAEdO,EAASC,MAAMC,QAAQP,GACzB,CAACQ,KAAM,OAAQC,SAAUT,GACzBA,GAAQ,CAACQ,KAAM,OAAQC,SAAU,IAUrC,OARIN,GAKFE,EAAOI,SAASC,KAAK,CAACF,KAAM,OAAQG,MAAO,MAAOR,GAG7CE,CACT"}

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 * @import {ElementContent} from 'hast'\n * @import {Reference, Nodes} from 'mdast'\n * @import {State} from './state.js'\n */\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 {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {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":"AAgBO,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,CAAC,CAACA,KAAM,OAAQC,MAAO,KAAOP,EAAKQ,IAAML,IAGlD,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 e from"../../@ungap/structured-clone/esm/index.js";import{visit as t}from"../../unist-util-visit/lib/index.js";import{position as n}from"../../unist-util-position/lib/index.js";import{handlers as i}from"./handlers/index.js";const r={}.hasOwnProperty,o={};function a(n,a){const h=a||o,d=new Map,f=new Map,y=new Map,m={...i,...h.handlers},g={all:function(e){const t=[];if("children"in e){const n=e.children;let i=-1;for(;++i<n.length;){const r=g.one(n[i],e);if(r){if(i&&"break"===n[i-1].type&&(Array.isArray(r)||"text"!==r.type||(r.value=c(r.value)),!Array.isArray(r)&&"element"===r.type)){const e=r.children[0];e&&"text"===e.type&&(e.value=c(e.value))}Array.isArray(r)?t.push(...r):t.push(r)}}}return t},applyData:s,definitionById:d,footnoteById:f,footnoteCounts:y,footnoteOrder:[],handlers:m,one:function(t,n){const i=t.type,o=g.handlers[i];if(r.call(g.handlers,i)&&o)return o(g,t,n);if(g.options.passThrough&&g.options.passThrough.includes(i)){if("children"in t){const{children:n,...i}=t,r=e(i);return r.children=g.all(t),r}return e(t)}return(g.options.unknownHandler||p)(g,t,n)},options:h,patch:l,wrap:u};return t(n,function(e){if("definition"===e.type||"footnoteDefinition"===e.type){const t="definition"===e.type?d:f,n=String(e.identifier).toUpperCase();t.has(n)||t.set(n,e)}}),g}function l(e,t){e.position&&(t.position=n(e))}function s(t,n){let i=n;if(t&&t.data){const n=t.data.hName,r=t.data.hChildren,o=t.data.hProperties;if("string"==typeof n)if("element"===i.type)i.tagName=n;else{i={type:"element",tagName:n,properties:{},children:"children"in i?i.children:[i]}}"element"===i.type&&o&&Object.assign(i.properties,e(o)),"children"in i&&i.children&&null!=r&&(i.children=r)}return i}function p(e,t){const n=t.data||{},i=!("value"in t)||r.call(n,"hProperties")||r.call(n,"hChildren")?{type:"element",tagName:"div",properties:{},children:e.all(t)}:{type:"text",value:t.value};return e.patch(t,i),e.applyData(t,i)}function u(e,t){const n=[];let i=-1;for(t&&n.push({type:"text",value:"\n"});++i<e.length;)i&&n.push({type:"text",value:"\n"}),n.push(e[i]);return t&&e.length>0&&n.push({type:"text",value:"\n"}),n}function c(e){let t=0,n=e.charCodeAt(t);for(;9===n||32===n;)t++,n=e.charCodeAt(t);return e.slice(t)}export{a as createState,u 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 * @import {\n *   ElementContent as HastElementContent,\n *   Element as HastElement,\n *   Nodes as HastNodes,\n *   Properties as HastProperties,\n *   RootContent as HastRootContent,\n *   Text as HastText\n * } from 'hast'\n * @import {\n *   Definition as MdastDefinition,\n *   FootnoteDefinition as MdastFootnoteDefinition,\n *   Nodes as MdastNodes,\n *   Parents as MdastParents\n * } from 'mdast'\n * @import {VFile} from 'vfile'\n * @import {\n *   FootnoteBackContentTemplate,\n *   FootnoteBackLabelTemplate\n * } from './footer.js'\n */\n\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 | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\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 (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | 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 *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\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 (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(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 all(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 = state.one(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 = trimMarkdownSpaceStart(result.value)\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 = trimMarkdownSpaceStart(head.value)\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/**\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 {undefined}\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 {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\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 of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\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 {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\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: state.all(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 {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\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\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n"],"names":["own","hasOwnProperty","emptyOptions","createState","tree","options","settings","definitionById","Map","footnoteById","footnoteCounts","handlers","defaultHandlers","state","all","parent","values","nodes","children","index","length","result","one","type","Array","isArray","value","trimMarkdownSpaceStart","head","push","applyData","footnoteOrder","node","handle","call","passThrough","includes","shallow","structuredClone","unknownHandler","defaultUnknownHandler","patch","wrap","visit","map","id","String","identifier","toUpperCase","has","set","from","to","position","data","hName","hChildren","hProperties","tagName","properties","Object","assign","loose","code","charCodeAt","slice"],"mappings":"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"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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