impact-nova 2.6.3 → 3.0.0-alpha.1

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

@@ -0,0 +1,130 @@
+import { ccount as f } from "../../ccount/index.js";
+import { ok as k } from "../../devlop/lib/default.js";
+import { unicodeWhitespace as p, unicodePunctuation as d } from "../../micromark-util-character/index.js";
+import { findAndReplace as g } from "../../mdast-util-find-and-replace/lib/index.js";
+const a = "phrasing", u = ["autolink", "link", "image", "label"];
+function b() {
+  return {
+    transforms: [y],
+    enter: {
+      literalAutolink: w,
+      literalAutolinkEmail: s,
+      literalAutolinkHttp: s,
+      literalAutolinkWww: s
+    },
+    exit: {
+      literalAutolink: L,
+      literalAutolinkEmail: m,
+      literalAutolinkHttp: x,
+      literalAutolinkWww: A
+    }
+  };
+}
+function I() {
+  return {
+    unsafe: [
+      {
+        character: "@",
+        before: "[+\\-.\\w]",
+        after: "[\\-.\\w]",
+        inConstruct: a,
+        notInConstruct: u
+      },
+      {
+        character: ".",
+        before: "[Ww]",
+        after: "[\\-.\\w]",
+        inConstruct: a,
+        notInConstruct: u
+      },
+      {
+        character: ":",
+        before: "[ps]",
+        after: "\\/",
+        inConstruct: a,
+        notInConstruct: u
+      }
+    ]
+  };
+}
+function w(t) {
+  this.enter({ type: "link", title: null, url: "", children: [] }, t);
+}
+function s(t) {
+  this.config.enter.autolinkProtocol.call(this, t);
+}
+function x(t) {
+  this.config.exit.autolinkProtocol.call(this, t);
+}
+function A(t) {
+  this.config.exit.data.call(this, t);
+  const e = this.stack[this.stack.length - 1];
+  k(e.type === "link"), e.url = "http://" + this.sliceSerialize(t);
+}
+function m(t) {
+  this.config.exit.autolinkEmail.call(this, t);
+}
+function L(t) {
+  this.exit(t);
+}
+function y(t) {
+  g(
+    t,
+    [
+      [/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, P],
+      [new RegExp("(?<=^|\\s|\\p{P}|\\p{S})([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)", "gu"), E]
+    ],
+    { ignore: ["link", "linkReference"] }
+  );
+}
+function P(t, e, i, n, o) {
+  let l = "";
+  if (!h(o) || (/^w/i.test(e) && (i = e + i, e = "", l = "http://"), !W(i)))
+    return !1;
+  const r = _(i + n);
+  if (!r[0]) return !1;
+  const c = {
+    type: "link",
+    title: null,
+    url: l + e + r[0],
+    children: [{ type: "text", value: e + r[0] }]
+  };
+  return r[1] ? [c, { type: "text", value: r[1] }] : c;
+}
+function E(t, e, i, n) {
+  return (
+    // Not an expected previous character.
+    !h(n, !0) || // Label ends in not allowed character.
+    /[-\d_]$/.test(i) ? !1 : {
+      type: "link",
+      title: null,
+      url: "mailto:" + e + "@" + i,
+      children: [{ type: "text", value: e + "@" + i }]
+    }
+  );
+}
+function W(t) {
+  const e = t.split(".");
+  return !(e.length < 2 || e[e.length - 1] && (/_/.test(e[e.length - 1]) || !/[a-zA-Z\d]/.test(e[e.length - 1])) || e[e.length - 2] && (/_/.test(e[e.length - 2]) || !/[a-zA-Z\d]/.test(e[e.length - 2])));
+}
+function _(t) {
+  const e = /[!"&'),.:;<>?\]}]+$/.exec(t);
+  if (!e)
+    return [t, void 0];
+  t = t.slice(0, e.index);
+  let i = e[0], n = i.indexOf(")");
+  const o = f(t, "(");
+  let l = f(t, ")");
+  for (; n !== -1 && o > l; )
+    t += i.slice(0, n + 1), i = i.slice(n + 1), n = i.indexOf(")"), l++;
+  return [t, i];
+}
+function h(t, e) {
+  const i = t.input.charCodeAt(t.index - 1);
+  return (t.index === 0 || p(i) || d(i)) && // If it’s an email, the previous character should not be a slash.
+  (!e || i !== 47);
+}
+export {
+  b as gfmAutolinkLiteralFromMarkdown,
+  I as gfmAutolinkLiteralToMarkdown
+};

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

@@ -0,0 +1,95 @@
+import { ok as a } from "../../devlop/lib/default.js";
+import { normalizeIdentifier as s } from "../../micromark-util-normalize-identifier/index.js";
+u.peek = S;
+function F() {
+  this.buffer();
+}
+function b(e) {
+  this.enter({ type: "footnoteReference", identifier: "", label: "" }, e);
+}
+function k() {
+  this.buffer();
+}
+function d(e) {
+  this.enter(
+    { type: "footnoteDefinition", identifier: "", label: "", children: [] },
+    e
+  );
+}
+function x(e) {
+  const n = this.resume(), t = this.stack[this.stack.length - 1];
+  a(t.type === "footnoteReference"), t.identifier = s(
+    this.sliceSerialize(e)
+  ).toLowerCase(), t.label = n;
+}
+function D(e) {
+  this.exit(e);
+}
+function p(e) {
+  const n = this.resume(), t = this.stack[this.stack.length - 1];
+  a(t.type === "footnoteDefinition"), t.identifier = s(
+    this.sliceSerialize(e)
+  ).toLowerCase(), t.label = n;
+}
+function C(e) {
+  this.exit(e);
+}
+function S() {
+  return "[";
+}
+function u(e, n, t, r) {
+  const l = t.createTracker(r);
+  let o = l.move("[^");
+  const c = t.enter("footnoteReference"), i = t.enter("reference");
+  return o += l.move(
+    t.safe(t.associationId(e), { after: "]", before: o })
+  ), i(), c(), o += l.move("]"), o;
+}
+function R() {
+  return {
+    enter: {
+      gfmFootnoteCallString: F,
+      gfmFootnoteCall: b,
+      gfmFootnoteDefinitionLabelString: k,
+      gfmFootnoteDefinition: d
+    },
+    exit: {
+      gfmFootnoteCallString: x,
+      gfmFootnoteCall: D,
+      gfmFootnoteDefinitionLabelString: p,
+      gfmFootnoteDefinition: C
+    }
+  };
+}
+function y(e) {
+  let n = !1;
+  return e && e.firstLineBlank && (n = !0), {
+    handlers: { footnoteDefinition: t, footnoteReference: u },
+    // This is on by default already.
+    unsafe: [{ character: "[", inConstruct: ["label", "phrasing", "reference"] }]
+  };
+  function t(r, l, o, c) {
+    const i = o.createTracker(c);
+    let f = i.move("[^");
+    const h = o.enter("footnoteDefinition"), g = o.enter("label");
+    return f += i.move(
+      o.safe(o.associationId(r), { before: f, after: "]" })
+    ), g(), f += i.move("]:"), r.children && r.children.length > 0 && (i.shift(4), f += i.move(
+      (n ? `
+` : " ") + o.indentLines(
+        o.containerFlow(r, i.current()),
+        n ? m : v
+      )
+    )), h(), f;
+  }
+}
+function v(e, n, t) {
+  return n === 0 ? e : m(e, n, t);
+}
+function m(e, n, t) {
+  return (t ? "" : "    ") + e;
+}
+export {
+  R as gfmFootnoteFromMarkdown,
+  y as gfmFootnoteToMarkdown
+};

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

@@ -0,0 +1,54 @@
+const h = [
+  "autolink",
+  "destinationLiteral",
+  "destinationRaw",
+  "reference",
+  "titleQuote",
+  "titleApostrophe"
+];
+o.attention = k;
+o.peek = l;
+function g() {
+  return {
+    canContainEols: ["delete"],
+    enter: { strikethrough: s },
+    exit: { strikethrough: a }
+  };
+}
+function d() {
+  return {
+    handlers: { delete: o },
+    unsafe: [
+      {
+        character: "~",
+        inConstruct: "phrasing",
+        notInConstruct: h
+      }
+    ]
+  };
+}
+function s(e) {
+  this.enter({ type: "delete", children: [], position: void 0 }, e);
+}
+function a(e) {
+  this.exit(e);
+}
+function o(e, f, t, u) {
+  const n = t.createTracker(u), i = t.stack.includes("strikethrough") ? "~" : "~~", c = t.enter("strikethrough");
+  let r = n.move(i);
+  return r += t.containerPhrasing(e, {
+    ...n.current(),
+    before: r,
+    after: "~"
+  }), r += n.move(i), c(), r;
+}
+function k() {
+  return { construct: "strikethrough", markers: ["~"], sizes: [2, 1] };
+}
+function l() {
+  return "~";
+}
+export {
+  g as gfmStrikethroughFromMarkdown,
+  d as gfmStrikethroughToMarkdown
+};

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

@@ -0,0 +1,135 @@
+import { ok as k } from "../../devlop/lib/default.js";
+import { markdownTable as R } from "../../markdown-table/index.js";
+import { handle as D } from "../../mdast-util-to-markdown/lib/handle/index.js";
+function M() {
+  return {
+    enter: {
+      table: v,
+      tableData: g,
+      tableHeader: g,
+      tableRow: _
+    },
+    exit: {
+      codeText: A,
+      table: y,
+      tableData: u,
+      tableHeader: u,
+      tableRow: u
+    }
+  };
+}
+function v(e) {
+  const l = e._align;
+  this.enter(
+    {
+      type: "table",
+      align: l.map(function(c) {
+        return c === "none" ? null : c;
+      }),
+      children: []
+    },
+    e
+  ), this.data.inTable = !0;
+}
+function y(e) {
+  this.exit(e), this.data.inTable = void 0;
+}
+function _(e) {
+  this.enter({ type: "tableRow", children: [] }, e);
+}
+function u(e) {
+  this.exit(e);
+}
+function g(e) {
+  this.enter({ type: "tableCell", children: [] }, e);
+}
+function A(e) {
+  let l = this.resume();
+  this.data.inTable && (l = l.replace(/\\([\\|])/g, B));
+  const c = this.stack[this.stack.length - 1];
+  k(c.type === "inlineCode"), c.value = l, this.exit(e);
+}
+function B(e, l) {
+  return l === "|" ? l : e;
+}
+function z(e) {
+  const l = e || {}, c = l.tableCellPadding, C = l.tablePipeAlign, x = l.stringLength, h = c ? " " : "|";
+  return {
+    unsafe: [
+      { character: "\r", inConstruct: "tableCell" },
+      { character: `
+`, inConstruct: "tableCell" },
+      // A pipe, when followed by a tab or space (padding), or a dash or colon
+      // (unpadded delimiter row), could result in a table.
+      { atBreak: !0, character: "|", after: "[	 :-]" },
+      // A pipe in a cell must be encoded.
+      { character: "|", inConstruct: "tableCell" },
+      // A colon must be followed by a dash, in which case it could start a
+      // delimiter row.
+      { atBreak: !0, character: ":", after: "-" },
+      // A delimiter row can also start with a dash, when followed by more
+      // dashes, a colon, or a pipe.
+      // This is a stricter version than the built in check for lists, thematic
+      // breaks, and setex heading underlines though:
+      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
+      { atBreak: !0, character: "-", after: "[:|-]" }
+    ],
+    handlers: {
+      inlineCode: m,
+      table: T,
+      tableCell: b,
+      tableRow: p
+    }
+  };
+  function T(t, r, a, n) {
+    return d(w(t, a, n), t.align);
+  }
+  function p(t, r, a, n) {
+    const i = f(t, a, n), o = d([i]);
+    return o.slice(0, o.indexOf(`
+`));
+  }
+  function b(t, r, a, n) {
+    const i = a.enter("tableCell"), o = a.enter("phrasing"), s = a.containerPhrasing(t, {
+      ...n,
+      before: h,
+      after: h
+    });
+    return o(), i(), s;
+  }
+  function d(t, r) {
+    return R(t, {
+      align: r,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      alignDelimiters: C,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      padding: c,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      stringLength: x
+    });
+  }
+  function w(t, r, a) {
+    const n = t.children;
+    let i = -1;
+    const o = [], s = r.enter("table");
+    for (; ++i < n.length; )
+      o[i] = f(n[i], r, a);
+    return s(), o;
+  }
+  function f(t, r, a) {
+    const n = t.children;
+    let i = -1;
+    const o = [], s = r.enter("tableRow");
+    for (; ++i < n.length; )
+      o[i] = b(n[i], t, r, a);
+    return s(), o;
+  }
+  function m(t, r, a) {
+    let n = D.inlineCode(t, r, a);
+    return a.stack.includes("tableCell") && (n = n.replace(/\|/g, "\\$&")), n;
+  }
+}
+export {
+  M as gfmTableFromMarkdown,
+  z as gfmTableToMarkdown
+};

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

@@ -0,0 +1,58 @@
+import { ok as l } from "../../devlop/lib/default.js";
+import { handle as f } from "../../mdast-util-to-markdown/lib/handle/index.js";
+function y() {
+  return {
+    exit: {
+      taskListCheckValueChecked: h,
+      taskListCheckValueUnchecked: h,
+      paragraph: u
+    }
+  };
+}
+function b() {
+  return {
+    unsafe: [{ atBreak: !0, character: "-", after: "[:|-]" }],
+    handlers: { listItem: m }
+  };
+}
+function h(s) {
+  const e = this.stack[this.stack.length - 2];
+  l(e.type === "listItem"), e.checked = s.type === "taskListCheckValueChecked";
+}
+function u(s) {
+  const e = this.stack[this.stack.length - 2];
+  if (e && e.type === "listItem" && typeof e.checked == "boolean") {
+    const i = this.stack[this.stack.length - 1];
+    l(i.type === "paragraph");
+    const t = i.children[0];
+    if (t && t.type === "text") {
+      const a = e.children;
+      let c = -1, n;
+      for (; ++c < a.length; ) {
+        const r = a[c];
+        if (r.type === "paragraph") {
+          n = r;
+          break;
+        }
+      }
+      n === i && (t.value = t.value.slice(1), t.value.length === 0 ? i.children.shift() : i.position && t.position && typeof t.position.start.offset == "number" && (t.position.start.column++, t.position.start.offset++, i.position.start = Object.assign({}, t.position.start)));
+    }
+  }
+  this.exit(s);
+}
+function m(s, e, i, t) {
+  const a = s.children[0], c = typeof s.checked == "boolean" && a && a.type === "paragraph", n = "[" + (s.checked ? "x" : " ") + "] ", r = i.createTracker(t);
+  c && r.move(n);
+  let o = f.listItem(s, e, i, {
+    ...t,
+    ...r.current()
+  });
+  return c && (o = o.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, k)), o;
+  function k(p) {
+    return p + n;
+  }
+}
+export {
+  y as gfmTaskListItemFromMarkdown,
+  b as gfmTaskListItemToMarkdown
+};

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

