@viswa-test/audit-log 0.0.1

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.tableCell=function(e,t){const l={type:"element",tagName:"td",properties:{},children:e.all(t)};return e.patch(t,l),e.applyData(t,l)};
+//# sourceMappingURL=table-cell.js.map

package/dist/cjs/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":["state","node","result","type","tagName","properties","children","all","patch","applyData"],"mappings":"sFAgBO,SAAmBA,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/cjs/node_modules/mdast-util-to-hast/lib/handlers/table-row.js

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

package/dist/cjs/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":["state","node","parent","siblings","children","undefined","tagName","indexOf","align","type","length","cellIndex","cells","cell","properties","alignValue","result","all","patch","applyData","push","wrap"],"mappings":"qFAkBO,SAAkBA,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/cjs/node_modules/mdast-util-to-hast/lib/handlers/table.js

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

package/dist/cjs/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":["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":"6IAkBO,SAAeA,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,EAAUA,WAACjB,EAAKU,SAAS,IACjCQ,EAAMC,EAAQA,SAACnB,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/cjs/node_modules/mdast-util-to-hast/lib/handlers/text.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../trim-lines/index.js");exports.text=function(t,r){const i={type:"text",value:e.trimLines(String(r.value))};return t.patch(r,i),t.applyData(r,i)};
+//# sourceMappingURL=text.js.map

package/dist/cjs/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":["state","node","result","type","value","trimLines","String","patch","applyData"],"mappings":"+HAkBO,SAAcA,EAAOC,GAE1B,MAAMC,EAAS,CAACC,KAAM,OAAQC,MAAOC,EAASA,UAACC,OAAOL,EAAKG,SAE3D,OADAJ,EAAMO,MAAMN,EAAMC,GACXF,EAAMQ,UAAUP,EAAMC,EAC/B"}

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.thematicBreak=function(e,t){const r={type:"element",tagName:"hr",properties:{},children:[]};return e.patch(t,r),e.applyData(t,r)};
+//# sourceMappingURL=thematic-break.js.map

package/dist/cjs/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":["state","node","result","type","tagName","properties","children","patch","applyData"],"mappings":"0FAgBO,SAAuBA,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/cjs/node_modules/mdast-util-to-hast/lib/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./footer.js"),t=require("./state.js");exports.toHast=function(r,o){const s=t.createState(r,o),i=s.one(r,void 0),n=e.footer(s),a=Array.isArray(i)?{type:"root",children:i}:i||{type:"root",children:[]};return n&&a.children.push({type:"text",value:"\n"},n),a};
+//# sourceMappingURL=index.js.map

