@glodon-aiot/agent-cli-ui 2.4.7 → 3.0.4

package/dist/es/node_modules/longest-streak/index.mjs

@@ -0,0 +1,12 @@
+function f(l, t) {
+  const i = String(l);
+  let e = i.indexOf(t), n = e, o = 0, r = 0;
+  if (typeof t != "string")
+    throw new TypeError("Expected substring");
+  for (; e !== -1; )
+    e === n ? ++o > r && (r = o) : o = 1, n = e + t.length, e = i.indexOf(t, n);
+  return r;
+}
+export {
+  f as longestStreak
+};

package/dist/es/node_modules/mdast-util-math/lib/index.mjs

@@ -0,0 +1,170 @@
+var $ = Object.defineProperty;
+var w = Object.getOwnPropertySymbols;
+var g = Object.prototype.hasOwnProperty, k = Object.prototype.propertyIsEnumerable;
+var F = (r, a, i) => a in r ? $(r, a, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[a] = i, M = (r, a) => {
+  for (var i in a || (a = {}))
+    g.call(a, i) && F(r, i, a[i]);
+  if (w)
+    for (var i of w(a))
+      k.call(a, i) && F(r, i, a[i]);
+  return r;
+};
+import { ok as u } from "../../devlop/lib/default.mjs";
+import { longestStreak as v } from "../../longest-streak/index.mjs";
+function N() {
+  return {
+    enter: {
+      mathFlow: r,
+      mathFlowFenceMeta: a,
+      mathText: s
+    },
+    exit: {
+      mathFlow: p,
+      mathFlowFence: m,
+      mathFlowFenceMeta: i,
+      mathFlowValue: h,
+      mathText: x,
+      mathTextData: h
+    }
+  };
+  function r(t) {
+    const e = {
+      type: "element",
+      tagName: "code",
+      properties: {
+        className: ["language-math", "math-display"]
+      },
+      children: []
+    };
+    this.enter({
+      type: "math",
+      meta: null,
+      value: "",
+      data: {
+        hName: "pre",
+        hChildren: [e]
+      }
+    }, t);
+  }
+  function a() {
+    this.buffer();
+  }
+  function i() {
+    const t = this.resume(), e = this.stack[this.stack.length - 1];
+    u(e.type === "math"), e.meta = t;
+  }
+  function m() {
+    this.data.mathFlowInside || (this.buffer(), this.data.mathFlowInside = !0);
+  }
+  function p(t) {
+    const e = this.resume().replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, ""), n = this.stack[this.stack.length - 1];
+    u(n.type === "math"), this.exit(t), n.value = e;
+    const o = (
+      /** @type {HastElement} */
+      n.data.hChildren[0]
+    );
+    u(o.type === "element"), u(o.tagName === "code"), o.children.push({
+      type: "text",
+      value: e
+    }), this.data.mathFlowInside = void 0;
+  }
+  function s(t) {
+    this.enter({
+      type: "inlineMath",
+      value: "",
+      data: {
+        hName: "code",
+        hProperties: {
+          className: ["language-math", "math-inline"]
+        },
+        hChildren: []
+      }
+    }, t), this.buffer();
+  }
+  function x(t) {
+    const e = this.resume(), n = this.stack[this.stack.length - 1];
+    u(n.type === "inlineMath"), this.exit(t), n.value = e, /** @type {Array<HastElementContent>} */
+    // @ts-expect-error: we defined it in `enterMathFlow`.
+    n.data.hChildren.push({
+      type: "text",
+      value: e
+    });
+  }
+  function h(t) {
+    this.config.enter.data.call(this, t), this.config.exit.data.call(this, t);
+  }
+}
+function b(r) {
+  let a = (r || {}).singleDollarTextMath;
+  return a == null && (a = !0), m.peek = p, {
+    unsafe: [{
+      character: "\r",
+      inConstruct: "mathFlowMeta"
+    }, {
+      character: `
+`,
+      inConstruct: "mathFlowMeta"
+    }, {
+      character: "$",
+      after: a ? void 0 : "\\$",
+      inConstruct: "phrasing"
+    }, {
+      character: "$",
+      inConstruct: "mathFlowMeta"
+    }, {
+      atBreak: !0,
+      character: "$",
+      after: "\\$"
+    }],
+    handlers: {
+      math: i,
+      inlineMath: m
+    }
+  };
+  function i(s, x, h, t) {
+    const e = s.value || "", n = h.createTracker(t), o = "$".repeat(Math.max(v(e, "$") + 1, 2)), d = h.enter("mathFlow");
+    let c = n.move(o);
+    if (s.meta) {
+      const l = h.enter("mathFlowMeta");
+      c += n.move(h.safe(s.meta, M({
+        after: `
+`,
+        before: c,
+        encode: ["$"]
+      }, n.current()))), l();
+    }
+    return c += n.move(`
+`), e && (c += n.move(e + `
+`)), c += n.move(o), d(), c;
+  }
+  function m(s, x, h) {
+    let t = s.value || "", e = 1;
+    for (a || e++; new RegExp("(^|[^$])" + "\\$".repeat(e) + "([^$]|$)").test(t); )
+      e++;
+    const n = "$".repeat(e);
+    // Contains non-space.
+    /[^ \r\n]/.test(t) && // Starts with space and ends with space.
+    (/^[ \r\n]/.test(t) && /[ \r\n]$/.test(t) || // Starts or ends with dollar.
+    /^\$|\$$/.test(t)) && (t = " " + t + " ");
+    let o = -1;
+    for (; ++o < h.unsafe.length; ) {
+      const d = h.unsafe[o];
+      if (!d.atBreak)
+        continue;
+      const c = h.compilePattern(d);
+      let l;
+      for (; l = c.exec(t); ) {
+        let f = l.index;
+        t.codePointAt(f) === 10 && t.codePointAt(f - 1) === 13 && f--, t = t.slice(0, f) + " " + t.slice(l.index + 1);
+      }
+    }
+    return n + t + n;
+  }
+  function p() {
+    return "$";
+  }
+}
+export {
+  N as mathFromMarkdown,
+  b as mathToMarkdown
+};