@@ -0,0 +1,30 @@
+import { convert as e } from "../../unist-util-is/lib/index.js";
+const n = (
+  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */
+  e([
+    "break",
+    "delete",
+    "emphasis",
+    // To do: next major: removed since footnotes were added to GFM.
+    "footnote",
+    "footnoteReference",
+    "image",
+    "imageReference",
+    "inlineCode",
+    // Enabled by `mdast-util-math`:
+    "inlineMath",
+    "link",
+    "linkReference",
+    // Enabled by `mdast-util-mdx`:
+    "mdxJsxTextElement",
+    // Enabled by `mdast-util-mdx`:
+    "mdxTextExpression",
+    "strong",
+    "text",
+    // Enabled by `mdast-util-directive`:
+    "textDirective"
+  ])
+);
+export {
+  n as phrasing
+};

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

@@ -0,0 +1,90 @@
+import x from "../../@ungap/structured-clone/esm/index.js";
+import { normalizeUri as N } from "../../micromark-util-sanitize-uri/index.js";
+function L(e, o) {
+  const r = [{ type: "text", value: "↩" }];
+  return o > 1 && r.push({
+    type: "element",
+    tagName: "sup",
+    properties: {},
+    children: [{ type: "text", value: String(o) }]
+  }), r;
+}
+function k(e, o) {
+  return "Back to reference " + (e + 1) + (o > 1 ? "-" + o : "");
+}
+function C(e) {
+  const o = typeof e.options.clobberPrefix == "string" ? e.options.clobberPrefix : "user-content-", r = e.options.footnoteBackContent || L, s = e.options.footnoteBackLabel || k, y = e.options.footnoteLabel || "Footnotes", g = e.options.footnoteLabelTagName || "h2", b = e.options.footnoteLabelProperties || {
+    className: ["sr-only"]
+  }, f = [];
+  let a = -1;
+  for (; ++a < e.footnoteOrder.length; ) {
+    const p = e.footnoteById.get(
+      e.footnoteOrder[a]
+    );
+    if (!p)
+      continue;
+    const c = e.all(p), u = String(p.identifier).toUpperCase(), d = N(u.toLowerCase());
+    let l = 0;
+    const i = [], h = e.footnoteCounts.get(u);
+    for (; h !== void 0 && ++l <= h; ) {
+      i.length > 0 && i.push({ type: "text", value: " " });
+      let t = typeof r == "string" ? r : r(a, l);
+      typeof t == "string" && (t = { type: "text", value: t }), i.push({
+        type: "element",
+        tagName: "a",
+        properties: {
+          href: "#" + o + "fnref-" + d + (l > 1 ? "-" + l : ""),
+          dataFootnoteBackref: "",
+          ariaLabel: typeof s == "string" ? s : s(a, l),
+          className: ["data-footnote-backref"]
+        },
+        children: Array.isArray(t) ? t : [t]
+      });
+    }
+    const n = c[c.length - 1];
+    if (n && n.type === "element" && n.tagName === "p") {
+      const t = n.children[n.children.length - 1];
+      t && t.type === "text" ? t.value += " " : n.children.push({ type: "text", value: " " }), n.children.push(...i);
+    } else
+      c.push(...i);
+    const m = {
+      type: "element",
+      tagName: "li",
+      properties: { id: o + "fn-" + d },
+      children: e.wrap(c, !0)
+    };
+    e.patch(p, m), f.push(m);
+  }
+  if (f.length !== 0)
+    return {
+      type: "element",
+      tagName: "section",
+      properties: { dataFootnotes: !0, className: ["footnotes"] },
+      children: [
+        {
+          type: "element",
+          tagName: g,
+          properties: {
+            ...x(b),
+            id: "footnote-label"
+          },
+          children: [{ type: "text", value: y }]
+        },
+        { type: "text", value: `
+` },
+        {
+          type: "element",
+          tagName: "ol",
+          properties: {},
+          children: e.wrap(f, !0)
+        },
+        { type: "text", value: `
+` }
+      ]
+    };
+}
+export {
+  L as defaultFootnoteBackContent,
+  k as defaultFootnoteBackLabel,
+  C as footer
+};

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