package/dist/cjs/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":["tree","options","state","createState","node","one","undefined","foot","footer","result","Array","isArray","type","children","push","value"],"mappings":"wIAuFO,SAAgBA,EAAMC,GAC3B,MAAMC,EAAQC,EAAAA,YAAYH,EAAMC,GAC1BG,EAAOF,EAAMG,IAAIL,OAAMM,GACvBC,EAAOC,EAAMA,OAACN,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/cjs/node_modules/mdast-util-to-hast/lib/revert.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"revert.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/revert.js"],"sourcesContent":["/**\n * @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":["state","node","subtype","referenceType","suffix","label","identifier","type","value","alt","contents","all","head","unshift","tail","length","push"],"mappings":"mFAgBO,SAAgBA,EAAOC,GAC5B,MAAMC,EAAUD,EAAKE,cACrB,IAAIC,EAAS,IAQb,GANgB,cAAZF,EACFE,GAAU,KACW,SAAZF,IACTE,GAAU,KAAOH,EAAKI,OAASJ,EAAKK,YAAc,KAGlC,mBAAdL,EAAKM,KACP,MAAO,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/cjs/node_modules/mdast-util-to-hast/lib/state.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../@ungap/structured-clone/esm/index.js"),t=require("../../unist-util-visit/lib/index.js"),n=require("../../unist-util-position/lib/index.js"),i=require("./handlers/index.js");const r={}.hasOwnProperty,o={};function a(e,t){e.position&&(t.position=n.position(e))}function l(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.default(o)),"children"in i&&i.children&&null!=r&&(i.children=r)}return i}function s(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 p(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 u(e){let t=0,n=e.charCodeAt(t);for(;9===n||32===n;)t++,n=e.charCodeAt(t);return e.slice(t)}exports.createState=function(n,c){const d=c||o,h=new Map,f=new Map,y=new Map,v={...i.handlers,...d.handlers},x={all:function(e){const t=[];if("children"in e){const n=e.children;let i=-1;for(;++i<n.length;){const r=x.one(n[i],e);if(r){if(i&&"break"===n[i-1].type&&(Array.isArray(r)||"text"!==r.type||(r.value=u(r.value)),!Array.isArray(r)&&"element"===r.type)){const e=r.children[0];e&&"text"===e.type&&(e.value=u(e.value))}Array.isArray(r)?t.push(...r):t.push(r)}}}return t},applyData:l,definitionById:h,footnoteById:f,footnoteCounts:y,footnoteOrder:[],handlers:v,one:function(t,n){const i=t.type,o=x.handlers[i];if(r.call(x.handlers,i)&&o)return o(x,t,n);if(x.options.passThrough&&x.options.passThrough.includes(i)){if("children"in t){const{children:n,...i}=t,r=e.default(i);return r.children=x.all(t),r}return e.default(t)}return(x.options.unknownHandler||s)(x,t,n)},options:d,patch:a,wrap:p};return t.visit(n,function(e){if("definition"===e.type||"footnoteDefinition"===e.type){const t="definition"===e.type?h:f,n=String(e.identifier).toUpperCase();t.has(n)||t.set(n,e)}}),x},exports.wrap=p;
+//# sourceMappingURL=state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sources":["../../../../../node_modules/mdast-util-to-hast/lib/state.js"],"sourcesContent":["/**\n * @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","patch","from","to","position","applyData","result","data","hName","hChildren","hProperties","type","tagName","properties","children","Object","assign","structuredClone","defaultUnknownHandler","state","node","call","all","value","wrap","nodes","loose","index","push","length","trimMarkdownSpaceStart","code","charCodeAt","slice","tree","options","settings","definitionById","Map","footnoteById","footnoteCounts","handlers","defaultHandlers","parent","values","one","Array","isArray","head","footnoteOrder","handle","passThrough","includes","shallow","unknownHandler","visit","map","id","String","identifier","toUpperCase","has","set"],"mappings":"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"}

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

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

package/dist/cjs/node_modules/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","one","value","includeImageAlt","includeHtml","Boolean","node","type","alt","all","children","Array","isArray","values","result","index","length","join","options","settings"],"mappings":"oEAYA,MAAMA,EAAe,CAAE,EAuCvB,SAASC,EAAIC,EAAOC,EAAiBC,GACnC,GAqDF,SAAcF,GACZ,OAAOG,QAAQH,GAA0B,iBAAVA,EACjC,CAvDMI,CAAKJ,GAAQ,CACf,GAAI,UAAWA,EACb,MAAsB,SAAfA,EAAMK,MAAoBH,EAAmBF,EAAMA,MAAX,GAGjD,GAAIC,GAAmB,QAASD,GAASA,EAAMM,IAC7C,OAAON,EAAMM,IAGf,GAAI,aAAcN,EAChB,OAAOO,EAAIP,EAAMQ,SAAUP,EAAiBC,EAE/C,CAED,OAAIO,MAAMC,QAAQV,GACTO,EAAIP,EAAOC,EAAiBC,GAG9B,EACT,CAcA,SAASK,EAAII,EAAQV,EAAiBC,GAEpC,MAAMU,EAAS,GACf,IAAIC,GAAS,EAEb,OAASA,EAAQF,EAAOG,QACtBF,EAAOC,GAASd,EAAIY,EAAOE,GAAQZ,EAAiBC,GAGtD,OAAOU,EAAOG,KAAK,GACrB,kBApEO,SAAkBf,EAAOgB,GAC9B,MAAMC,EAAWD,GAAWlB,EAQ5B,OAAOC,EAAIC,EAN2B,kBAA7BiB,EAAShB,iBACZgB,EAAShB,gBAGmB,kBAAzBgB,EAASf,aAA4Be,EAASf,YAGzD"}

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

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

package/dist/cjs/node_modules/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"],"mappings":"63CAQY,MAACA,EAAW,CACtB,GAAMC,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMA,EAAIA,KACV,GAAMC,EAAUA,YAILC,EAAiB,CAC5B,GAAMC,EAAUA,YAILC,EAAc,CACzB,EAAE,GAAIC,EAAYA,aAClB,EAAE,GAAIA,EAAYA,aAClB,GAAMA,EAAYA,cAIPC,EAAO,CAClB,GAAMC,EAAUA,WAChB,GAAMC,EAAaA,cACnB,GAAM,CAACC,EAAeA,gBAAED,iBACxB,GAAME,EAAQA,SACd,GAAMD,EAAeA,gBACrB,GAAMD,EAAaA,cACnB,GAAMG,EAAUA,WAChB,IAAOA,EAAUA,YAINC,EAAS,CACpB,GAAMC,EAAkBA,mBACxB,GAAMC,EAAeA,iBAIVC,EAAO,CAClB,EAAE,GAAIC,EAAUA,WAChB,EAAE,GAAIA,EAAUA,WAChB,EAAE,GAAIA,EAAUA,WAChB,GAAMC,EAAeA,gBACrB,GAAMJ,EAAkBA,mBACxB,GAAMK,EAASA,UACf,GAAM,CAACC,EAAQA,SAAEC,YACjB,GAAMC,EAAcA,eACpB,GAAM,CAACC,EAAeA,gBAAER,mBACxB,GAAMS,EAAQA,SACd,GAAML,EAASA,UACf,GAAMM,EAAQA,UAIHC,EAAa,CACxBC,KAAM,CAACR,EAASA,UAAES,sCAIY,CAC9BD,KAAM,CAAC,GAAI,8CAIU,CACrBA,KAAM"}

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

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

package/dist/cjs/node_modules/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":["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/cjs/node_modules/micromark/lib/initialize/content.js

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

package/dist/cjs/node_modules/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":"uLAaY,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,EAAAA,mBAAmBX,IACrBP,EAAQQ,QAAQD,GAChBP,EAAQU,KAAK,aACNE,IAITZ,EAAQQ,QAAQD,GACTU,EACR,CACH"}

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

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

package/dist/cjs/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/cjs/node_modules/micromark/lib/initialize/flow.js

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

package/dist/cjs/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":"mdAaY,MAACA,EAAO,CAClBC,SASF,SAAwBC,GACtB,MAAMC,EAAOC,KACPC,EAAUH,EAAQI,QAExBC,EAAAA,UAMA,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,EAAYA,aAAChB,EAASA,EAAQI,QAAQF,KAAKU,OAAOC,WAAWf,KAAMiB,EAAgBf,EAAQI,QAAQa,EAAOA,QAAEF,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"}

package/dist/cjs/node_modules/micromark/lib/initialize/text.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={resolveAll:i()},t=r("string"),n=r("text");function r(e){return{resolveAll:i("text"===e?o:void 0),tokenize:function(t){const n=this,r=this.parser.constructs[e],i=t.attempt(r,o,s);return o;function o(e){return l(e)?i(e):s(e)}function s(e){if(null!==e)return t.enter("data"),t.consume(e),f;t.consume(e)}function f(e){return l(e)?(t.exit("data"),i(e)):(t.consume(e),f)}function l(e){if(null===e)return!0;const t=r[e];let i=-1;if(t)for(;++i<t.length;){const e=t[i];if(!e.previous||e.previous.call(n,n.previous))return!0}return!1}}}}function i(e){return function(t,n){let r,i=-1;for(;++i<=t.length;)void 0===r?t[i]&&"data"===t[i][1].type&&(r=i,i++):t[i]&&"data"===t[i][1].type||(i!==r+2&&(t[r][1].end=t[i-1][1].end,t.splice(r+2,i-r-2),i=r+2),r=void 0);return e?e(t,n):t}}function o(e,t){let n=0;for(;++n<=e.length;)if((n===e.length||"lineEnding"===e[n][1].type)&&"data"===e[n-1][1].type){const r=e[n-1][1],i=t.sliceStream(r);let o,s=i.length,f=-1,l=0;for(;s--;){const e=i[s];if("string"==typeof e){for(f=e.length;32===e.charCodeAt(f-1);)l++,f--;if(f)break;f=-1}else if(-2===e)o=!0,l++;else if(-1!==e){s++;break}}if(t._contentTypeTextTrailing&&n===e.length&&(l=0),l){const i={type:n===e.length||o||l<2?"lineSuffix":"hardBreakTrailing",start:{_bufferIndex:s?f:r.start._bufferIndex+f,_index:r.start._index+s,line:r.end.line,column:r.end.column-l,offset:r.end.offset-l},end:{...r.end}};r.end={...i.start},r.start.offset===r.end.offset?Object.assign(r,i):(e.splice(n,0,["enter",i,t],["exit",i,t]),n+=2)}n++}return e}exports.resolver=e,exports.string=t,exports.text=n;
+//# sourceMappingURL=text.js.map

package/dist/cjs/node_modules/micromark/lib/initialize/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sources":["../../../../../../node_modules/micromark/lib/initialize/text.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      // Allow final trailing whitespace.\n      if (context._contentTypeTextTrailing && eventIndex === events.length) {\n        size = 0;\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}"],"names":["resolver","resolveAll","createResolver","string","initializeFactory","text","field","resolveAllLineSuffixes","undefined","tokenize","effects","self","this","constructs","parser","attempt","start","notText","code","atBreak","enter","consume","data","exit","list","index","length","item","previous","call","extraResolver","events","context","type","end","splice","eventIndex","chunks","sliceStream","tabs","bufferIndex","size","chunk","charCodeAt","_contentTypeTextTrailing","token","_bufferIndex","_index","line","column","offset","Object","assign"],"mappings":"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"}

package/dist/cjs/node_modules/micromark/lib/parse.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-util-combine-extensions/index.js"),t=require("./initialize/content.js"),i=require("./initialize/document.js"),n=require("./initialize/flow.js"),r=require("./initialize/text.js"),o=require("./constructs.js"),s=require("./create-tokenizer.js");exports.parse=function(u){const c=u||{},a={constructs:e.combineExtensions([o,...c.extensions||[]]),content:l(t.content),defined:[],document:l(i.document),flow:l(n.flow),lazy:{},string:l(r.string),text:l(r.text)};return a;function l(e){return function(t){return s.createTokenizer(a,e,t)}}};
+//# sourceMappingURL=parse.js.map

package/dist/cjs/node_modules/micromark/lib/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sources":["../../../../../node_modules/micromark/lib/parse.js"],"sourcesContent":["/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}"],"names":["options","settings","parser","constructs","combineExtensions","defaultConstructs","extensions","content","create","defined","document","flow","lazy","string","text","initial","from","createTokenizer"],"mappings":"mWAwBO,SAAeA,GACpB,MAAMC,EAAWD,GAAW,GAKtBE,EAAS,CACjBC,WAJEC,EAAiBA,kBAAC,CAACC,KAAuBJ,EAASK,YAAc,KAK/DC,QAASC,EAAOD,WAChBE,QAAS,GACTC,SAAUF,EAAOE,YACjBC,KAAMH,EAAOG,QACbC,KAAM,CAAE,EACRC,OAAQL,EAAOK,UACfC,KAAMN,EAAOM,SAEf,OAAOZ,EAQP,SAASM,EAAOO,GACd,OAEA,SAAiBC,GACf,OAAOC,kBAAgBf,EAAQa,EAASC,EACzC,CACF,CACH"}

package/dist/cjs/node_modules/micromark/lib/postprocess.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-util-subtokenize/index.js");exports.postprocess=function(r){for(;!e.subtokenize(r););return r};
+//# sourceMappingURL=postprocess.js.map

package/dist/cjs/node_modules/micromark/lib/postprocess.js.map

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

package/dist/cjs/node_modules/micromark/lib/preprocess.js

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

package/dist/cjs/node_modules/micromark/lib/preprocess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess.js","sources":["../../../../../node_modules/micromark/lib/preprocess.js"],"sourcesContent":["/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}"],"names":["search","atCarriageReturn","column","buffer","start","value","encoding","end","chunks","match","next","startPosition","endPosition","code","toString","TextDecoder","undefined","decode","charCodeAt","length","lastIndex","exec","index","slice","push","Math","ceil"],"mappings":"oEAiBA,MAAMA,EAAS,iCAMR,WACL,IAKIC,EALAC,EAAS,EACTC,EAAS,GAETC,GAAQ,EAGZ,OAIA,SAAsBC,EAAOC,EAAUC,GAErC,MAAMC,EAAS,GAEf,IAAIC,EAEAC,EAEAC,EAEAC,EAEAC,EACJR,EAAQF,GAA2B,iBAAVE,EAAqBA,EAAMS,WAAa,IAAIC,YAAYT,QAAYU,GAAWC,OAAOZ,IAC/GM,EAAgB,EAChBR,EAAS,GACLC,IAE0B,QAAxBC,EAAMa,WAAW,IACnBP,IAEFP,OAAQY,GAEV,KAAOL,EAAgBN,EAAMc,QAAQ,CAKnC,GAJAnB,EAAOoB,UAAYT,EACnBF,EAAQT,EAAOqB,KAAKhB,GACpBO,EAAcH,QAAyBO,IAAhBP,EAAMa,MAAsBb,EAAMa,MAAQjB,EAAMc,OACvEN,EAAOR,EAAMa,WAAWN,IACnBH,EAAO,CACVN,EAASE,EAAMkB,MAAMZ,GACrB,KACD,CACD,GAAa,KAATE,GAAeF,IAAkBC,GAAeX,EAClDO,EAAOgB,MAAM,GACbvB,OAAmBe,OAUnB,OARIf,IACFO,EAAOgB,MAAM,GACbvB,OAAmBe,GAEjBL,EAAgBC,IAClBJ,EAAOgB,KAAKnB,EAAMkB,MAAMZ,EAAeC,IACvCV,GAAUU,EAAcD,GAElBE,GACN,KAAK,EAEDL,EAAOgB,KAAK,OACZtB,IACA,MAEJ,KAAK,EAID,IAFAQ,EAA+B,EAAxBe,KAAKC,KAAKxB,EAAS,GAC1BM,EAAOgB,MAAM,GACNtB,IAAWQ,GAAMF,EAAOgB,MAAM,GACrC,MAEJ,KAAK,GAEDhB,EAAOgB,MAAM,GACbtB,EAAS,EACT,MAEJ,QAEID,GAAmB,EACnBC,EAAS,EAIjBS,EAAgBC,EAAc,CAC/B,CACGL,IACEN,GAAkBO,EAAOgB,MAAM,GAC/BrB,GAAQK,EAAOgB,KAAKrB,GACxBK,EAAOgB,KAAK,OAEd,OAAOhB,CACR,CACH"}

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-util-chunked/index.js"),t=require("../../micromark-util-classify-character/index.js"),n=require("../../micromark-util-resolve-all/index.js");const s={name:"attention",resolveAll:function(t,s){let o,i,a,c,f,u,l,d,p=-1;for(;++p<t.length;)if("enter"===t[p][0]&&"attentionSequence"===t[p][1].type&&t[p][1]._close)for(o=p;o--;)if("exit"===t[o][0]&&"attentionSequence"===t[o][1].type&&t[o][1]._open&&s.sliceSerialize(t[o][1]).charCodeAt(0)===s.sliceSerialize(t[p][1]).charCodeAt(0)){if((t[o][1]._close||t[p][1]._open)&&(t[p][1].end.offset-t[p][1].start.offset)%3&&!((t[o][1].end.offset-t[o][1].start.offset+t[p][1].end.offset-t[p][1].start.offset)%3))continue;u=t[o][1].end.offset-t[o][1].start.offset>1&&t[p][1].end.offset-t[p][1].start.offset>1?2:1;const h={...t[o][1].end},x={...t[p][1].start};r(h,-u),r(x,u),c={type:u>1?"strongSequence":"emphasisSequence",start:h,end:{...t[o][1].end}},f={type:u>1?"strongSequence":"emphasisSequence",start:{...t[p][1].start},end:x},a={type:u>1?"strongText":"emphasisText",start:{...t[o][1].end},end:{...t[p][1].start}},i={type:u>1?"strong":"emphasis",start:{...c.start},end:{...f.end}},t[o][1].end={...c.start},t[p][1].start={...f.end},l=[],t[o][1].end.offset-t[o][1].start.offset&&(l=e.push(l,[["enter",t[o][1],s],["exit",t[o][1],s]])),l=e.push(l,[["enter",i,s],["enter",c,s],["exit",c,s],["enter",a,s]]),l=e.push(l,n.resolveAll(s.parser.constructs.insideSpan.null,t.slice(o+1,p),s)),l=e.push(l,[["exit",a,s],["enter",f,s],["exit",f,s],["exit",i,s]]),t[p][1].end.offset-t[p][1].start.offset?(d=2,l=e.push(l,[["enter",t[p][1],s],["exit",t[p][1],s]])):d=0,e.splice(t,o-1,p-o+3,l),p=o+l.length-d-2;break}p=-1;for(;++p<t.length;)"attentionSequence"===t[p][1].type&&(t[p][1].type="data");return t},tokenize:function(e,n){const s=this.parser.constructs.attentionMarkers.null,r=this.previous,o=t.classifyCharacter(r);let i;return function(t){return i=t,e.enter("attentionSequence"),a(t)};function a(c){if(c===i)return e.consume(c),a;const f=e.exit("attentionSequence"),u=t.classifyCharacter(c),l=!u||2===u&&o||s.includes(c),d=!o||2===o&&u||s.includes(r);return f._open=Boolean(42===i?l:l&&(o||!d)),f._close=Boolean(42===i?d:d&&(u||!l)),n(c)}}};function r(e,t){e.column+=t,e.offset+=t,e._bufferIndex+=t}exports.attention=s;
+//# sourceMappingURL=attention.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/attention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attention.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/attention.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}"],"names":["attention","name","resolveAll","events","context","open","group","text","openingSequence","closingSequence","use","nextEvents","offset","index","length","type","_close","_open","sliceSerialize","charCodeAt","end","start","movePoint","push","parser","constructs","insideSpan","null","slice","splice","tokenize","effects","ok","attentionMarkers","this","previous","before","classifyCharacter","marker","code","enter","inside","consume","token","exit","after","includes","close","Boolean","point","column","_bufferIndex"],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=require("../../micromark-util-character/index.js");const e={name:"autolink",tokenize:function(e,t,i){let r=0;return function(n){return e.enter("autolink"),e.enter("autolinkMarker"),e.consume(n),e.exit("autolinkMarker"),e.enter("autolinkProtocol"),u};function u(t){return n.asciiAlpha(t)?(e.consume(t),o):64===t?i(t):l(t)}function o(e){return 43===e||45===e||46===e||n.asciiAlphanumeric(e)?(r=1,c(e)):l(e)}function c(t){return 58===t?(e.consume(t),r=0,a):(43===t||45===t||46===t||n.asciiAlphanumeric(t))&&r++<32?(e.consume(t),c):(r=0,l(t))}function a(r){return 62===r?(e.exit("autolinkProtocol"),e.enter("autolinkMarker"),e.consume(r),e.exit("autolinkMarker"),e.exit("autolink"),t):null===r||32===r||60===r||n.asciiControl(r)?i(r):(e.consume(r),a)}function l(t){return 64===t?(e.consume(t),s):n.asciiAtext(t)?(e.consume(t),l):i(t)}function s(e){return n.asciiAlphanumeric(e)?k(e):i(e)}function k(n){return 46===n?(e.consume(n),r=0,s):62===n?(e.exit("autolinkProtocol").type="autolinkEmail",e.enter("autolinkMarker"),e.consume(n),e.exit("autolinkMarker"),e.exit("autolink"),t):m(n)}function m(t){if((45===t||n.asciiAlphanumeric(t))&&r++<63){const n=45===t?m:k;return e.consume(t),n}return i(t)}}};exports.autolink=e;
+//# sourceMappingURL=autolink.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/autolink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autolink.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/autolink.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"autolink\");\n    effects.enter(\"autolinkMarker\");\n    effects.consume(code);\n    effects.exit(\"autolinkMarker\");\n    effects.enter(\"autolinkProtocol\");\n    return open;\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}"],"names":["autolink","name","tokenize","effects","ok","nok","size","code","enter","consume","exit","open","asciiAlpha","schemeOrEmailAtext","emailAtext","asciiAlphanumeric","schemeInsideOrEmailAtext","urlInside","asciiControl","emailAtSignOrDot","asciiAtext","emailLabel","type","emailValue","next"],"mappings":"6HAWY,MAACA,EAAW,CACtBC,KAAM,WACNC,SAQF,SAA0BC,EAASC,EAAIC,GACrC,IAAIC,EAAO,EACX,OAcA,SAAeC,GAMb,OALAJ,EAAQK,MAAM,YACdL,EAAQK,MAAM,kBACdL,EAAQM,QAAQF,GAChBJ,EAAQO,KAAK,kBACbP,EAAQK,MAAM,oBACPG,CACR,EAcD,SAASA,EAAKJ,GACZ,OAAIK,EAAAA,WAAWL,IACbJ,EAAQM,QAAQF,GACTM,GAEI,KAATN,EACKF,EAAIE,GAENO,EAAWP,EACnB,CAcD,SAASM,EAAmBN,GAE1B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAeQ,oBAAkBR,IAEjED,EAAO,EACAU,EAAyBT,IAE3BO,EAAWP,EACnB,CAcD,SAASS,EAAyBT,GAChC,OAAa,KAATA,GACFJ,EAAQM,QAAQF,GAChBD,EAAO,EACAW,IAIK,KAATV,GAAwB,KAATA,GAAwB,KAATA,GAAeQ,EAAiBA,kBAACR,KAAUD,IAAS,IACrFH,EAAQM,QAAQF,GACTS,IAETV,EAAO,EACAQ,EAAWP,GACnB,CAYD,SAASU,EAAUV,GACjB,OAAa,KAATA,GACFJ,EAAQO,KAAK,oBACbP,EAAQK,MAAM,kBACdL,EAAQM,QAAQF,GAChBJ,EAAQO,KAAK,kBACbP,EAAQO,KAAK,YACNN,GAII,OAATG,GAA0B,KAATA,GAAwB,KAATA,GAAeW,eAAaX,GACvDF,EAAIE,IAEbJ,EAAQM,QAAQF,GACTU,EACR,CAYD,SAASH,EAAWP,GAClB,OAAa,KAATA,GACFJ,EAAQM,QAAQF,GACTY,GAELC,EAAAA,WAAWb,IACbJ,EAAQM,QAAQF,GACTO,GAEFT,EAAIE,EACZ,CAYD,SAASY,EAAiBZ,GACxB,OAAOQ,EAAAA,kBAAkBR,GAAQc,EAAWd,GAAQF,EAAIE,EACzD,CAYD,SAASc,EAAWd,GAClB,OAAa,KAATA,GACFJ,EAAQM,QAAQF,GAChBD,EAAO,EACAa,GAEI,KAATZ,GAEFJ,EAAQO,KAAK,oBAAoBY,KAAO,gBACxCnB,EAAQK,MAAM,kBACdL,EAAQM,QAAQF,GAChBJ,EAAQO,KAAK,kBACbP,EAAQO,KAAK,YACNN,GAEFmB,EAAWhB,EACnB,CAcD,SAASgB,EAAWhB,GAElB,IAAc,KAATA,GAAeQ,EAAAA,kBAAkBR,KAAUD,IAAS,GAAI,CAC3D,MAAMkB,EAAgB,KAATjB,EAAcgB,EAAaF,EAExC,OADAlB,EAAQM,QAAQF,GACTiB,CACR,CACD,OAAOnB,EAAIE,EACZ,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/blank-line.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),r=require("../../micromark-util-character/index.js");const n={partial:!0,tokenize:function(n,i,t){return function(i){return r.markdownSpace(i)?e.factorySpace(n,a,"linePrefix")(i):a(i)};function a(e){return null===e||r.markdownLineEnding(e)?i(e):t(e)}}};exports.blankLine=n;
+//# sourceMappingURL=blank-line.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blank-line.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/blank-line.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["blankLine","partial","tokenize","effects","ok","nok","code","markdownSpace","factorySpace","after","markdownLineEnding"],"mappings":"iLAYY,MAACA,EAAY,CACvBC,SAAS,EACTC,SAQF,SAA2BC,EAASC,EAAIC,GACtC,OAgBA,SAAeC,GACb,OAAOC,gBAAcD,GAAQE,EAAAA,aAAaL,EAASM,EAAO,aAA7BD,CAA2CF,GAAQG,EAAMH,EACvF,EAgBD,SAASG,EAAMH,GACb,OAAgB,OAATA,GAAiBI,EAAAA,mBAAmBJ,GAAQF,EAAGE,GAAQD,EAAIC,EACnE,CACH"}

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-factory-space/index.js"),t=require("../../micromark-util-character/index.js");const o={continuation:{tokenize:function(n,r,c){const i=this;return function(o){if(t.markdownSpace(o))return e.factorySpace(n,u,"linePrefix",i.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(o);return u(o)};function u(e){return n.attempt(o,r,c)(e)}}},exit:function(e){e.exit("blockQuote")},name:"blockQuote",tokenize:function(e,o,n){const r=this;return function(t){if(62===t){const o=r.containerState;return o.open||(e.enter("blockQuote",{_container:!0}),o.open=!0),e.enter("blockQuotePrefix"),e.enter("blockQuoteMarker"),e.consume(t),e.exit("blockQuoteMarker"),c}return n(t)};function c(n){return t.markdownSpace(n)?(e.enter("blockQuotePrefixWhitespace"),e.consume(n),e.exit("blockQuotePrefixWhitespace"),e.exit("blockQuotePrefix"),o):(e.exit("blockQuotePrefix"),o(n))}}};exports.blockQuote=o;
+//# sourceMappingURL=block-quote.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block-quote.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/block-quote.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"blockQuotePrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"blockQuotePrefixWhitespace\");\n      effects.exit(\"blockQuotePrefix\");\n      return ok;\n    }\n    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}"],"names":["blockQuote","continuation","tokenize","effects","ok","nok","self","this","code","markdownSpace","factorySpace","contBefore","parser","constructs","disable","null","includes","undefined","attempt","exit","name","state","containerState","open","enter","_container","consume","after"],"mappings":"iLAaY,MAACA,EAAa,CACxBC,aAAc,CACZC,SAgFJ,SAAwCC,EAASC,EAAIC,GACnD,MAAMC,EAAOC,KACb,OAeA,SAAmBC,GACjB,GAAIC,EAAAA,cAAcD,GAGhB,OAAOE,EAAAA,aAAaP,EAASQ,EAAY,aAAcL,EAAKM,OAAOC,WAAWC,QAAQC,KAAKC,SAAS,qBAAkBC,EAAY,EAA3HP,CAA8HF,GAEvI,OAAOG,EAAWH,EACnB,EAeD,SAASG,EAAWH,GAClB,OAAOL,EAAQe,QAAQlB,EAAYI,EAAIC,EAAhCF,CAAqCK,EAC7C,CACH,GAxHEW,KA2HF,SAAchB,GACZA,EAAQgB,KAAK,aACf,EA5HEC,KAAM,aACNlB,SAQF,SAAiCC,EAASC,EAAIC,GAC5C,MAAMC,EAAOC,KACb,OAYA,SAAeC,GACb,GAAa,KAATA,EAAa,CACf,MAAMa,EAAQf,EAAKgB,eAWnB,OAVKD,EAAME,OACTpB,EAAQqB,MAAM,aAAc,CAC1BC,YAAY,IAEdJ,EAAME,MAAO,GAEfpB,EAAQqB,MAAM,oBACdrB,EAAQqB,MAAM,oBACdrB,EAAQuB,QAAQlB,GAChBL,EAAQgB,KAAK,oBACNQ,CACR,CACD,OAAOtB,EAAIG,EACZ,EAYD,SAASmB,EAAMnB,GACb,OAAIC,EAAAA,cAAcD,IAChBL,EAAQqB,MAAM,8BACdrB,EAAQuB,QAAQlB,GAChBL,EAAQgB,KAAK,8BACbhB,EAAQgB,KAAK,oBACNf,IAETD,EAAQgB,KAAK,oBACNf,EAAGI,GACX,CACH"}

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../micromark-util-character/index.js");const r={name:"characterEscape",tokenize:function(r,c,a){return function(e){return r.enter("characterEscape"),r.enter("escapeMarker"),r.consume(e),r.exit("escapeMarker"),t};function t(t){return e.asciiPunctuation(t)?(r.enter("characterEscapeValue"),r.consume(t),r.exit("characterEscapeValue"),r.exit("characterEscape"),c):a(t)}}};exports.characterEscape=r;
+//# sourceMappingURL=character-escape.js.map

