@easyv/biz-components 0.0.1

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/list-item.es.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-item.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/list-item.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === null || spread === undefined\n    ? node.children.length > 1\n    : spread\n}\n"],"names":["listItem","state","node","parent","results","loose","listLoose","listItemLoose","properties","children","head","paragraph","index","child","tail","result","spread"],"mappings":"AAwBO,SAASA,EAASC,GAAOC,GAAMC,GAAQ;AAC5C,QAAMC,IAAUH,EAAM,IAAIC,CAAI,GACxBG,IAAQF,IAASG,EAAUH,CAAM,IAAII,EAAcL,CAAI,GAEvDM,IAAa,CAAA,GAEbC,IAAW,CAAA;AAEjB,MAAI,OAAOP,EAAK,WAAY,WAAW;AACrC,UAAMQ,IAAON,EAAQ,CAAC;AAEtB,QAAIO;AAEJ,IAAID,KAAQA,EAAK,SAAS,aAAaA,EAAK,YAAY,MACtDC,IAAYD,KAEZC,IAAY,EAAC,MAAM,WAAW,SAAS,KAAK,YAAY,IAAI,UAAU,CAAE,EAAA,GACxEP,EAAQ,QAAQO,CAAS,IAGvBA,EAAU,SAAS,SAAS,KAC9BA,EAAU,SAAS,QAAQ,EAAC,MAAM,QAAQ,OAAO,IAAG,CAAC,GAGvDA,EAAU,SAAS,QAAQ;AAAA,MACzB,MAAM;AAAA,MACN,SAAS;AAAA,MACT,YAAY,EAAC,MAAM,YAAY,SAAST,EAAK,SAAS,UAAU,GAAI;AAAA,MACpE,UAAU,CAAA;AAAA,IACX,CAAA,GAIDM,EAAW,YAAY,CAAC,gBAAgB;AAAA,EAC5C;AAEE,MAAII,IAAQ;AAEZ,SAAO,EAAEA,IAAQR,EAAQ,UAAQ;AAC/B,UAAMS,IAAQT,EAAQQ,CAAK;AAG3B,KACEP,KACAO,MAAU,KACVC,EAAM,SAAS,aACfA,EAAM,YAAY,QAElBJ,EAAS,KAAK,EAAC,MAAM,QAAQ,OAAO;AAAA,EAAI,CAAC,GAGvCI,EAAM,SAAS,aAAaA,EAAM,YAAY,OAAO,CAACR,IACxDI,EAAS,KAAK,GAAGI,EAAM,QAAQ,IAE/BJ,EAAS,KAAKI,CAAK;AAAA,EAEzB;AAEE,QAAMC,IAAOV,EAAQA,EAAQ,SAAS,CAAC;AAGvC,EAAIU,MAAST,KAASS,EAAK,SAAS,aAAaA,EAAK,YAAY,QAChEL,EAAS,KAAK,EAAC,MAAM,QAAQ,OAAO;AAAA,EAAI,CAAC;AAI3C,QAAMM,IAAS,EAAC,MAAM,WAAW,SAAS,MAAM,YAAAP,GAAY,UAAAC,EAAQ;AACpE,SAAAR,EAAM,MAAMC,GAAMa,CAAM,GACjBd,EAAM,UAAUC,GAAMa,CAAM;AACrC;AAMA,SAAST,EAAUJ,GAAM;AACvB,MAAIG,IAAQ;AACZ,MAAIH,EAAK,SAAS,QAAQ;AACxB,IAAAG,IAAQH,EAAK,UAAU;AACvB,UAAMO,IAAWP,EAAK;AACtB,QAAIU,IAAQ;AAEZ,WAAO,CAACP,KAAS,EAAEO,IAAQH,EAAS;AAClC,MAAAJ,IAAQE,EAAcE,EAASG,CAAK,CAAC;AAAA,EAE3C;AAEE,SAAOP;AACT;AAMA,SAASE,EAAcL,GAAM;AAC3B,QAAMc,IAASd,EAAK;AAEpB,SAAOc,KACHd,EAAK,SAAS,SAAS;AAE7B;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/list.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/list.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/list.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["list","state","node","properties","results","index","child","result"],"mappings":"AAoBO,SAASA,EAAKC,GAAOC,GAAM;AAEhC,QAAMC,IAAa,CAAA,GACbC,IAAUH,EAAM,IAAIC,CAAI;AAC9B,MAAIG,IAAQ;AAOZ,OALI,OAAOH,EAAK,SAAU,YAAYA,EAAK,UAAU,MACnDC,EAAW,QAAQD,EAAK,QAInB,EAAEG,IAAQD,EAAQ,UAAQ;AAC/B,UAAME,IAAQF,EAAQC,CAAK;AAE3B,QACEC,EAAM,SAAS,aACfA,EAAM,YAAY,QAClBA,EAAM,cACN,MAAM,QAAQA,EAAM,WAAW,SAAS,KACxCA,EAAM,WAAW,UAAU,SAAS,gBAAgB,GACpD;AACA,MAAAH,EAAW,YAAY,CAAC,oBAAoB;AAC5C;AAAA,IACN;AAAA,EACA;AAGE,QAAMI,IAAS;AAAA,IACb,MAAM;AAAA,IACN,SAASL,EAAK,UAAU,OAAO;AAAA,IAC/B,YAAAC;AAAA,IACA,UAAUF,EAAM,KAAKG,GAAS,EAAI;AAAA,EACtC;AACE,SAAAH,EAAM,MAAMC,GAAMK,CAAM,GACjBN,EAAM,UAAUC,GAAMK,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/paragraph.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/paragraph.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/paragraph.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["paragraph","state","node","result"],"mappings":"AAmBO,SAASA,EAAUC,GAAOC,GAAM;AAErC,QAAMC,IAAS;AAAA,IACb,MAAM;AAAA,IACN,SAAS;AAAA,IACT,YAAY,CAAE;AAAA,IACd,UAAUF,EAAM,IAAIC,CAAI;AAAA,EAC5B;AACE,SAAAD,EAAM,MAAMC,GAAMC,CAAM,GACjBF,EAAM,UAAUC,GAAMC,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/root.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/root.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/root.js"],"sourcesContent":["/**\n * @typedef {import('hast').Parents} HastParents\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["root","state","node","result"],"mappings":"AAoBO,SAASA,EAAKC,GAAOC,GAAM;AAEhC,QAAMC,IAAS,EAAC,MAAM,QAAQ,UAAUF,EAAM,KAAKA,EAAM,IAAIC,CAAI,CAAC,EAAC;AACnE,SAAAD,EAAM,MAAMC,GAAMC,CAAM,GACjBF,EAAM,UAAUC,GAAMC,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/strong.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/strong.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/strong.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["strong","state","node","result"],"mappings":"AAmBO,SAASA,EAAOC,GAAOC,GAAM;AAElC,QAAMC,IAAS;AAAA,IACb,MAAM;AAAA,IACN,SAAS;AAAA,IACT,YAAY,CAAE;AAAA,IACd,UAAUF,EAAM,IAAIC,CAAI;AAAA,EAC5B;AACE,SAAAD,EAAM,MAAMC,GAAMC,CAAM,GACjBF,EAAM,UAAUC,GAAMC,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/table-cell.es.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-cell.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/table-cell.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["tableCell","state","node","result"],"mappings":"AAmBO,SAASA,EAAUC,GAAOC,GAAM;AAIrC,QAAMC,IAAS;AAAA,IACb,MAAM;AAAA,IACN,SAAS;AAAA;AAAA,IACT,YAAY,CAAE;AAAA,IACd,UAAUF,EAAM,IAAIC,CAAI;AAAA,EAC5B;AACE,SAAAD,EAAM,MAAMC,GAAMC,CAAM,GACjBF,EAAM,UAAUC,GAAMC,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/table-row.es.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-row.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/table-row.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["tableRow","state","node","parent","siblings","tagName","align","length","cellIndex","cells","cell","properties","alignValue","result"],"mappings":"AAwBO,SAASA,EAASC,GAAOC,GAAMC,GAAQ;AAC5C,QAAMC,IAAWD,IAASA,EAAO,WAAW,QAGtCE,KADWD,IAAWA,EAAS,QAAQF,CAAI,IAAI,OACxB,IAAI,OAAO,MAElCI,IAAQH,KAAUA,EAAO,SAAS,UAAUA,EAAO,QAAQ,QAC3DI,IAASD,IAAQA,EAAM,SAASJ,EAAK,SAAS;AACpD,MAAIM,IAAY;AAEhB,QAAMC,IAAQ,CAAA;AAEd,SAAO,EAAED,IAAYD,KAAQ;AAE3B,UAAMG,IAAOR,EAAK,SAASM,CAAS,GAE9BG,IAAa,CAAA,GACbC,IAAaN,IAAQA,EAAME,CAAS,IAAI;AAE9C,IAAII,MACFD,EAAW,QAAQC;AAIrB,QAAIC,IAAS,EAAC,MAAM,WAAW,SAAAR,GAAS,YAAAM,GAAY,UAAU,CAAE,EAAA;AAEhE,IAAID,MACFG,EAAO,WAAWZ,EAAM,IAAIS,CAAI,GAChCT,EAAM,MAAMS,GAAMG,CAAM,GACxBA,IAASZ,EAAM,UAAUS,GAAMG,CAAM,IAGvCJ,EAAM,KAAKI,CAAM;AAAA,EACrB;AAGE,QAAMA,IAAS;AAAA,IACb,MAAM;AAAA,IACN,SAAS;AAAA,IACT,YAAY,CAAE;AAAA,IACd,UAAUZ,EAAM,KAAKQ,GAAO,EAAI;AAAA,EACpC;AACE,SAAAR,EAAM,MAAMC,GAAMW,CAAM,GACjBZ,EAAM,UAAUC,GAAMW,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/table.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/table.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/table.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["table","state","node","rows","firstRow","tableContent","head","body","start","pointStart","end","pointEnd","result"],"mappings":";AAkBO,SAASA,EAAMC,GAAOC,GAAM;AACjC,QAAMC,IAAOF,EAAM,IAAIC,CAAI,GACrBE,IAAWD,EAAK,MAAK,GAErBE,IAAe,CAAA;AAErB,MAAID,GAAU;AAEZ,UAAME,IAAO;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,YAAY,CAAE;AAAA,MACd,UAAUL,EAAM,KAAK,CAACG,CAAQ,GAAG,EAAI;AAAA,IAC3C;AACI,IAAAH,EAAM,MAAMC,EAAK,SAAS,CAAC,GAAGI,CAAI,GAClCD,EAAa,KAAKC,CAAI;AAAA,EAC1B;AAEE,MAAIH,EAAK,SAAS,GAAG;AAEnB,UAAMI,IAAO;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,YAAY,CAAE;AAAA,MACd,UAAUN,EAAM,KAAKE,GAAM,EAAI;AAAA,IACrC,GAEUK,IAAQC,EAAWP,EAAK,SAAS,CAAC,CAAC,GACnCQ,IAAMC,EAAST,EAAK,SAASA,EAAK,SAAS,SAAS,CAAC,CAAC;AAC5D,IAAIM,KAASE,MAAKH,EAAK,WAAW,EAAC,OAAAC,GAAO,KAAAE,EAAG,IAC7CL,EAAa,KAAKE,CAAI;AAAA,EAC1B;AAGE,QAAMK,IAAS;AAAA,IACb,MAAM;AAAA,IACN,SAAS;AAAA,IACT,YAAY,CAAE;AAAA,IACd,UAAUX,EAAM,KAAKI,GAAc,EAAI;AAAA,EAC3C;AACE,SAAAJ,EAAM,MAAMC,GAAMU,CAAM,GACjBX,EAAM,UAAUC,GAAMU,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/text.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/text.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/text.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["text","state","node","result","trimLines"],"mappings":";AAmBO,SAASA,EAAKC,GAAOC,GAAM;AAEhC,QAAMC,IAAS,EAAC,MAAM,QAAQ,OAAOC,EAAU,OAAOF,EAAK,KAAK,CAAC,EAAC;AAClE,SAAAD,EAAM,MAAMC,GAAMC,CAAM,GACjBF,EAAM,UAAUC,GAAMC,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.es.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"thematic-break.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":["thematicBreak","state","node","result"],"mappings":"AAmBO,SAASA,EAAcC,GAAOC,GAAM;AAEzC,QAAMC,IAAS;AAAA,IACb,MAAM;AAAA,IACN,SAAS;AAAA,IACT,YAAY,CAAE;AAAA,IACd,UAAU,CAAA;AAAA,EACd;AACE,SAAAF,EAAM,MAAMC,GAAMC,CAAM,GACjBF,EAAM,UAAUC,GAAMC,CAAM;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/index.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n"],"names":["toHast","tree","options","state","createState","node","foot","footer","result"],"mappings":";;AAuFO,SAASA,EAAOC,GAAMC,GAAS;AACpC,QAAMC,IAAQC,EAAYH,GAAMC,CAAO,GACjCG,IAAOF,EAAM,IAAIF,GAAM,MAAS,GAChCK,IAAOC,EAAOJ,CAAK,GAEnBK,IAAS,MAAM,QAAQH,CAAI,IAC7B,EAAC,MAAM,QAAQ,UAAUA,EAAI,IAC7BA,KAAQ,EAAC,MAAM,QAAQ,UAAU,CAAE,EAAA;AAEvC,SAAIC,KAKFE,EAAO,SAAS,KAAK,EAAC,MAAM,QAAQ,OAAO;AAAA,EAAI,GAAGF,CAAI,GAGjDE;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/revert.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/revert.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revert.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/revert.js"],"sourcesContent":["/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n"],"names":["revert","state","node","subtype","suffix","contents","head","tail"],"mappings":"AAsBO,SAASA,EAAOC,GAAOC,GAAM;AAClC,QAAMC,IAAUD,EAAK;AACrB,MAAIE,IAAS;AAQb,MANID,MAAY,cACdC,KAAU,OACDD,MAAY,WACrBC,KAAU,OAAOF,EAAK,SAASA,EAAK,cAAc,MAGhDA,EAAK,SAAS;AAChB,WAAO,CAAC,EAAC,MAAM,QAAQ,OAAO,OAAOA,EAAK,MAAME,EAAM,CAAC;AAGzD,QAAMC,IAAWJ,EAAM,IAAIC,CAAI,GACzBI,IAAOD,EAAS,CAAC;AAEvB,EAAIC,KAAQA,EAAK,SAAS,SACxBA,EAAK,QAAQ,MAAMA,EAAK,QAExBD,EAAS,QAAQ,EAAC,MAAM,QAAQ,OAAO,IAAG,CAAC;AAG7C,QAAME,IAAOF,EAASA,EAAS,SAAS,CAAC;AAEzC,SAAIE,KAAQA,EAAK,SAAS,SACxBA,EAAK,SAASH,IAEdC,EAAS,KAAK,EAAC,MAAM,QAAQ,OAAOD,EAAM,CAAC,GAGtCC;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/state.es.js

@@ -0,0 +1,105 @@
+import d from "../../../../@ungap_structured-clone@1.3.0/node_modules/@ungap/structured-clone/esm/index.es.js";
+import { handlers as A } from "./handlers/index.es.js";
+import { visit as C } from "../../../../unist-util-visit@5.0.0/node_modules/unist-util-visit/lib/index.es.js";
+import { position as k } from "../../../../unist-util-position@5.0.0/node_modules/unist-util-position/lib/index.es.js";
+const y = {}.hasOwnProperty, N = {};
+function I(e, n) {
+  const t = n || N, r = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), f = { ...A, ...t.handlers }, l = {
+    all: v,
+    applyData: O,
+    definitionById: r,
+    footnoteById: p,
+    footnoteCounts: u,
+    footnoteOrder: [],
+    handlers: f,
+    one: g,
+    options: t,
+    patch: M,
+    wrap: S
+  };
+  return C(e, function(i) {
+    if (i.type === "definition" || i.type === "footnoteDefinition") {
+      const a = i.type === "definition" ? r : p, o = String(i.identifier).toUpperCase();
+      a.has(o) || a.set(o, i);
+    }
+  }), l;
+  function g(i, a) {
+    const o = i.type, c = l.handlers[o];
+    if (y.call(l.handlers, o) && c)
+      return c(l, i, a);
+    if (l.options.passThrough && l.options.passThrough.includes(o)) {
+      if ("children" in i) {
+        const { children: h, ...x } = i, m = d(x);
+        return m.children = l.all(i), m;
+      }
+      return d(i);
+    }
+    return (l.options.unknownHandler || P)(l, i, a);
+  }
+  function v(i) {
+    const a = [];
+    if ("children" in i) {
+      const o = i.children;
+      let c = -1;
+      for (; ++c < o.length; ) {
+        const s = l.one(o[c], i);
+        if (s) {
+          if (c && o[c - 1].type === "break" && (!Array.isArray(s) && s.type === "text" && (s.value = w(s.value)), !Array.isArray(s) && s.type === "element")) {
+            const h = s.children[0];
+            h && h.type === "text" && (h.value = w(h.value));
+          }
+          Array.isArray(s) ? a.push(...s) : a.push(s);
+        }
+      }
+    }
+    return a;
+  }
+}
+function M(e, n) {
+  e.position && (n.position = k(e));
+}
+function O(e, n) {
+  let t = n;
+  if (e && e.data) {
+    const r = e.data.hName, p = e.data.hChildren, u = e.data.hProperties;
+    if (typeof r == "string")
+      if (t.type === "element")
+        t.tagName = r;
+      else {
+        const f = "children" in t ? t.children : [t];
+        t = { type: "element", tagName: r, properties: {}, children: f };
+      }
+    t.type === "element" && u && Object.assign(t.properties, d(u)), "children" in t && t.children && p !== null && p !== void 0 && (t.children = p);
+  }
+  return t;
+}
+function P(e, n) {
+  const t = n.data || {}, r = "value" in n && !(y.call(t, "hProperties") || y.call(t, "hChildren")) ? { type: "text", value: n.value } : {
+    type: "element",
+    tagName: "div",
+    properties: {},
+    children: e.all(n)
+  };
+  return e.patch(n, r), e.applyData(n, r);
+}
+function S(e, n) {
+  const t = [];
+  let r = -1;
+  for (n && t.push({ type: "text", value: `
+` }); ++r < e.length; )
+    r && t.push({ type: "text", value: `
+` }), t.push(e[r]);
+  return n && e.length > 0 && t.push({ type: "text", value: `
+` }), t;
+}
+function w(e) {
+  let n = 0, t = e.charCodeAt(n);
+  for (; t === 9 || t === 32; )
+    n++, t = e.charCodeAt(n);
+  return e.slice(n);
+}
+export {
+  I as createState,
+  S as wrap
+};
+//# sourceMappingURL=state.es.js.map

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/state.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/state.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\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","emptyOptions","createState","tree","options","settings","definitionById","footnoteById","footnoteCounts","handlers","defaultHandlers","state","all","applyData","one","patch","wrap","visit","node","map","id","parent","type","handle","children","shallow","result","structuredClone","defaultUnknownHandler","values","nodes","index","trimMarkdownSpaceStart","head","from","to","position","hName","hChildren","hProperties","data","loose","value","code"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.es.js

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

package/dist/node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n"],"names":["emptyOptions","toString","value","options","settings","includeImageAlt","includeHtml","one","node","all","values","result","index"],"mappings":"AAYA,MAAMA,IAAe,CAAA;AAed,SAASC,EAASC,GAAOC,GAAS;AACvC,QAAMC,IAAsBJ,GACtBK,IACJ,OAAOD,EAAS,mBAAoB,YAChCA,EAAS,kBACT,IACAE,IACJ,OAAOF,EAAS,eAAgB,YAAYA,EAAS,cAAc;AAErE,SAAOG,EAAIL,GAAOG,GAAiBC,CAAW;AAChD;AAcA,SAASC,EAAIL,GAAOG,GAAiBC,GAAa;AAChD,MAAIE,EAAKN,CAAK,GAAG;AACf,QAAI,WAAWA;AACb,aAAOA,EAAM,SAAS,UAAU,CAACI,IAAc,KAAKJ,EAAM;AAG5D,QAAIG,KAAmB,SAASH,KAASA,EAAM;AAC7C,aAAOA,EAAM;AAGf,QAAI,cAAcA;AAChB,aAAOO,EAAIP,EAAM,UAAUG,GAAiBC,CAAW;AAAA,EAE7D;AAEE,SAAI,MAAM,QAAQJ,CAAK,IACdO,EAAIP,GAAOG,GAAiBC,CAAW,IAGzC;AACT;AAcA,SAASG,EAAIC,GAAQL,GAAiBC,GAAa;AAEjD,QAAMK,IAAS,CAAA;AACf,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAO;AACtB,IAAAC,EAAOC,CAAK,IAAIL,EAAIG,EAAOE,CAAK,GAAGP,GAAiBC,CAAW;AAGjE,SAAOK,EAAO,KAAK,EAAE;AACvB;AAUA,SAASH,EAAKN,GAAO;AACnB,SAAO,GAAQA,KAAS,OAAOA,KAAU;AAC3C;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/attention.es.js

@@ -0,0 +1,84 @@
+import { push as d, splice as S } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+import { classifyCharacter as h } from "../../../../micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.es.js";
+import { resolveAll as q } from "../../../../micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.es.js";
+const z = {
+  name: "attention",
+  resolveAll: g,
+  tokenize: y
+};
+function g(t, i) {
+  let e = -1, r, a, l, u, s, n, o, f;
+  for (; ++e < t.length; )
+    if (t[e][0] === "enter" && t[e][1].type === "attentionSequence" && t[e][1]._close) {
+      for (r = e; r--; )
+        if (t[r][0] === "exit" && t[r][1].type === "attentionSequence" && t[r][1]._open && // If the markers are the same:
+        i.sliceSerialize(t[r][1]).charCodeAt(0) === i.sliceSerialize(t[e][1]).charCodeAt(0)) {
+          if ((t[r][1]._close || t[e][1]._open) && (t[e][1].end.offset - t[e][1].start.offset) % 3 && !((t[r][1].end.offset - t[r][1].start.offset + t[e][1].end.offset - t[e][1].start.offset) % 3))
+            continue;
+          n = t[r][1].end.offset - t[r][1].start.offset > 1 && t[e][1].end.offset - t[e][1].start.offset > 1 ? 2 : 1;
+          const p = {
+            ...t[r][1].end
+          }, c = {
+            ...t[e][1].start
+          };
+          m(p, -n), m(c, n), u = {
+            type: n > 1 ? "strongSequence" : "emphasisSequence",
+            start: p,
+            end: {
+              ...t[r][1].end
+            }
+          }, s = {
+            type: n > 1 ? "strongSequence" : "emphasisSequence",
+            start: {
+              ...t[e][1].start
+            },
+            end: c
+          }, l = {
+            type: n > 1 ? "strongText" : "emphasisText",
+            start: {
+              ...t[r][1].end
+            },
+            end: {
+              ...t[e][1].start
+            }
+          }, a = {
+            type: n > 1 ? "strong" : "emphasis",
+            start: {
+              ...u.start
+            },
+            end: {
+              ...s.end
+            }
+          }, t[r][1].end = {
+            ...u.start
+          }, t[e][1].start = {
+            ...s.end
+          }, o = [], t[r][1].end.offset - t[r][1].start.offset && (o = d(o, [["enter", t[r][1], i], ["exit", t[r][1], i]])), o = d(o, [["enter", a, i], ["enter", u, i], ["exit", u, i], ["enter", l, i]]), o = d(o, q(i.parser.constructs.insideSpan.null, t.slice(r + 1, e), i)), o = d(o, [["exit", l, i], ["enter", s, i], ["exit", s, i], ["exit", a, i]]), t[e][1].end.offset - t[e][1].start.offset ? (f = 2, o = d(o, [["enter", t[e][1], i], ["exit", t[e][1], i]])) : f = 0, S(t, r - 1, e - r + 3, o), e = r + o.length - f - 2;
+          break;
+        }
+    }
+  for (e = -1; ++e < t.length; )
+    t[e][1].type === "attentionSequence" && (t[e][1].type = "data");
+  return t;
+}
+function y(t, i) {
+  const e = this.parser.constructs.attentionMarkers.null, r = this.previous, a = h(r);
+  let l;
+  return u;
+  function u(n) {
+    return l = n, t.enter("attentionSequence"), s(n);
+  }
+  function s(n) {
+    if (n === l)
+      return t.consume(n), s;
+    const o = t.exit("attentionSequence"), f = h(n), p = !f || f === 2 && a || e.includes(n), c = !a || a === 2 && f || e.includes(r);
+    return o._open = !!(l === 42 ? p : p && (a || !c)), o._close = !!(l === 42 ? c : c && (f || !p)), i(n);
+  }
+}
+function m(t, i) {
+  t.column += i, t.offset += i, t._bufferIndex += i;
+}
+export {
+  z as attention
+};
+//# sourceMappingURL=attention.es.js.map