@@ -0,0 +1,12 @@
+function p(e, r) {
+  const l = {
+    type: "element",
+    tagName: "blockquote",
+    properties: {},
+    children: e.wrap(e.all(r), !0)
+  };
+  return e.patch(r, l), e.applyData(r, l);
+}
+export {
+  p as blockquote
+};

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

@@ -0,0 +1,8 @@
+function a(e, t) {
+  const r = { type: "element", tagName: "br", properties: {}, children: [] };
+  return e.patch(t, r), [e.applyData(t, r), { type: "text", value: `
+` }];
+}
+export {
+  a as hardBreak
+};

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

@@ -0,0 +1,15 @@
+function r(a, e) {
+  const c = e.value ? e.value + `
+` : "", l = {}, p = e.lang ? e.lang.split(/\s+/) : [];
+  p.length > 0 && (l.className = ["language-" + p[0]]);
+  let t = {
+    type: "element",
+    tagName: "code",
+    properties: l,
+    children: [{ type: "text", value: c }]
+  };
+  return e.meta && (t.data = { meta: e.meta }), a.patch(e, t), t = a.applyData(e, t), t = { type: "element", tagName: "pre", properties: {}, children: [t] }, a.patch(e, t), t;
+}
+export {
+  r as code
+};

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

@@ -0,0 +1,12 @@
+function l(e, r) {
+  const t = {
+    type: "element",
+    tagName: "del",
+    properties: {},
+    children: e.all(r)
+  };
+  return e.patch(r, t), e.applyData(r, t);
+}
+export {
+  l as strikethrough
+};

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

@@ -0,0 +1,12 @@
+function t(e, p) {
+  const r = {
+    type: "element",
+    tagName: "em",
+    properties: {},
+    children: e.all(p)
+  };
+  return e.patch(p, r), e.applyData(p, r);
+}
+export {
+  t as emphasis
+};

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

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