@easyv/biz-components 0.0.20 → 0.0.22

package/dist/node_modules/.pnpm/mdast-util-from-markdown@2.0.2/node_modules/mdast-util-from-markdown/lib/index.es.js

@@ -1,428 +1,550 @@
-import { decodeNumericCharacterReference as Be } from "../../../../micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.es.js";
-import { decodeString as Re } from "../../../../micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.es.js";
-import { normalizeIdentifier as T } from "../../../../micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.es.js";
-import { decodeNamedCharacterReference as Ce } from "../../../../decode-named-character-reference@1.1.0/node_modules/decode-named-character-reference/index.dom.es.js";
-import { postprocess as He } from "../../../../micromark@4.0.2/node_modules/micromark/lib/postprocess.es.js";
-import { parse as Le } from "../../../../micromark@4.0.2/node_modules/micromark/lib/parse.es.js";
-import { preprocess as ze } from "../../../../micromark@4.0.2/node_modules/micromark/lib/preprocess.es.js";
-import { stringifyPosition as I } from "../../../../unist-util-stringify-position@4.0.0/node_modules/unist-util-stringify-position/lib/index.es.js";
-import { toString as Pe } from "../../../../mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.es.js";
-const M = {}.hasOwnProperty;
-function We(o, a, l) {
-  return typeof a != "string" && (l = a, a = void 0), Oe(l)(He(Le(l).document().write(ze()(o, a, !0))));
+import { decodeNumericCharacterReference } from "../../../../micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.es.js";
+import { decodeString } from "../../../../micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.es.js";
+import { normalizeIdentifier } from "../../../../micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.es.js";
+import { decodeNamedCharacterReference } from "../../../../decode-named-character-reference@1.1.0/node_modules/decode-named-character-reference/index.dom.es.js";
+import { postprocess } from "../../../../micromark@4.0.2/node_modules/micromark/lib/postprocess.es.js";
+import { parse } from "../../../../micromark@4.0.2/node_modules/micromark/lib/parse.es.js";
+import { preprocess } from "../../../../micromark@4.0.2/node_modules/micromark/lib/preprocess.es.js";
+import { stringifyPosition } from "../../../../unist-util-stringify-position@4.0.0/node_modules/unist-util-stringify-position/lib/index.es.js";
+import { toString } from "../../../../mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.es.js";
+const own = {}.hasOwnProperty;
+function fromMarkdown(value, encoding, options) {
+  if (typeof encoding !== "string") {
+    options = encoding;
+    encoding = void 0;
+  }
+  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));
 }