package/dist/cjs/node_modules/micromark-core-commonmark/lib/character-escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-escape.js","sources":["../../../../../node_modules/micromark-core-commonmark/lib/character-escape.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter(\"characterEscapeValue\");\n      effects.consume(code);\n      effects.exit(\"characterEscapeValue\");\n      effects.exit(\"characterEscape\");\n      return ok;\n    }\n    return nok(code);\n  }\n}"],"names":["characterEscape","name","tokenize","effects","ok","nok","code","enter","consume","exit","inside","asciiPunctuation"],"mappings":"6HAWY,MAACA,EAAkB,CAC7BC,KAAM,kBACNC,SAQF,SAAiCC,EAASC,EAAIC,GAC5C,OAYA,SAAeC,GAKb,OAJAH,EAAQI,MAAM,mBACdJ,EAAQI,MAAM,gBACdJ,EAAQK,QAAQF,GAChBH,EAAQM,KAAK,gBACNC,CACR,EAYD,SAASA,EAAOJ,GAEd,OAAIK,EAAAA,iBAAiBL,IACnBH,EAAQI,MAAM,wBACdJ,EAAQK,QAAQF,GAChBH,EAAQM,KAAK,wBACbN,EAAQM,KAAK,mBACNL,GAEFC,EAAIC,EACZ,CACH"}

