impact-nova 2.6.3 → 3.0.0-alpha.1

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

@@ -0,0 +1,225 @@
+import { markdownLineEnding as V } from "../../micromark-util-character/index.js";
+import { push as W, splice as X } from "../../micromark-util-chunked/index.js";
+import { resolveAll as Y } from "../../micromark-util-resolve-all/index.js";
+function re(d, l, u) {
+  let n = {
+    _bufferIndex: -1,
+    _index: 0,
+    line: u && u.line || 1,
+    column: u && u.column || 1,
+    offset: u && u.offset || 0
+  };
+  const f = {}, o = [];
+  let r = [], h = [];
+  const S = {
+    attempt: m(J),
+    check: m(P),
+    consume: D,
+    enter: G,
+    exit: H,
+    interrupt: m(P, {
+      interrupt: !0
+    })
+  }, t = {
+    code: null,
+    containerState: {},
+    defineSkip: R,
+    events: [],
+    now: v,
+    parser: d,
+    previous: null,
+    sliceSerialize: M,
+    sliceStream: j,
+    write: L
+  };
+  let O = l.tokenize.call(t, S);
+  return l.resolveAll && o.push(l), t;
+  function L(e) {
+    return r = W(r, e), q(), r[r.length - 1] !== null ? [] : (T(l, 0), t.events = Y(o, t.events, t), t.events);
+  }
+  function M(e, s) {
+    return $(j(e), s);
+  }
+  function j(e) {
+    return Z(r, e);
+  }
+  function v() {
+    const {
+      _bufferIndex: e,
+      _index: s,
+      line: c,
+      column: a,
+      offset: p
+    } = n;
+    return {
+      _bufferIndex: e,
+      _index: s,
+      line: c,
+      column: a,
+      offset: p
+    };
+  }
+  function R(e) {
+    f[e.line] = e.column, g();
+  }
+  function q() {
+    for (; n._index < r.length; ) {
+      const e = r[n._index];
+      if (typeof e == "string") {
+        const s = n._index;
+        for (n._bufferIndex < 0 && (n._bufferIndex = 0); n._index === s && n._bufferIndex < e.length; )
+          z(e.charCodeAt(n._bufferIndex));
+      } else
+        z(e);
+    }
+  }
+  function z(e) {
+    O = O(e);
+  }
+  function D(e) {
+    V(e) ? (n.line++, n.column = 1, n.offset += e === -3 ? 2 : 1, g()) : e !== -1 && (n.column++, n.offset++), n._bufferIndex < 0 ? n._index++ : (n._bufferIndex++, n._bufferIndex === // Points w/ non-negative `_bufferIndex` reference
+    // strings.
+    /** @type {string} */
+    r[n._index].length && (n._bufferIndex = -1, n._index++)), t.previous = e;
+  }
+  function G(e, s) {
+    const c = s || {};
+    return c.type = e, c.start = v(), t.events.push(["enter", c, t]), h.push(c), c;
+  }
+  function H(e) {
+    const s = h.pop();
+    return s.end = v(), t.events.push(["exit", s, t]), s;
+  }
+  function J(e, s) {
+    T(e, s.from);
+  }
+  function P(e, s) {
+    s.restore();
+  }
+  function m(e, s) {
+    return c;
+    function c(a, p, _) {
+      let C, k, B, y;
+      return Array.isArray(a) ? (
+        /* c8 ignore next 1 */
+        A(a)
+      ) : "tokenize" in a ? (
+        // Looks like a construct.
+        A([
+          /** @type {Construct} */
+          a
+        ])
+      ) : N(a);
+      function N(i) {
+        return w;
+        function w(x) {
+          const b = x !== null && i[x], I = x !== null && i.null, U = [
+            // To do: add more extension tests.
+            /* c8 ignore next 2 */
+            ...Array.isArray(b) ? b : b ? [b] : [],
+            ...Array.isArray(I) ? I : I ? [I] : []
+          ];
+          return A(U)(x);
+        }
+      }
+      function A(i) {
+        return C = i, k = 0, i.length === 0 ? _ : E(i[k]);
+      }
+      function E(i) {
+        return w;
+        function w(x) {
+          return y = K(), B = i, i.partial || (t.currentConstruct = i), i.name && t.parser.constructs.disable.null.includes(i.name) ? F() : i.tokenize.call(
+            // If we do have fields, create an object w/ `context` as its
+            // prototype.
+            // This allows a “live binding”, which is needed for `interrupt`.
+            s ? Object.assign(Object.create(t), s) : t,
+            S,
+            Q,
+            F
+          )(x);
+        }
+      }
+      function Q(i) {
+        return e(B, y), p;
+      }
+      function F(i) {
+        return y.restore(), ++k < C.length ? E(C[k]) : _;
+      }
+    }
+  }
+  function T(e, s) {
+    e.resolveAll && !o.includes(e) && o.push(e), e.resolve && X(t.events, s, t.events.length - s, e.resolve(t.events.slice(s), t)), e.resolveTo && (t.events = e.resolveTo(t.events, t));
+  }
+  function K() {
+    const e = v(), s = t.previous, c = t.currentConstruct, a = t.events.length, p = Array.from(h);
+    return {
+      from: a,
+      restore: _
+    };
+    function _() {
+      n = e, t.previous = s, t.currentConstruct = c, t.events.length = a, h = p, g();
+    }
+  }
+  function g() {
+    n.line in f && n.column < 2 && (n.column = f[n.line], n.offset += f[n.line] - 1);
+  }
+}
+function Z(d, l) {
+  const u = l.start._index, n = l.start._bufferIndex, f = l.end._index, o = l.end._bufferIndex;
+  let r;
+  if (u === f)
+    r = [d[u].slice(n, o)];
+  else {
+    if (r = d.slice(u, f), n > -1) {
+      const h = r[0];
+      typeof h == "string" ? r[0] = h.slice(n) : r.shift();
+    }
+    o > 0 && r.push(d[f].slice(0, o));
+  }
+  return r;
+}
+function $(d, l) {
+  let u = -1;
+  const n = [];
+  let f;
+  for (; ++u < d.length; ) {
+    const o = d[u];
+    let r;
+    if (typeof o == "string")
+      r = o;
+    else
+      switch (o) {
+        case -5: {
+          r = "\r";
+          break;
+        }
+        case -4: {
+          r = `
+`;
+          break;
+        }
+        case -3: {
+          r = `\r
+`;
+          break;
+        }
+        case -2: {
+          r = l ? " " : "	";
+          break;
+        }
+        case -1: {
+          if (!l && f)
+            continue;
+          r = " ";
+          break;
+        }
+        default:
+          r = String.fromCharCode(o);
+      }
+    f = o === -2, n.push(r);
+  }
+  return n.join("");
+}
+export {
+  re as createTokenizer
+};

