impact-nova 2.6.3 → 3.0.0-alpha.1

package/dist/node_modules/mdast-util-from-markdown/lib/index.js

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

package/dist/node_modules/mdast-util-gfm/lib/index.js

@@ -0,0 +1,29 @@
+import { gfmAutolinkLiteralFromMarkdown as r, gfmAutolinkLiteralToMarkdown as m } from "../../mdast-util-gfm-autolink-literal/lib/index.js";
+import { gfmFootnoteFromMarkdown as t, gfmFootnoteToMarkdown as n } from "../../mdast-util-gfm-footnote/lib/index.js";
+import { gfmStrikethroughFromMarkdown as f, gfmStrikethroughToMarkdown as a } from "../../mdast-util-gfm-strikethrough/lib/index.js";
+import { gfmTableFromMarkdown as k, gfmTableToMarkdown as e } from "../../mdast-util-gfm-table/lib/index.js";
+import { gfmTaskListItemFromMarkdown as i, gfmTaskListItemToMarkdown as g } from "../../mdast-util-gfm-task-list-item/lib/index.js";
+function F() {
+  return [
+    r(),
+    t(),
+    f(),
+    k(),
+    i()
+  ];
+}
+function l(o) {
+  return {
+    extensions: [
+      m(),
+      n(o),
+      a(),
+      e(o),
+      g()
+    ]
+  };
+}
+export {
+  F as gfmFromMarkdown,
+  l as gfmToMarkdown
+};