package/dist/cjs/node_modules/micromark-core-commonmark/lib/character-reference.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../decode-named-character-reference/index.dom.js"),r=require("../../micromark-util-character/index.js");const c={name:"characterReference",tokenize:function(c,a,t){const n=this;let i,u,f=0;return function(e){return c.enter("characterReference"),c.enter("characterReferenceMarker"),c.consume(e),c.exit("characterReferenceMarker"),h};function h(e){return 35===e?(c.enter("characterReferenceMarkerNumeric"),c.consume(e),c.exit("characterReferenceMarkerNumeric"),o):(c.enter("characterReferenceValue"),i=31,u=r.asciiAlphanumeric,s(e))}function o(e){return 88===e||120===e?(c.enter("characterReferenceMarkerHexadecimal"),c.consume(e),c.exit("characterReferenceMarkerHexadecimal"),c.enter("characterReferenceValue"),i=6,u=r.asciiHexDigit,s):(c.enter("characterReferenceValue"),i=7,u=r.asciiDigit,s(e))}function s(h){if(59===h&&f){const i=c.exit("characterReferenceValue");return u!==r.asciiAlphanumeric||e.decodeNamedCharacterReference(n.sliceSerialize(i))?(c.enter("characterReferenceMarker"),c.consume(h),c.exit("characterReferenceMarker"),c.exit("characterReference"),a):t(h)}return u(h)&&f++<i?(c.consume(h),s):t(h)}}};exports.characterReference=c;
+//# sourceMappingURL=character-reference.js.map