package/dist/es/node_modules/micromark-extension-math/lib/math-flow.mjs

@@ -0,0 +1,76 @@
+import { factorySpace as h } from "../../micromark-factory-space/index.mjs";
+import { markdownLineEnding as a } from "../../micromark-util-character/index.mjs";
+const A = {
+  tokenize: v,
+  concrete: !0,
+  name: "mathFlow"
+}, q = {
+  tokenize: N,
+  partial: !0
+};
+function v(t, l, o) {
+  const i = this, u = i.events[i.events.length - 1], m = u && u[1].type === "linePrefix" ? u[2].sliceSerialize(u[1], !0).length : 0;
+  let r = 0;
+  return k;
+  function k(n) {
+    return t.enter("mathFlow"), t.enter("mathFlowFence"), t.enter("mathFlowFenceSequence"), p(n);
+  }
+  function p(n) {
+    return n === 36 ? (t.consume(n), r++, p) : r < 2 ? o(n) : (t.exit("mathFlowFenceSequence"), h(t, y, "whitespace")(n));
+  }
+  function y(n) {
+    return n === null || a(n) ? x(n) : (t.enter("mathFlowFenceMeta"), t.enter("chunkString", {
+      contentType: "string"
+    }), z(n));
+  }
+  function z(n) {
+    return n === null || a(n) ? (t.exit("chunkString"), t.exit("mathFlowFenceMeta"), x(n)) : n === 36 ? o(n) : (t.consume(n), z);
+  }
+  function x(n) {
+    return t.exit("mathFlowFence"), i.interrupt ? l(n) : t.attempt(q, S, F)(n);
+  }
+  function S(n) {
+    return t.attempt({
+      tokenize: L,
+      partial: !0
+    }, F, b)(n);
+  }
+  function b(n) {
+    return (m ? h(t, w, "linePrefix", m + 1) : w)(n);
+  }
+  function w(n) {
+    return n === null ? F(n) : a(n) ? t.attempt(q, S, F)(n) : (t.enter("mathFlowValue"), c(n));
+  }
+  function c(n) {
+    return n === null || a(n) ? (t.exit("mathFlowValue"), w(n)) : (t.consume(n), c);
+  }
+  function F(n) {
+    return t.exit("mathFlow"), l(n);
+  }
+  function L(n, E, s) {
+    let C = 0;
+    return h(n, M, "linePrefix", i.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+    function M(e) {
+      return n.enter("mathFlowFence"), n.enter("mathFlowFenceSequence"), g(e);
+    }
+    function g(e) {
+      return e === 36 ? (C++, n.consume(e), g) : C < r ? s(e) : (n.exit("mathFlowFenceSequence"), h(n, P, "whitespace")(e));
+    }
+    function P(e) {
+      return e === null || a(e) ? (n.exit("mathFlowFence"), E(e)) : s(e);
+    }
+  }
+}
+function N(t, l, o) {
+  const i = this;
+  return u;
+  function u(r) {
+    return r === null ? l(r) : (t.enter("lineEnding"), t.consume(r), t.exit("lineEnding"), m);
+  }
+  function m(r) {
+    return i.parser.lazy[i.now().line] ? o(r) : l(r);
+  }
+}
+export {
+  A as mathFlow
+};

package/dist/es/node_modules/micromark-extension-math/lib/math-text.mjs

@@ -0,0 +1,48 @@
+import { markdownLineEnding as y } from "../../micromark-util-character/index.mjs";
+function k(e) {
+  let a = (e || {}).singleDollarTextMath;
+  return a == null && (a = !0), {
+    tokenize: i,
+    resolve: d,
+    previous: q,
+    name: "mathText"
+  };
+  function i(n, o, p) {
+    let l = 0, x, m;
+    return E;
+    function E(t) {
+      return n.enter("mathText"), n.enter("mathTextSequence"), T(t);
+    }
+    function T(t) {
+      return t === 36 ? (n.consume(t), l++, T) : l < 2 && !a ? p(t) : (n.exit("mathTextSequence"), u(t));
+    }
+    function u(t) {
+      return t === null ? p(t) : t === 36 ? (m = n.enter("mathTextSequence"), x = 0, g(t)) : t === 32 ? (n.enter("space"), n.consume(t), n.exit("space"), u) : y(t) ? (n.enter("lineEnding"), n.consume(t), n.exit("lineEnding"), u) : (n.enter("mathTextData"), h(t));
+    }
+    function h(t) {
+      return t === null || t === 32 || t === 36 || y(t) ? (n.exit("mathTextData"), u(t)) : (n.consume(t), h);
+    }
+    function g(t) {
+      return t === 36 ? (n.consume(t), x++, g) : x === l ? (n.exit("mathTextSequence"), n.exit("mathText"), o(t)) : (m.type = "mathTextData", h(t));
+    }
+  }
+}
+function d(e) {
+  let r = e.length - 4, a = 3, i, n;
+  if ((e[a][1].type === "lineEnding" || e[a][1].type === "space") && (e[r][1].type === "lineEnding" || e[r][1].type === "space")) {
+    for (i = a; ++i < r; )
+      if (e[i][1].type === "mathTextData") {
+        e[r][1].type = "mathTextPadding", e[a][1].type = "mathTextPadding", a += 2, r -= 2;
+        break;
+      }
+  }
+  for (i = a - 1, r++; ++i <= r; )
+    n === void 0 ? i !== r && e[i][1].type !== "lineEnding" && (n = i) : (i === r || e[i][1].type === "lineEnding") && (e[n][1].type = "mathTextData", i !== n + 2 && (e[n][1].end = e[i - 1][1].end, e.splice(n + 2, i - n - 2), r -= i - n - 2, i = n + 2), n = void 0);
+  return e;
+}
+function q(e) {
+  return e !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+export {
+  k as mathText
+};

package/dist/es/node_modules/micromark-extension-math/lib/syntax.mjs

@@ -0,0 +1,15 @@
+import { mathFlow as o } from "./math-flow.mjs";
+import { mathText as m } from "./math-text.mjs";
+function f(t) {
+  return {
+    flow: {
+      36: o
+    },
+    text: {
+      36: m(t)
+    }
+  };
+}
+export {
+  f as math
+};

package/dist/es/node_modules/micromark-factory-space/index.mjs

@@ -0,0 +1,15 @@
+import { markdownSpace as m } from "../micromark-util-character/index.mjs";
+function p(n, t, i, u) {
+  const o = u ? u - 1 : Number.POSITIVE_INFINITY;
+  let I = 0;
+  return a;
+  function a(r) {
+    return m(r) ? (n.enter(i), e(r)) : t(r);
+  }
+  function e(r) {
+    return m(r) && I++ < o ? (n.consume(r), e) : (n.exit(i), t(r));
+  }
+}
+export {
+  p as factorySpace
+};

package/dist/es/node_modules/micromark-util-character/index.mjs

@@ -0,0 +1,10 @@
+function r(n) {
+  return n !== null && n < -2;
+}
+function t(n) {
+  return n === -2 || n === -1 || n === 32;
+}
+export {
+  r as markdownLineEnding,
+  t as markdownSpace
+};

package/dist/es/node_modules/rehype-katex/lib/index.mjs

@@ -0,0 +1,83 @@
+var S = Object.defineProperty, T = Object.defineProperties;
+var k = Object.getOwnPropertyDescriptors;
+var y = Object.getOwnPropertySymbols;
+var K = Object.prototype.hasOwnProperty, v = Object.prototype.propertyIsEnumerable;
+var x = (r, t, e) => t in r ? S(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, h = (r, t) => {
+  for (var e in t || (t = {}))
+    K.call(t, e) && x(r, e, t[e]);
+  if (y)
+    for (var e of y(t))
+      v.call(t, e) && x(r, e, t[e]);
+  return r;
+}, u = (r, t) => T(r, k(t));
+import { fromHtmlIsomorphic as A } from "../../hast-util-from-html-isomorphic/lib/browser.mjs";
+import N from "../../katex/dist/katex.mjs";
+import { visitParents as E, SKIP as M } from "../../unist-util-visit-parents/lib/index.mjs";
+import { toText as P } from "../../hast-util-to-text/lib/index.mjs";
+const D = {}, H = [];
+function B(r) {
+  const t = r || D;
+  return function(e, w) {
+    E(e, "element", function(n, a) {
+      const i = Array.isArray(n.properties.className) ? n.properties.className : H, d = i.includes("language-math"), f = i.includes("math-display"), C = i.includes("math-inline");
+      let c = f;
+      if (!d && !f && !C)
+        return;
+      let o = a[a.length - 1], l = n;
+      if (n.tagName === "code" && d && o && o.type === "element" && o.tagName === "pre" && (l = o, o = a[a.length - 2], c = !0), !o)
+        return;
+      const p = P(l, {
+        whitespace: "pre"
+      });
+      let s;
+      try {
+        s = N.renderToString(p, u(h({}, t), {
+          displayMode: c,
+          throwOnError: !0
+        }));
+      } catch (m) {
+        const g = (
+          /** @type {Error} */
+          m
+        ), O = g.name.toLowerCase();
+        w.message("Could not render math with KaTeX", {
+          ancestors: [...a, n],
+          cause: g,
+          place: n.position,
+          ruleId: O,
+          source: "rehype-katex"
+        });
+        try {
+          s = N.renderToString(p, u(h({}, t), {
+            displayMode: c,
+            strict: "ignore",
+            throwOnError: !1
+          }));
+        } catch (L) {
+          s = [{
+            type: "element",
+            tagName: "span",
+            properties: {
+              className: ["katex-error"],
+              style: "color:" + (t.errorColor || "#cc0000"),
+              title: String(m)
+            },
+            children: [{
+              type: "text",
+              value: p
+            }]
+          }];
+        }
+      }
+      typeof s == "string" && (s = /** @type {Array<ElementContent>} */
+      A(s, {
+        fragment: !0
+      }).children);
+      const I = o.children.indexOf(l);
+      return o.children.splice(I, 1, ...s), M;
+    });
+  };
+}
+export {
+  B as default
+};

package/dist/es/node_modules/remark-math/lib/index.mjs

@@ -0,0 +1,13 @@
+import { math as i } from "../../micromark-extension-math/lib/syntax.mjs";
+import { mathFromMarkdown as e, mathToMarkdown as k } from "../../mdast-util-math/lib/index.mjs";
+const c = {};
+function E(t) {
+  const s = (
+    /** @type {Processor} */
+    this
+  ), n = t || c, o = s.data(), r = o.micromarkExtensions || (o.micromarkExtensions = []), a = o.fromMarkdownExtensions || (o.fromMarkdownExtensions = []), m = o.toMarkdownExtensions || (o.toMarkdownExtensions = []);
+  r.push(i(n)), a.push(e()), m.push(k(n));
+}
+export {
+  E as default
+};

package/dist/es/node_modules/space-separated-tokens/index.mjs

@@ -0,0 +1,7 @@
+function r(n) {
+  const t = String(n || "").trim();
+  return t ? t.split(/[ \t\n\r\f]+/g) : [];
+}
+export {
+  r as parse
+};

package/dist/es/node_modules/unist-util-find-after/lib/index.mjs

@@ -0,0 +1,32 @@
+import { convert as t } from "../../unist-util-is/lib/index.mjs";
+const f = (
+  // Note: overloads like this are needed to support optional generics.
+  /**
+   * @type {(
+   *   (<Kind extends UnistParent, Check extends Test>(parent: Kind, index: Child<Kind> | number, test: Check) => Matches<Child<Kind>, Check> | undefined) &
+   *   (<Kind extends UnistParent>(parent: Kind, index: Child<Kind> | number, test?: null | undefined) => Child<Kind> | undefined)
+   * )}
+   */
+  /**
+   * @param {UnistParent} parent
+   * @param {UnistNode | number} index
+   * @param {Test} [test]
+   * @returns {UnistNode | undefined}
+   */
+  function(e, r, o) {
+    const i = t(o);
+    if (!e || !e.type || !e.children)
+      throw new Error("Expected parent node");
+    if (typeof r == "number") {
+      if (r < 0 || r === Number.POSITIVE_INFINITY)
+        throw new Error("Expected positive finite number as index");
+    } else if (r = e.children.indexOf(r), r < 0)
+      throw new Error("Expected child node or index");
+    for (; ++r < e.children.length; )
+      if (i(e.children[r], r, e))
+        return e.children[r];
+  }
+);
+export {
+  f as findAfter
+};

package/dist/es/node_modules/unist-util-is/lib/index.mjs

@@ -0,0 +1,81 @@
+const i = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
+   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
+   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
+   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test} [test]
+   * @returns {Check}
+   */
+  function(n) {
+    if (n == null)
+      return p;
+    if (typeof n == "function")
+      return c(n);
+    if (typeof n == "object")
+      return Array.isArray(n) ? f(n) : y(n);
+    if (typeof n == "string")
+      return l(n);
+    throw new Error("Expected function, string, or object as test");
+  }
+);
+function f(n) {
+  const e = [];
+  let r = -1;
+  for (; ++r < n.length; )
+    e[r] = i(n[r]);
+  return c(t);
+  function t(...u) {
+    let o = -1;
+    for (; ++o < e.length; )
+      if (e[o].apply(this, u))
+        return !0;
+    return !1;
+  }
+}
+function y(n) {
+  const e = (
+    /** @type {Record<string, unknown>} */
+    n
+  );
+  return c(r);
+  function r(t) {
+    const u = (
+      /** @type {Record<string, unknown>} */
+      /** @type {unknown} */
+      t
+    );
+    let o;
+    for (o in n)
+      if (u[o] !== e[o])
+        return !1;
+    return !0;
+  }
+}
+function l(n) {
+  return c(e);
+  function e(r) {
+    return r && r.type === n;
+  }
+}
+function c(n) {
+  return e;
+  function e(r, t, u) {
+    return !!(a(r) && n.call(this, r, typeof t == "number" ? t : void 0, u || void 0));
+  }
+}
+function p() {
+  return !0;
+}
+function a(n) {
+  return n !== null && typeof n == "object" && "type" in n;
+}
+export {
+  i as convert
+};

package/dist/es/node_modules/unist-util-visit-parents/lib/color.mjs

@@ -0,0 +1,6 @@
+function r(o) {
+  return o;
+}
+export {
+  r as color
+};

package/dist/es/node_modules/unist-util-visit-parents/lib/index.mjs

@@ -0,0 +1,56 @@
+import { color as A } from "./color.mjs";
+import { convert as I } from "../../unist-util-is/lib/index.mjs";
+const g = [], j = !0, a = !1, k = "skip";
+function w(t, o, u, s) {
+  let p;
+  typeof o == "function" && typeof u != "function" ? (s = u, u = o) : p = o;
+  const b = I(p), y = s ? -1 : 1;
+  m(t, void 0, [])();
+  function m(n, N, l) {
+    const i = (
+      /** @type {Record<string, unknown>} */
+      n && typeof n == "object" ? n : {}
+    );
+    if (typeof i.type == "string") {
+      const e = (
+        // `hast`
+        typeof i.tagName == "string" ? i.tagName : (
+          // `xast`
+          typeof i.name == "string" ? i.name : void 0
+        )
+      );
+      Object.defineProperty(h, "name", {
+        value: "node (" + A(n.type + (e ? "<" + e + ">" : "")) + ")"
+      });
+    }
+    return h;
+    function h() {
+      let e = g, f, r, d;
+      if ((!o || b(n, N, l[l.length - 1] || void 0)) && (e = E(u(n, l)), e[0] === a))
+        return e;
+      if ("children" in n && n.children) {
+        const c = (
+          /** @type {UnistParent} */
+          n
+        );
+        if (c.children && e[0] !== k)
+          for (r = (s ? c.children.length : -1) + y, d = l.concat(c); r > -1 && r < c.children.length; ) {
+            const P = c.children[r];
+            if (f = m(P, r, d)(), f[0] === a)
+              return f;
+            r = typeof f[1] == "number" ? f[1] : r + y;
+          }
+      }
+      return e;
+    }
+  }
+}
+function E(t) {
+  return Array.isArray(t) ? t : typeof t == "number" ? [j, t] : t == null ? g : [t];
+}
+export {
+  j as CONTINUE,
+  a as EXIT,
+  k as SKIP,
+  w as visitParents
+};

package/dist/es/node_modules/web-namespaces/index.mjs

@@ -0,0 +1,11 @@
+const w = {
+  html: "http://www.w3.org/1999/xhtml",
+  mathml: "http://www.w3.org/1998/Math/MathML",
+  svg: "http://www.w3.org/2000/svg",
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace",
+  xmlns: "http://www.w3.org/2000/xmlns/"
+};
+export {
+  w as webNamespaces
+};