package/dist/node_modules/micromark/lib/initialize/content.js

@@ -0,0 +1,37 @@
+import { factorySpace as l } from "../../../micromark-factory-space/index.js";
+import { markdownLineEnding as m } from "../../../micromark-util-character/index.js";
+const g = {
+  tokenize: x
+};
+function x(n) {
+  const i = n.attempt(this.parser.constructs.contentInitial, e, p);
+  let r;
+  return i;
+  function e(t) {
+    if (t === null) {
+      n.consume(t);
+      return;
+    }
+    return n.enter("lineEnding"), n.consume(t), n.exit("lineEnding"), l(n, i, "linePrefix");
+  }
+  function p(t) {
+    return n.enter("paragraph"), u(t);
+  }
+  function u(t) {
+    const a = n.enter("chunkText", {
+      contentType: "text",
+      previous: r
+    });
+    return r && (r.next = a), r = a, o(t);
+  }
+  function o(t) {
+    if (t === null) {
+      n.exit("chunkText"), n.exit("paragraph"), n.consume(t);
+      return;
+    }
+    return m(t) ? (n.consume(t), n.exit("chunkText"), u) : (n.consume(t), o);
+  }
+}
+export {
+  g as content
+};

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

@@ -0,0 +1,128 @@
+import { factorySpace as I } from "../../../micromark-factory-space/index.js";
+import { markdownLineEnding as N } from "../../../micromark-util-character/index.js";
+import { EditMap as y } from "../../../micromark-util-edit-map/index.js";
+const L = {
+  tokenize: T
+}, z = {
+  tokenize: M
+};
+function T(i) {
+  const n = this, l = [];
+  let s = 0, t, d, w;
+  return h;
+  function h(e) {
+    if (s < l.length) {
+      const r = l[s];
+      return n.containerState = r[1], i.attempt(r[0].continuation, B, p)(e);
+    }
+    return p(e);
+  }
+  function B(e) {
+    if (s++, n.containerState._closeFlow) {
+      n.containerState._closeFlow = void 0, t && x();
+      const r = n.events.length;
+      let u = r, o;
+      for (; u--; )
+        if (n.events[u][0] === "exit" && n.events[u][1].type === "chunkFlow") {
+          o = n.events[u][1].end;
+          break;
+        }
+      f(s);
+      let c = r;
+      for (; c < n.events.length; )
+        n.events[c][1].end = {
+          ...o
+        }, c++;
+      const a = new y();
+      return a.add(u + 1, 0, n.events.slice(r)), a.add(r, c - r, []), a.consume(n.events), p(e);
+    }
+    return h(e);
+  }
+  function p(e) {
+    if (s === l.length) {
+      if (!t)
+        return m(e);
+      if (t.currentConstruct && t.currentConstruct.concrete)
+        return v(e);
+      n.interrupt = !!(t.currentConstruct && !t._gfmTableDynamicInterruptHack);
+    }
+    return n.containerState = {}, i.check(z, _, b)(e);
+  }
+  function _(e) {
+    return t && x(), f(s), m(e);
+  }
+  function b(e) {
+    return n.parser.lazy[n.now().line] = s !== l.length, w = n.now().offset, v(e);
+  }
+  function m(e) {
+    return n.containerState = {}, i.attempt(z, E, v)(e);
+  }
+  function E(e) {
+    return s++, l.push([n.currentConstruct, n.containerState]), m(e);
+  }
+  function v(e) {
+    if (e === null) {
+      t && x(), f(0), i.consume(e);
+      return;
+    }
+    return t = t || n.parser.flow(n.now()), i.enter("chunkFlow", {
+      _tokenizer: t,
+      contentType: "flow",
+      previous: d
+    }), k(e);
+  }
+  function k(e) {
+    if (e === null) {
+      S(i.exit("chunkFlow"), !0), f(0), i.consume(e);
+      return;
+    }
+    return N(e) ? (i.consume(e), S(i.exit("chunkFlow")), s = 0, n.interrupt = void 0, h) : (i.consume(e), k);
+  }
+  function S(e, r) {
+    const u = n.sliceStream(e);
+    if (r && u.push(null), e.previous = d, d && (d.next = e), d = e, t.defineSkip(e.start), t.write(u), n.parser.lazy[e.start.line]) {
+      let o = t.events.length;
+      for (; o--; )
+        if (
+          // The token starts before the line ending…
+          t.events[o][1].start.offset < w && // …and either is not ended yet…
+          (!t.events[o][1].end || // …or ends after it.
+          t.events[o][1].end.offset > w)
+        )
+          return;
+      const c = n.events.length;
+      let a = c, g, F;
+      for (; a--; )
+        if (n.events[a][0] === "exit" && n.events[a][1].type === "chunkFlow") {
+          if (g) {
+            F = n.events[a][1].end;
+            break;
+          }
+          g = !0;
+        }
+      for (f(s), o = c; o < n.events.length; )
+        n.events[o][1].end = {
+          ...F
+        }, o++;
+      const C = new y();
+      C.add(a + 1, 0, n.events.slice(c)), C.add(c, o - c, []), C.consume(n.events);
+    }
+  }
+  function f(e) {
+    let r = l.length;
+    for (; r-- > e; ) {
+      const u = l[r];
+      n.containerState = u[1], u[0].exit.call(n, i);
+    }
+    l.length = e;
+  }
+  function x() {
+    t.write([null]), d = void 0, t = void 0, n.containerState._closeFlow = void 0;
+  }
+}
+function M(i, n, l) {
+  return I(i, i.attempt(this.parser.constructs.document, n, l), "linePrefix", this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+}
+export {
+  L as document
+};

package/dist/node_modules/micromark/lib/initialize/flow.js

@@ -0,0 +1,33 @@
+import { factorySpace as l } from "../../../micromark-factory-space/index.js";
+import { blankLine as a } from "../../../micromark-core-commonmark/lib/blank-line.js";
+import { content as e } from "../../../micromark-core-commonmark/lib/content.js";
+const d = {
+  tokenize: m
+};
+function m(n) {
+  const o = this, i = n.attempt(
+    // Try to parse a blank line.
+    a,
+    u,
+    // Try to parse initial flow (essentially, only code).
+    n.attempt(this.parser.constructs.flowInitial, r, l(n, n.attempt(this.parser.constructs.flow, r, n.attempt(e, r)), "linePrefix"))
+  );
+  return i;
+  function u(t) {
+    if (t === null) {
+      n.consume(t);
+      return;
+    }
+    return n.enter("lineEndingBlank"), n.consume(t), n.exit("lineEndingBlank"), o.currentConstruct = void 0, i;
+  }
+  function r(t) {
+    if (t === null) {
+      n.consume(t);
+      return;
+    }
+    return n.enter("lineEnding"), n.consume(t), n.exit("lineEnding"), o.currentConstruct = void 0, i;
+  }
+}
+export {
+  d as flow
+};

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

@@ -0,0 +1,98 @@
+import { EditMap as g } from "../../../micromark-util-edit-map/index.js";
+const y = {
+  resolveAll: p()
+}, b = x("string"), T = x("text");
+function x(i) {
+  return {
+    resolveAll: p(i === "text" ? m : void 0),
+    tokenize: o
+  };
+  function o(n) {
+    const r = this, t = this.parser.constructs[i], l = n.attempt(t, f, u);
+    return f;
+    function f(e) {
+      return s(e) ? l(e) : u(e);
+    }
+    function u(e) {
+      if (e === null) {
+        n.consume(e);
+        return;
+      }
+      return n.enter("data"), n.consume(e), a;
+    }
+    function a(e) {
+      return s(e) ? (n.exit("data"), l(e)) : (n.consume(e), a);
+    }
+    function s(e) {
+      if (e === null)
+        return !0;
+      const d = t[e];
+      let c = -1;
+      if (d)
+        for (; ++c < d.length; ) {
+          const h = d[c];
+          if (!h.previous || h.previous.call(r, r.previous))
+            return !0;
+        }
+      return !1;
+    }
+  }
+}
+function p(i) {
+  return o;
+  function o(n, r) {
+    let t = -1, l;
+    for (; ++t <= n.length; )
+      l === void 0 ? n[t] && n[t][1].type === "data" && (l = t, t++) : (!n[t] || n[t][1].type !== "data") && (t !== l + 2 && (n[l][1].end = n[t - 1][1].end, n.splice(l + 2, t - l - 2), t = l + 2), l = void 0);
+    return i ? i(n, r) : n;
+  }
+}
+function m(i, o) {
+  const n = new g();
+  let r = 0;
+  for (; ++r <= i.length; )
+    if ((r === i.length || i[r][1].type === "lineEnding") && i[r - 1][1].type === "data") {
+      const t = i[r - 1][1], l = o.sliceStream(t);
+      let f = l.length, u = -1, a = 0, s;
+      for (; f--; ) {
+        const e = l[f];
+        if (typeof e == "string") {
+          for (u = e.length; e.charCodeAt(u - 1) === 32; )
+            a++, u--;
+          if (u)
+            break;
+          u = -1;
+        } else if (e === -2)
+          s = !0, a++;
+        else if (e !== -1) {
+          f++;
+          break;
+        }
+      }
+      if (o._contentTypeTextTrailing && r === i.length && (a = 0), a) {
+        const e = {
+          type: r === i.length || s || a < 2 ? "lineSuffix" : "hardBreakTrailing",
+          start: {
+            _bufferIndex: f ? u : t.start._bufferIndex + u,
+            _index: t.start._index + f,
+            line: t.end.line,
+            column: t.end.column - a,
+            offset: t.end.offset - a
+          },
+          end: {
+            ...t.end
+          }
+        };
+        t.end = {
+          ...e.start
+        }, t.start.offset === t.end.offset ? Object.assign(t, e) : n.add(r, 0, [["enter", e, o], ["exit", e, o]]);
+      }
+      r++;
+    }
+  return n.consume(i), i;
+}
+export {
+  y as resolver,
+  b as string,
+  T as text
+};

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

@@ -0,0 +1,32 @@
+import { combineExtensions as c } from "../../micromark-util-combine-extensions/index.js";
+import { content as i } from "./initialize/content.js";
+import { document as m } from "./initialize/document.js";
+import { flow as f } from "./initialize/flow.js";
+import { text as u, string as p } from "./initialize/text.js";
+import * as a from "./constructs.js";
+import { createTokenizer as x } from "./create-tokenizer.js";
+function y(r) {
+  const o = {
+    constructs: (
+      /** @type {FullNormalizedExtension} */
+      c([a, ...(r || {}).extensions || []])
+    ),
+    content: t(i),
+    defined: [],
+    document: t(m),
+    flow: t(f),
+    lazy: {},
+    string: t(p),
+    text: t(u)
+  };
+  return o;
+  function t(n) {
+    return e;
+    function e(s) {
+      return x(o, n, s);
+    }
+  }
+}
+export {
+  y as parse
+};

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

@@ -0,0 +1,9 @@
+import { subtokenize as r } from "../../micromark-util-subtokenize/index.js";
+function e(o) {
+  for (; !r(o); )
+    ;
+  return o;
+}
+export {
+  e as postprocess
+};

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

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

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

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