-function Oe(o) {
-  const a = {
+function compiler(options) {
+  const config = {
     transforms: [],
     canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
     enter: {
-      autolink: r(P),
-      autolinkProtocol: p,
-      autolinkEmail: p,
-      atxHeading: r(H),
-      blockQuote: r(me),
-      characterEscape: p,
-      characterReference: p,
-      codeFenced: r(C),
-      codeFencedFenceInfo: h,
-      codeFencedFenceMeta: h,
-      codeIndented: r(C, h),
-      codeText: r(xe, h),
-      codeTextData: p,
-      data: p,
-      codeFlowValue: p,
-      definition: r(ye),
-      definitionDestinationString: h,
-      definitionLabelString: h,
-      definitionTitleString: h,
-      emphasis: r(be),
-      hardBreakEscape: r(L),
-      hardBreakTrailing: r(L),
-      htmlFlow: r(z, h),
-      htmlFlowData: p,
-      htmlText: r(z, h),
-      htmlTextData: p,
-      image: r(Se),
-      label: h,
-      link: r(P),
-      listItem: r(we),
-      listItemValue: U,
-      listOrdered: r(O, N),
-      listUnordered: r(O),
-      paragraph: r(Ie),
-      reference: he,
-      referenceString: h,
-      resourceDestinationString: h,
-      resourceTitleString: h,
-      setextHeading: r(H),
-      strong: r(Te),
-      thematicBreak: r(Fe)
+      autolink: opener(link),
+      autolinkProtocol: onenterdata,
+      autolinkEmail: onenterdata,
+      atxHeading: opener(heading),
+      blockQuote: opener(blockQuote),
+      characterEscape: onenterdata,
+      characterReference: onenterdata,
+      codeFenced: opener(codeFlow),
+      codeFencedFenceInfo: buffer,
+      codeFencedFenceMeta: buffer,
+      codeIndented: opener(codeFlow, buffer),
+      codeText: opener(codeText, buffer),
+      codeTextData: onenterdata,
+      data: onenterdata,
+      codeFlowValue: onenterdata,
+      definition: opener(definition),
+      definitionDestinationString: buffer,
+      definitionLabelString: buffer,
+      definitionTitleString: buffer,
+      emphasis: opener(emphasis),
+      hardBreakEscape: opener(hardBreak),
+      hardBreakTrailing: opener(hardBreak),
+      htmlFlow: opener(html, buffer),
+      htmlFlowData: onenterdata,
+      htmlText: opener(html, buffer),
+      htmlTextData: onenterdata,
+      image: opener(image),
+      label: buffer,
+      link: opener(link),
+      listItem: opener(listItem),
+      listItemValue: onenterlistitemvalue,
+      listOrdered: opener(list, onenterlistordered),
+      listUnordered: opener(list),
+      paragraph: opener(paragraph),
+      reference: onenterreference,
+      referenceString: buffer,
+      resourceDestinationString: buffer,
+      resourceTitleString: buffer,
+      setextHeading: opener(heading),
+      strong: opener(strong),
+      thematicBreak: opener(thematicBreak)
     },
     exit: {
-      atxHeading: c(),
-      atxHeadingSequence: X,
-      autolink: c(),
-      autolinkEmail: ge,
-      autolinkProtocol: ke,
-      blockQuote: c(),
-      characterEscapeValue: k,
-      characterReferenceMarkerHexadecimal: R,
-      characterReferenceMarkerNumeric: R,
-      characterReferenceValue: fe,
-      characterReference: pe,
-      codeFenced: c(W),
-      codeFencedFence: A,
-      codeFencedFenceInfo: _,
-      codeFencedFenceMeta: j,
-      codeFlowValue: k,
-      codeIndented: c($),
-      codeText: c(ie),
-      codeTextData: k,
-      data: k,
-      definition: c(),
-      definitionDestinationString: K,
-      definitionLabelString: G,
-      definitionTitleString: J,
-      emphasis: c(),
-      hardBreakEscape: c(B),
-      hardBreakTrailing: c(B),
-      htmlFlow: c(te),
-      htmlFlowData: k,
-      htmlText: c(ne),
-      htmlTextData: k,
-      image: c(se),
-      label: ce,
-      labelText: re,
-      lineEnding: ee,
-      link: c(ae),
-      listItem: c(),
-      listOrdered: c(),
-      listUnordered: c(),
-      paragraph: c(),
-      referenceString: ue,
-      resourceDestinationString: oe,
-      resourceTitleString: le,
-      resource: de,
-      setextHeading: c(v),
-      setextHeadingLineSequence: Z,
-      setextHeadingText: Y,
-      strong: c(),
-      thematicBreak: c()
+      atxHeading: closer(),
+      atxHeadingSequence: onexitatxheadingsequence,
+      autolink: closer(),
+      autolinkEmail: onexitautolinkemail,
+      autolinkProtocol: onexitautolinkprotocol,
+      blockQuote: closer(),
+      characterEscapeValue: onexitdata,
+      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
+      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
+      characterReferenceValue: onexitcharacterreferencevalue,
+      characterReference: onexitcharacterreference,
+      codeFenced: closer(onexitcodefenced),
+      codeFencedFence: onexitcodefencedfence,
+      codeFencedFenceInfo: onexitcodefencedfenceinfo,
+      codeFencedFenceMeta: onexitcodefencedfencemeta,
+      codeFlowValue: onexitdata,
+      codeIndented: closer(onexitcodeindented),
+      codeText: closer(onexitcodetext),
+      codeTextData: onexitdata,
+      data: onexitdata,
+      definition: closer(),
+      definitionDestinationString: onexitdefinitiondestinationstring,
+      definitionLabelString: onexitdefinitionlabelstring,
+      definitionTitleString: onexitdefinitiontitlestring,
+      emphasis: closer(),
+      hardBreakEscape: closer(onexithardbreak),
+      hardBreakTrailing: closer(onexithardbreak),
+      htmlFlow: closer(onexithtmlflow),
+      htmlFlowData: onexitdata,
+      htmlText: closer(onexithtmltext),
+      htmlTextData: onexitdata,
+      image: closer(onexitimage),
+      label: onexitlabel,
+      labelText: onexitlabeltext,
+      lineEnding: onexitlineending,
+      link: closer(onexitlink),
+      listItem: closer(),
+      listOrdered: closer(),
+      listUnordered: closer(),
+      paragraph: closer(),
+      referenceString: onexitreferencestring,
+      resourceDestinationString: onexitresourcedestinationstring,
+      resourceTitleString: onexitresourcetitlestring,
+      resource: onexitresource,
+      setextHeading: closer(onexitsetextheading),
+      setextHeadingLineSequence: onexitsetextheadinglinesequence,
+      setextHeadingText: onexitsetextheadingtext,
+      strong: closer(),
+      thematicBreak: closer()
     }
   };
-  V(a, (o || {}).mdastExtensions || []);
-  const l = {};
-  return d;
-  function d(e) {
-    let t = {
+  configure(config, (options || {}).mdastExtensions || []);
+  const data = {};
+  return compile;
+  function compile(events) {
+    let tree = {
       type: "root",
       children: []
     };
-    const n = {
-      stack: [t],
+    const context = {
+      stack: [tree],
       tokenStack: [],
-      config: a,
-      enter: E,
-      exit: F,
-      buffer: h,
-      resume: q,
-      data: l
-    }, i = [];
-    let s = -1;
-    for (; ++s < e.length; )
-      if (e[s][1].type === "listOrdered" || e[s][1].type === "listUnordered")
-        if (e[s][0] === "enter")
-          i.push(s);
-        else {
-          const f = i.pop();
-          s = Q(e, f, s);
+      config,
+      enter,
+      exit,
+      buffer,
+      resume,
+      data
+    };
+    const listStack = [];
+    let index = -1;
+    while (++index < events.length) {
+      if (events[index][1].type === "listOrdered" || events[index][1].type === "listUnordered") {
+        if (events[index][0] === "enter") {
+          listStack.push(index);
+        } else {
+          const tail = listStack.pop();
+          index = prepareList(events, tail, index);
         }
-    for (s = -1; ++s < e.length; ) {
-      const f = a[e[s][0]];
-      M.call(f, e[s][1].type) && f[e[s][1].type].call(Object.assign({
-        sliceSerialize: e[s][2].sliceSerialize
-      }, n), e[s][1]);
+      }
     }
-    if (n.tokenStack.length > 0) {
-      const f = n.tokenStack[n.tokenStack.length - 1];
-      (f[1] || D).call(n, void 0, f[0]);
+    index = -1;
+    while (++index < events.length) {
+      const handler = config[events[index][0]];
+      if (own.call(handler, events[index][1].type)) {
+        handler[events[index][1].type].call(Object.assign({
+          sliceSerialize: events[index][2].sliceSerialize
+        }, context), events[index][1]);
+      }
     }
-    for (t.position = {
-      start: x(e.length > 0 ? e[0][1].start : {
+    if (context.tokenStack.length > 0) {
+      const tail = context.tokenStack[context.tokenStack.length - 1];
+      const handler = tail[1] || defaultOnError;
+      handler.call(context, void 0, tail[0]);
+    }
+    tree.position = {
+      start: point(events.length > 0 ? events[0][1].start : {
         line: 1,
         column: 1,
         offset: 0
       }),
-      end: x(e.length > 0 ? e[e.length - 2][1].end : {
+      end: point(events.length > 0 ? events[events.length - 2][1].end : {
         line: 1,
         column: 1,
         offset: 0
       })
-    }, s = -1; ++s < a.transforms.length; )
-      t = a.transforms[s](t) || t;
-    return t;
-  }
-  function Q(e, t, n) {
-    let i = t - 1, s = -1, f = !1, y, g, S, w;
-    for (; ++i <= n; ) {
-      const u = e[i];
-      switch (u[1].type) {
+    };
+    index = -1;
+    while (++index < config.transforms.length) {
+      tree = config.transforms[index](tree) || tree;
+    }
+    return tree;
+  }
+  function prepareList(events, start, length) {
+    let index = start - 1;
+    let containerBalance = -1;
+    let listSpread = false;
+    let listItem2;
+    let lineIndex;
+    let firstBlankLineIndex;
+    let atMarker;
+    while (++index <= length) {
+      const event = events[index];
+      switch (event[1].type) {
         case "listUnordered":
         case "listOrdered":
         case "blockQuote": {
-          u[0] === "enter" ? s++ : s--, w = void 0;
+          if (event[0] === "enter") {
+            containerBalance++;
+          } else {
+            containerBalance--;
+          }
+          atMarker = void 0;
           break;
         }
         case "lineEndingBlank": {
-          u[0] === "enter" && (y && !w && !s && !S && (S = i), w = void 0);
+          if (event[0] === "enter") {
+            if (listItem2 && !atMarker && !containerBalance && !firstBlankLineIndex) {
+              firstBlankLineIndex = index;
+            }
+            atMarker = void 0;
+          }
           break;
         }
         case "linePrefix":
         case "listItemValue":
         case "listItemMarker":
         case "listItemPrefix":
-        case "listItemPrefixWhitespace":
+        case "listItemPrefixWhitespace": {
           break;
-        default:
-          w = void 0;
+        }
+        default: {
+          atMarker = void 0;
+        }
       }
-      if (!s && u[0] === "enter" && u[1].type === "listItemPrefix" || s === -1 && u[0] === "exit" && (u[1].type === "listUnordered" || u[1].type === "listOrdered")) {
-        if (y) {
-          let b = i;
-          for (g = void 0; b--; ) {
-            const m = e[b];
-            if (m[1].type === "lineEnding" || m[1].type === "lineEndingBlank") {
-              if (m[0] === "exit") continue;
-              g && (e[g][1].type = "lineEndingBlank", f = !0), m[1].type = "lineEnding", g = b;
-            } else if (!(m[1].type === "linePrefix" || m[1].type === "blockQuotePrefix" || m[1].type === "blockQuotePrefixWhitespace" || m[1].type === "blockQuoteMarker" || m[1].type === "listItemIndent")) break;
+      if (!containerBalance && event[0] === "enter" && event[1].type === "listItemPrefix" || containerBalance === -1 && event[0] === "exit" && (event[1].type === "listUnordered" || event[1].type === "listOrdered")) {
+        if (listItem2) {
+          let tailIndex = index;
+          lineIndex = void 0;
+          while (tailIndex--) {
+            const tailEvent = events[tailIndex];
+            if (tailEvent[1].type === "lineEnding" || tailEvent[1].type === "lineEndingBlank") {
+              if (tailEvent[0] === "exit") continue;
+              if (lineIndex) {
+                events[lineIndex][1].type = "lineEndingBlank";
+                listSpread = true;
+              }
+              tailEvent[1].type = "lineEnding";
+              lineIndex = tailIndex;
+            } else if (tailEvent[1].type === "linePrefix" || tailEvent[1].type === "blockQuotePrefix" || tailEvent[1].type === "blockQuotePrefixWhitespace" || tailEvent[1].type === "blockQuoteMarker" || tailEvent[1].type === "listItemIndent") ;
+            else {
+              break;
+            }
           }
-          S && (!g || S < g) && (y._spread = !0), y.end = Object.assign({}, g ? e[g][1].start : u[1].end), e.splice(g || i, 0, ["exit", y, u[2]]), i++, n++;
+          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {
+            listItem2._spread = true;
+          }
+          listItem2.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);
+          events.splice(lineIndex || index, 0, ["exit", listItem2, event[2]]);
+          index++;
+          length++;
         }
-        if (u[1].type === "listItemPrefix") {
-          const b = {
+        if (event[1].type === "listItemPrefix") {
+          const item = {
             type: "listItem",
-            _spread: !1,
-            start: Object.assign({}, u[1].start),
+            _spread: false,
+            start: Object.assign({}, event[1].start),
             // @ts-expect-error: we’ll add `end` in a second.
             end: void 0
           };
-          y = b, e.splice(i, 0, ["enter", b, u[2]]), i++, n++, S = void 0, w = !0;
+          listItem2 = item;
+          events.splice(index, 0, ["enter", item, event[2]]);
+          index++;
+          length++;
+          firstBlankLineIndex = void 0;
+          atMarker = true;
         }
       }
     }
-    return e[t][1]._spread = f, n;
-  }
-  function r(e, t) {
-    return n;
-    function n(i) {
-      E.call(this, e(i), i), t && t.call(this, i);
+    events[start][1]._spread = listSpread;
+    return length;
+  }
+  function opener(create, and) {
+    return open;
+    function open(token) {
+      enter.call(this, create(token), token);
+      if (and) and.call(this, token);
     }
   }
-  function h() {
+  function buffer() {
     this.stack.push({
       type: "fragment",
       children: []
     });
   }
-  function E(e, t, n) {
-    this.stack[this.stack.length - 1].children.push(e), this.stack.push(e), this.tokenStack.push([t, n || void 0]), e.position = {
-      start: x(t.start),
+  function enter(node, token, errorHandler) {
+    const parent = this.stack[this.stack.length - 1];
+    const siblings = parent.children;
+    siblings.push(node);
+    this.stack.push(node);
+    this.tokenStack.push([token, errorHandler || void 0]);
+    node.position = {
+      start: point(token.start),
       // @ts-expect-error: `end` will be patched later.
       end: void 0
     };
   }
-  function c(e) {
-    return t;
-    function t(n) {
-      e && e.call(this, n), F.call(this, n);
+  function closer(and) {
+    return close;
+    function close(token) {
+      if (and) and.call(this, token);
+      exit.call(this, token);
     }
   }
-  function F(e, t) {
-    const n = this.stack.pop(), i = this.tokenStack.pop();
-    if (i)
-      i[0].type !== e.type && (t ? t.call(this, e, i[0]) : (i[1] || D).call(this, e, i[0]));
-    else throw new Error("Cannot close `" + e.type + "` (" + I({
-      start: e.start,
-      end: e.end
-    }) + "): it’s not open");
-    n.position.end = x(e.end);
+  function exit(token, onExitError) {
+    const node = this.stack.pop();
+    const open = this.tokenStack.pop();
+    if (!open) {
+      throw new Error("Cannot close `" + token.type + "` (" + stringifyPosition({
+        start: token.start,
+        end: token.end
+      }) + "): it’s not open");
+    } else if (open[0].type !== token.type) {
+      if (onExitError) {
+        onExitError.call(this, token, open[0]);
+      } else {
+        const handler = open[1] || defaultOnError;
+        handler.call(this, token, open[0]);
+      }
+    }
+    node.position.end = point(token.end);
   }
-  function q() {
-    return Pe(this.stack.pop());
+  function resume() {
+    return toString(this.stack.pop());
   }
-  function N() {
-    this.data.expectingFirstListItemValue = !0;
+  function onenterlistordered() {
+    this.data.expectingFirstListItemValue = true;
   }
-  function U(e) {
+  function onenterlistitemvalue(token) {
     if (this.data.expectingFirstListItemValue) {
-      const t = this.stack[this.stack.length - 2];
-      t.start = Number.parseInt(this.sliceSerialize(e), 10), this.data.expectingFirstListItemValue = void 0;
+      const ancestor = this.stack[this.stack.length - 2];
+      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);
+      this.data.expectingFirstListItemValue = void 0;
     }
   }
-  function _() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.lang = e;
-  }
-  function j() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.meta = e;
-  }
-  function A() {
-    this.data.flowCodeInside || (this.buffer(), this.data.flowCodeInside = !0);
-  }
-  function W() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.value = e.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, ""), this.data.flowCodeInside = void 0;
-  }
-  function $() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.value = e.replace(/(\r?\n|\r)$/g, "");
-  }
-  function G(e) {
-    const t = this.resume(), n = this.stack[this.stack.length - 1];
-    n.label = t, n.identifier = T(this.sliceSerialize(e)).toLowerCase();
-  }
-  function J() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.title = e;
-  }
-  function K() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.url = e;
-  }
-  function X(e) {
-    const t = this.stack[this.stack.length - 1];
-    if (!t.depth) {
-      const n = this.sliceSerialize(e).length;
-      t.depth = n;
+  function onexitcodefencedfenceinfo() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.lang = data2;
+  }
+  function onexitcodefencedfencemeta() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.meta = data2;
+  }
+  function onexitcodefencedfence() {
+    if (this.data.flowCodeInside) return;
+    this.buffer();
+    this.data.flowCodeInside = true;
+  }
+  function onexitcodefenced() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.value = data2.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, "");
+    this.data.flowCodeInside = void 0;
+  }
+  function onexitcodeindented() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.value = data2.replace(/(\r?\n|\r)$/g, "");
+  }
+  function onexitdefinitionlabelstring(token) {
+    const label = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.label = label;
+    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
+  }
+  function onexitdefinitiontitlestring() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.title = data2;
+  }
+  function onexitdefinitiondestinationstring() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.url = data2;
+  }
+  function onexitatxheadingsequence(token) {
+    const node = this.stack[this.stack.length - 1];
+    if (!node.depth) {
+      const depth = this.sliceSerialize(token).length;
+      node.depth = depth;
     }
   }
-  function Y() {
-    this.data.setextHeadingSlurpLineEnding = !0;
+  function onexitsetextheadingtext() {
+    this.data.setextHeadingSlurpLineEnding = true;
   }
-  function Z(e) {
-    const t = this.stack[this.stack.length - 1];
-    t.depth = this.sliceSerialize(e).codePointAt(0) === 61 ? 1 : 2;
+  function onexitsetextheadinglinesequence(token) {
+    const node = this.stack[this.stack.length - 1];
+    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;
   }
-  function v() {
+  function onexitsetextheading() {
     this.data.setextHeadingSlurpLineEnding = void 0;
   }
-  function p(e) {
-    const n = this.stack[this.stack.length - 1].children;
-    let i = n[n.length - 1];
-    (!i || i.type !== "text") && (i = Ee(), i.position = {
-      start: x(e.start),
-      // @ts-expect-error: we’ll add `end` later.
-      end: void 0
-    }, n.push(i)), this.stack.push(i);
+  function onenterdata(token) {
+    const node = this.stack[this.stack.length - 1];
+    const siblings = node.children;
+    let tail = siblings[siblings.length - 1];
+    if (!tail || tail.type !== "text") {
+      tail = text();
+      tail.position = {
+        start: point(token.start),
+        // @ts-expect-error: we’ll add `end` later.
+        end: void 0
+      };
+      siblings.push(tail);
+    }
+    this.stack.push(tail);
   }
-  function k(e) {
-    const t = this.stack.pop();
-    t.value += this.sliceSerialize(e), t.position.end = x(e.end);
+  function onexitdata(token) {
+    const tail = this.stack.pop();
+    tail.value += this.sliceSerialize(token);
+    tail.position.end = point(token.end);
   }
-  function ee(e) {
-    const t = this.stack[this.stack.length - 1];
+  function onexitlineending(token) {
+    const context = this.stack[this.stack.length - 1];
     if (this.data.atHardBreak) {
-      const n = t.children[t.children.length - 1];
-      n.position.end = x(e.end), this.data.atHardBreak = void 0;
+      const tail = context.children[context.children.length - 1];
+      tail.position.end = point(token.end);
+      this.data.atHardBreak = void 0;
       return;
     }
-    !this.data.setextHeadingSlurpLineEnding && a.canContainEols.includes(t.type) && (p.call(this, e), k.call(this, e));
+    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {
+      onenterdata.call(this, token);
+      onexitdata.call(this, token);
+    }
   }
-  function B() {
-    this.data.atHardBreak = !0;
+  function onexithardbreak() {
+    this.data.atHardBreak = true;
   }
-  function te() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.value = e;
+  function onexithtmlflow() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.value = data2;
   }
-  function ne() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.value = e;
+  function onexithtmltext() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.value = data2;
   }
-  function ie() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.value = e;
+  function onexitcodetext() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.value = data2;
   }
-  function ae() {
-    const e = this.stack[this.stack.length - 1];
+  function onexitlink() {
+    const node = this.stack[this.stack.length - 1];
     if (this.data.inReference) {
-      const t = this.data.referenceType || "shortcut";
-      e.type += "Reference", e.referenceType = t, delete e.url, delete e.title;
-    } else
-      delete e.identifier, delete e.label;
+      const referenceType = this.data.referenceType || "shortcut";
+      node.type += "Reference";
+      node.referenceType = referenceType;
+      delete node.url;
+      delete node.title;
+    } else {
+      delete node.identifier;
+      delete node.label;
+    }
     this.data.referenceType = void 0;
   }
-  function se() {
-    const e = this.stack[this.stack.length - 1];
+  function onexitimage() {
+    const node = this.stack[this.stack.length - 1];
     if (this.data.inReference) {
-      const t = this.data.referenceType || "shortcut";
-      e.type += "Reference", e.referenceType = t, delete e.url, delete e.title;
-    } else
-      delete e.identifier, delete e.label;
+      const referenceType = this.data.referenceType || "shortcut";
+      node.type += "Reference";
+      node.referenceType = referenceType;
+      delete node.url;
+      delete node.title;
+    } else {
+      delete node.identifier;
+      delete node.label;
+    }
     this.data.referenceType = void 0;
   }
-  function re(e) {
-    const t = this.sliceSerialize(e), n = this.stack[this.stack.length - 2];
-    n.label = Re(t), n.identifier = T(t).toLowerCase();
-  }
-  function ce() {
-    const e = this.stack[this.stack.length - 1], t = this.resume(), n = this.stack[this.stack.length - 1];
-    if (this.data.inReference = !0, n.type === "link") {
-      const i = e.children;
-      n.children = i;
-    } else
-      n.alt = t;
+  function onexitlabeltext(token) {
+    const string = this.sliceSerialize(token);
+    const ancestor = this.stack[this.stack.length - 2];
+    ancestor.label = decodeString(string);
+    ancestor.identifier = normalizeIdentifier(string).toLowerCase();
+  }
+  function onexitlabel() {
+    const fragment = this.stack[this.stack.length - 1];
+    const value = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    this.data.inReference = true;
+    if (node.type === "link") {
+      const children = fragment.children;
+      node.children = children;
+    } else {
+      node.alt = value;
+    }
   }
-  function oe() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.url = e;
+  function onexitresourcedestinationstring() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.url = data2;
   }
-  function le() {
-    const e = this.resume(), t = this.stack[this.stack.length - 1];
-    t.title = e;
+  function onexitresourcetitlestring() {
+    const data2 = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.title = data2;
   }
-  function de() {
+  function onexitresource() {
     this.data.inReference = void 0;
   }
-  function he() {
+  function onenterreference() {
     this.data.referenceType = "collapsed";
   }
-  function ue(e) {
-    const t = this.resume(), n = this.stack[this.stack.length - 1];
-    n.label = t, n.identifier = T(this.sliceSerialize(e)).toLowerCase(), this.data.referenceType = "full";
-  }
-  function R(e) {
-    this.data.characterReferenceType = e.type;
-  }
-  function fe(e) {
-    const t = this.sliceSerialize(e), n = this.data.characterReferenceType;
-    let i;
-    n ? (i = Be(t, n === "characterReferenceMarkerNumeric" ? 10 : 16), this.data.characterReferenceType = void 0) : i = Ce(t);
-    const s = this.stack[this.stack.length - 1];
-    s.value += i;
+  function onexitreferencestring(token) {
+    const label = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    node.label = label;
+    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
+    this.data.referenceType = "full";
+  }
+  function onexitcharacterreferencemarker(token) {
+    this.data.characterReferenceType = token.type;
+  }
+  function onexitcharacterreferencevalue(token) {
+    const data2 = this.sliceSerialize(token);
+    const type = this.data.characterReferenceType;
+    let value;
+    if (type) {
+      value = decodeNumericCharacterReference(data2, type === "characterReferenceMarkerNumeric" ? 10 : 16);
+      this.data.characterReferenceType = void 0;
+    } else {
+      const result = decodeNamedCharacterReference(data2);
+      value = result;
+    }
+    const tail = this.stack[this.stack.length - 1];
+    tail.value += value;
   }
-  function pe(e) {
-    const t = this.stack.pop();
-    t.position.end = x(e.end);
+  function onexitcharacterreference(token) {
+    const tail = this.stack.pop();
+    tail.position.end = point(token.end);
   }
-  function ke(e) {
-    k.call(this, e);
-    const t = this.stack[this.stack.length - 1];
-    t.url = this.sliceSerialize(e);
+  function onexitautolinkprotocol(token) {
+    onexitdata.call(this, token);
+    const node = this.stack[this.stack.length - 1];
+    node.url = this.sliceSerialize(token);
   }
-  function ge(e) {
-    k.call(this, e);
-    const t = this.stack[this.stack.length - 1];
-    t.url = "mailto:" + this.sliceSerialize(e);
+  function onexitautolinkemail(token) {
+    onexitdata.call(this, token);
+    const node = this.stack[this.stack.length - 1];
+    node.url = "mailto:" + this.sliceSerialize(token);
   }
-  function me() {
+  function blockQuote() {
     return {
       type: "blockquote",
       children: []
     };
   }
-  function C() {
+  function codeFlow() {
     return {
       type: "code",
       lang: null,
@@ -430,13 +552,13 @@ function Oe(o) {
       value: ""
     };
   }
-  function xe() {
+  function codeText() {
     return {
       type: "inlineCode",
       value: ""
     };
   }
-  function ye() {
+  function definition() {
     return {
       type: "definition",
       identifier: "",
@@ -445,13 +567,13 @@ function Oe(o) {
       url: ""
     };
   }
-  function be() {
+  function emphasis() {
     return {
       type: "emphasis",
       children: []
     };
   }
-  function H() {
+  function heading() {
     return {
       type: "heading",
       // @ts-expect-error `depth` will be set later.
@@ -459,18 +581,18 @@ function Oe(o) {
       children: []
     };
   }
-  function L() {
+  function hardBreak() {
     return {
       type: "break"
     };
   }
-  function z() {
+  function html() {
     return {
       type: "html",
       value: ""
     };
   }
-  function Se() {
+  function image() {
     return {
       type: "image",
       title: null,
@@ -478,7 +600,7 @@ function Oe(o) {
       alt: null
     };
   }
-  function P() {
+  function link() {
     return {
       type: "link",
       title: null,
@@ -486,97 +608,113 @@ function Oe(o) {
       children: []
     };
   }
-  function O(e) {
+  function list(token) {
     return {
       type: "list",
-      ordered: e.type === "listOrdered",
+      ordered: token.type === "listOrdered",
       start: null,
-      spread: e._spread,
+      spread: token._spread,
       children: []
     };
   }
-  function we(e) {
+  function listItem(token) {
     return {
       type: "listItem",
-      spread: e._spread,
+      spread: token._spread,
       checked: null,
       children: []
     };
   }
-  function Ie() {
+  function paragraph() {
     return {
       type: "paragraph",
       children: []
     };
   }
-  function Te() {
+  function strong() {
     return {
       type: "strong",
       children: []
     };
   }
-  function Ee() {
+  function text() {
     return {
       type: "text",
       value: ""
     };
   }
-  function Fe() {
+  function thematicBreak() {
     return {
       type: "thematicBreak"
     };
   }
 }
-function x(o) {
+function point(d) {
   return {
-    line: o.line,
-    column: o.column,
-    offset: o.offset
+    line: d.line,
+    column: d.column,
+    offset: d.offset
   };
 }
-function V(o, a) {
-  let l = -1;
-  for (; ++l < a.length; ) {
-    const d = a[l];
-    Array.isArray(d) ? V(o, d) : De(o, d);
+function configure(combined, extensions) {
+  let index = -1;
+  while (++index < extensions.length) {
+    const value = extensions[index];
+    if (Array.isArray(value)) {
+      configure(combined, value);
+    } else {
+      extension(combined, value);
+    }
   }
 }
-function De(o, a) {
-  let l;
-  for (l in a)
-    if (M.call(a, l))
-      switch (l) {
+function extension(combined, extension2) {
+  let key;
+  for (key in extension2) {
+    if (own.call(extension2, key)) {
+      switch (key) {
         case "canContainEols": {
-          const d = a[l];
-          d && o[l].push(...d);
+          const right = extension2[key];
+          if (right) {
+            combined[key].push(...right);
+          }
           break;
         }
         case "transforms": {
-          const d = a[l];
-          d && o[l].push(...d);
+          const right = extension2[key];
+          if (right) {
+            combined[key].push(...right);
+          }
           break;
         }
         case "enter":
         case "exit": {
-          const d = a[l];
-          d && Object.assign(o[l], d);
+          const right = extension2[key];
+          if (right) {
+            Object.assign(combined[key], right);
+          }
           break;
         }
       }
+    }
+  }
 }
-function D(o, a) {
-  throw o ? new Error("Cannot close `" + o.type + "` (" + I({
-    start: o.start,
-    end: o.end
-  }) + "): a different token (`" + a.type + "`, " + I({
-    start: a.start,
-    end: a.end
-  }) + ") is open") : new Error("Cannot close document, a token (`" + a.type + "`, " + I({
-    start: a.start,
-    end: a.end
-  }) + ") is still open");
+function defaultOnError(left, right) {
+  if (left) {
+    throw new Error("Cannot close `" + left.type + "` (" + stringifyPosition({
+      start: left.start,
+      end: left.end
+    }) + "): a different token (`" + right.type + "`, " + stringifyPosition({
+      start: right.start,
+      end: right.end
+    }) + ") is open");
+  } else {
+    throw new Error("Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({
+      start: right.start,
+      end: right.end
+    }) + ") is still open");
+  }
 }
 export {
-  We as fromMarkdown
+  fromMarkdown
 };
 //# sourceMappingURL=index.es.js.map