@kong-ui-public/documentation 1.7.40-pr.3869.e876c8c8a.0 → 1.7.40

package/dist/sankeyDiagram-5OEKKPKP-Cgs6W_El-D7GZyd8n.js

@@ -0,0 +1,946 @@
+import { f as xt, i as kt, G as bt, K as vt, U as Lt, W as Et, p as g, Z as it, $ as wt, q as tt, au as At, a as St, H as Mt } from "./index-DfVKdDwj.js";
+import { s as It } from "./ordinal-D9ksOc8y-2hZwLyEk.js";
+function $t(t) {
+  for (var r = t.length / 6 | 0, s = Array(r), l = 0; l < r; ) s[l] = "#" + t.slice(l * 6, ++l * 6);
+  return s;
+}
+var Pt = $t("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");
+function ht(t, r) {
+  let s;
+  if (r === void 0) for (let l of t) l != null && (s < l || s === void 0 && l >= l) && (s = l);
+  else {
+    let l = -1;
+    for (let h of t) (h = r(h, ++l, t)) != null && (s < h || s === void 0 && h >= h) && (s = h);
+  }
+  return s;
+}
+function pt(t, r) {
+  let s;
+  if (r === void 0) for (let l of t) l != null && (s > l || s === void 0 && l >= l) && (s = l);
+  else {
+    let l = -1;
+    for (let h of t) (h = r(h, ++l, t)) != null && (s > h || s === void 0 && h >= h) && (s = h);
+  }
+  return s;
+}
+function et(t, r) {
+  let s = 0;
+  if (r === void 0) for (let l of t) (l = +l) && (s += l);
+  else {
+    let l = -1;
+    for (let h of t) (h = +r(h, ++l, t)) && (s += h);
+  }
+  return s;
+}
+function Nt(t) {
+  return t.target.depth;
+}
+function Ct(t) {
+  return t.depth;
+}
+function Ot(t, r) {
+  return r - 1 - t.height;
+}
+function _t(t, r) {
+  return t.sourceLinks.length ? t.depth : r - 1;
+}
+function Tt(t) {
+  return t.targetLinks.length ? t.depth : t.sourceLinks.length ? pt(t.sourceLinks, Nt) - 1 : 0;
+}
+function X(t) {
+  return function() {
+    return t;
+  };
+}
+function ut(t, r) {
+  return Q(t.source, r.source) || t.index - r.index;
+}
+function ct(t, r) {
+  return Q(t.target, r.target) || t.index - r.index;
+}
+function Q(t, r) {
+  return t.y0 - r.y0;
+}
+function nt(t) {
+  return t.value;
+}
+function Dt(t) {
+  return t.index;
+}
+function jt(t) {
+  return t.nodes;
+}
+function zt(t) {
+  return t.links;
+}
+function ft(t, r) {
+  let s = t.get(r);
+  if (!s) throw Error("missing: " + r);
+  return s;
+}
+function yt({ nodes: t }) {
+  for (let r of t) {
+    let s = r.y0, l = s;
+    for (let h of r.sourceLinks) h.y0 = s + h.width / 2, s += h.width;
+    for (let h of r.targetLinks) h.y1 = l + h.width / 2, l += h.width;
+  }
+}
+function Ft() {
+  let t = 0, r = 0, s = 1, l = 1, h = 24, m = 8, n, f = Dt, u = _t, y, _, d = jt, A = zt, v = 6;
+  function x() {
+    let i = {
+      nodes: d.apply(null, arguments),
+      links: A.apply(null, arguments)
+    };
+    return $(i), I(i), T(i), C(i), S(i), yt(i), i;
+  }
+  x.update = function(i) {
+    return yt(i), i;
+  }, x.nodeId = function(i) {
+    return arguments.length ? (f = typeof i == "function" ? i : X(i), x) : f;
+  }, x.nodeAlign = function(i) {
+    return arguments.length ? (u = typeof i == "function" ? i : X(i), x) : u;
+  }, x.nodeSort = function(i) {
+    return arguments.length ? (y = i, x) : y;
+  }, x.nodeWidth = function(i) {
+    return arguments.length ? (h = +i, x) : h;
+  }, x.nodePadding = function(i) {
+    return arguments.length ? (m = n = +i, x) : m;
+  }, x.nodes = function(i) {
+    return arguments.length ? (d = typeof i == "function" ? i : X(i), x) : d;
+  }, x.links = function(i) {
+    return arguments.length ? (A = typeof i == "function" ? i : X(i), x) : A;
+  }, x.linkSort = function(i) {
+    return arguments.length ? (_ = i, x) : _;
+  }, x.size = function(i) {
+    return arguments.length ? (t = r = 0, s = +i[0], l = +i[1], x) : [s - t, l - r];
+  }, x.extent = function(i) {
+    return arguments.length ? (t = +i[0][0], s = +i[1][0], r = +i[0][1], l = +i[1][1], x) : [[t, r], [s, l]];
+  }, x.iterations = function(i) {
+    return arguments.length ? (v = +i, x) : v;
+  };
+  function $({ nodes: i, links: c }) {
+    for (let [o, a] of i.entries()) a.index = o, a.sourceLinks = [], a.targetLinks = [];
+    let e = new Map(i.map((o, a) => [f(o, a, i), o]));
+    for (let [o, a] of c.entries()) {
+      a.index = o;
+      let { source: p, target: b } = a;
+      typeof p != "object" && (p = a.source = ft(e, p)), typeof b != "object" && (b = a.target = ft(e, b)), p.sourceLinks.push(a), b.targetLinks.push(a);
+    }
+    if (_ != null) for (let { sourceLinks: o, targetLinks: a } of i) o.sort(_), a.sort(_);
+  }
+  function I({ nodes: i }) {
+    for (let c of i) c.value = c.fixedValue === void 0 ? Math.max(et(c.sourceLinks, nt), et(c.targetLinks, nt)) : c.fixedValue;
+  }
+  function T({ nodes: i }) {
+    let c = i.length, e = new Set(i), o = /* @__PURE__ */ new Set(), a = 0;
+    for (; e.size; ) {
+      for (let p of e) {
+        p.depth = a;
+        for (let { target: b } of p.sourceLinks) o.add(b);
+      }
+      if (++a > c) throw Error("circular link");
+      e = o, o = /* @__PURE__ */ new Set();
+    }
+  }
+  function C({ nodes: i }) {
+    let c = i.length, e = new Set(i), o = /* @__PURE__ */ new Set(), a = 0;
+    for (; e.size; ) {
+      for (let p of e) {
+        p.height = a;
+        for (let { source: b } of p.targetLinks) o.add(b);
+      }
+      if (++a > c) throw Error("circular link");
+      e = o, o = /* @__PURE__ */ new Set();
+    }
+  }
+  function P({ nodes: i }) {
+    let c = ht(i, (a) => a.depth) + 1, e = (s - t - h) / (c - 1), o = Array(c);
+    for (let a of i) {
+      let p = Math.max(0, Math.min(c - 1, Math.floor(u.call(null, a, c))));
+      a.layer = p, a.x0 = t + p * e, a.x1 = a.x0 + h, o[p] ? o[p].push(a) : o[p] = [a];
+    }
+    if (y) for (let a of o) a.sort(y);
+    return o;
+  }
+  function k(i) {
+    let c = pt(i, (e) => (l - r - (e.length - 1) * n) / et(e, nt));
+    for (let e of i) {
+      let o = r;
+      for (let a of e) {
+        a.y0 = o, a.y1 = o + a.value * c, o = a.y1 + n;
+        for (let p of a.sourceLinks) p.width = p.value * c;
+      }
+      o = (l - o + n) / (e.length + 1);
+      for (let a = 0; a < e.length; ++a) {
+        let p = e[a];
+        p.y0 += o * (a + 1), p.y1 += o * (a + 1);
+      }
+      F(e);
+    }
+  }
+  function S(i) {
+    let c = P(i);
+    n = Math.min(m, (l - r) / (ht(c, (e) => e.length) - 1)), k(c);
+    for (let e = 0; e < v; ++e) {
+      let o = 0.99 ** e, a = Math.max(1 - o, (e + 1) / v);
+      j(c, o, a), D(c, o, a);
+    }
+  }
+  function D(i, c, e) {
+    for (let o = 1, a = i.length; o < a; ++o) {
+      let p = i[o];
+      for (let b of p) {
+        let E = 0, G = 0;
+        for (let { source: V, value: K } of b.targetLinks) {
+          let at = K * (b.layer - V.layer);
+          E += M(V, b) * at, G += at;
+        }
+        if (!(G > 0)) continue;
+        let R = (E / G - b.y0) * c;
+        b.y0 += R, b.y1 += R, L(b);
+      }
+      y === void 0 && p.sort(Q), U(p, e);
+    }
+  }
+  function j(i, c, e) {
+    for (let o = i.length - 2; o >= 0; --o) {
+      let a = i[o];
+      for (let p of a) {
+        let b = 0, E = 0;
+        for (let { target: R, value: V } of p.sourceLinks) {
+          let K = V * (R.layer - p.layer);
+          b += w(p, R) * K, E += K;
+        }
+        if (!(E > 0)) continue;
+        let G = (b / E - p.y0) * c;
+        p.y0 += G, p.y1 += G, L(p);
+      }
+      y === void 0 && a.sort(Q), U(a, e);
+    }
+  }
+  function U(i, c) {
+    let e = i.length >> 1, o = i[e];
+    z(i, o.y0 - n, e - 1, c), N(i, o.y1 + n, e + 1, c), z(i, l, i.length - 1, c), N(i, r, 0, c);
+  }
+  function N(i, c, e, o) {
+    for (; e < i.length; ++e) {
+      let a = i[e], p = (c - a.y0) * o;
+      p > 1e-6 && (a.y0 += p, a.y1 += p), c = a.y1 + n;
+    }
+  }
+  function z(i, c, e, o) {
+    for (; e >= 0; --e) {
+      let a = i[e], p = (a.y1 - c) * o;
+      p > 1e-6 && (a.y0 -= p, a.y1 -= p), c = a.y0 - n;
+    }
+  }
+  function L({ sourceLinks: i, targetLinks: c }) {
+    if (_ === void 0) {
+      for (let { source: { sourceLinks: e } } of c) e.sort(ct);
+      for (let { target: { targetLinks: e } } of i) e.sort(ut);
+    }
+  }
+  function F(i) {
+    if (_ === void 0) for (let { sourceLinks: c, targetLinks: e } of i) c.sort(ct), e.sort(ut);
+  }
+  function M(i, c) {
+    let e = i.y0 - (i.sourceLinks.length - 1) * n / 2;
+    for (let { target: o, width: a } of i.sourceLinks) {
+      if (o === c) break;
+      e += a + n;
+    }
+    for (let { source: o, width: a } of c.targetLinks) {
+      if (o === i) break;
+      e -= a;
+    }
+    return e;
+  }
+  function w(i, c) {
+    let e = c.y0 - (c.targetLinks.length - 1) * n / 2;
+    for (let { source: o, width: a } of c.targetLinks) {
+      if (o === i) break;
+      e += a + n;
+    }
+    for (let { target: o, width: a } of i.sourceLinks) {
+      if (o === c) break;
+      e -= a;
+    }
+    return e;
+  }
+  return x;
+}
+var rt = Math.PI, st = 2 * rt, W = 1e-6, Wt = st - W;
+function ot() {
+  this._x0 = this._y0 = this._x1 = this._y1 = null, this._ = "";
+}
+function mt() {
+  return new ot();
+}
+ot.prototype = mt.prototype = {
+  constructor: ot,
+  moveTo: function(t, r) {
+    this._ += "M" + (this._x0 = this._x1 = +t) + "," + (this._y0 = this._y1 = +r);
+  },
+  closePath: function() {
+    this._x1 !== null && (this._x1 = this._x0, this._y1 = this._y0, this._ += "Z");
+  },
+  lineTo: function(t, r) {
+    this._ += "L" + (this._x1 = +t) + "," + (this._y1 = +r);
+  },
+  quadraticCurveTo: function(t, r, s, l) {
+    this._ += "Q" + +t + "," + +r + "," + (this._x1 = +s) + "," + (this._y1 = +l);
+  },
+  bezierCurveTo: function(t, r, s, l, h, m) {
+    this._ += "C" + +t + "," + +r + "," + +s + "," + +l + "," + (this._x1 = +h) + "," + (this._y1 = +m);
+  },
+  arcTo: function(t, r, s, l, h) {
+    t = +t, r = +r, s = +s, l = +l, h = +h;
+    var m = this._x1, n = this._y1, f = s - t, u = l - r, y = m - t, _ = n - r, d = y * y + _ * _;
+    if (h < 0) throw Error("negative radius: " + h);
+    if (this._x1 === null) this._ += "M" + (this._x1 = t) + "," + (this._y1 = r);
+    else if (d > W) if (!(Math.abs(_ * f - u * y) > W) || !h) this._ += "L" + (this._x1 = t) + "," + (this._y1 = r);
+    else {
+      var A = s - m, v = l - n, x = f * f + u * u, $ = A * A + v * v, I = Math.sqrt(x), T = Math.sqrt(d), C = h * Math.tan((rt - Math.acos((x + d - $) / (2 * I * T))) / 2), P = C / T, k = C / I;
+      Math.abs(P - 1) > W && (this._ += "L" + (t + P * y) + "," + (r + P * _)), this._ += "A" + h + "," + h + ",0,0," + +(_ * A > y * v) + "," + (this._x1 = t + k * f) + "," + (this._y1 = r + k * u);
+    }
+  },
+  arc: function(t, r, s, l, h, m) {
+    t = +t, r = +r, s = +s, m = !!m;
+    var n = s * Math.cos(l), f = s * Math.sin(l), u = t + n, y = r + f, _ = 1 ^ m, d = m ? l - h : h - l;
+    if (s < 0) throw Error("negative radius: " + s);
+    this._x1 === null ? this._ += "M" + u + "," + y : (Math.abs(this._x1 - u) > W || Math.abs(this._y1 - y) > W) && (this._ += "L" + u + "," + y), s && (d < 0 && (d = d % st + st), d > Wt ? this._ += "A" + s + "," + s + ",0,1," + _ + "," + (t - n) + "," + (r - f) + "A" + s + "," + s + ",0,1," + _ + "," + (this._x1 = u) + "," + (this._y1 = y) : d > W && (this._ += "A" + s + "," + s + ",0," + +(d >= rt) + "," + _ + "," + (this._x1 = t + s * Math.cos(h)) + "," + (this._y1 = r + s * Math.sin(h))));
+  },
+  rect: function(t, r, s, l) {
+    this._ += "M" + (this._x0 = this._x1 = +t) + "," + (this._y0 = this._y1 = +r) + "h" + +s + "v" + +l + "h" + -s + "Z";
+  },
+  toString: function() {
+    return this._;
+  }
+};
+function dt(t) {
+  return function() {
+    return t;
+  };
+}
+function Ut(t) {
+  return t[0];
+}
+function Gt(t) {
+  return t[1];
+}
+var qt = Array.prototype.slice;
+function Bt(t) {
+  return t.source;
+}
+function Rt(t) {
+  return t.target;
+}
+function Vt(t) {
+  var r = Bt, s = Rt, l = Ut, h = Gt, m = null;
+  function n() {
+    var f, u = qt.call(arguments), y = r.apply(this, u), _ = s.apply(this, u);
+    if (m ||= f = mt(), t(m, +l.apply(this, (u[0] = y, u)), +h.apply(this, u), +l.apply(this, (u[0] = _, u)), +h.apply(this, u)), f) return m = null, f + "" || null;
+  }
+  return n.source = function(f) {
+    return arguments.length ? (r = f, n) : r;
+  }, n.target = function(f) {
+    return arguments.length ? (s = f, n) : s;
+  }, n.x = function(f) {
+    return arguments.length ? (l = typeof f == "function" ? f : dt(+f), n) : l;
+  }, n.y = function(f) {
+    return arguments.length ? (h = typeof f == "function" ? f : dt(+f), n) : h;
+  }, n.context = function(f) {
+    return arguments.length ? (m = f ?? null, n) : m;
+  }, n;
+}
+function Kt(t, r, s, l, h) {
+  t.moveTo(r, s), t.bezierCurveTo(r = (r + l) / 2, s, r, h, l, h);
+}
+function Xt() {
+  return Vt(Kt);
+}
+function Zt(t) {
+  return [t.source.x1, t.y0];
+}
+function Ht(t) {
+  return [t.target.x0, t.y1];
+}
+function Qt() {
+  return Xt().source(Zt).target(Ht);
+}
+var lt = (function() {
+  var t = /* @__PURE__ */ g(function(n, f, u, y) {
+    for (u ||= {}, y = n.length; y--; u[n[y]] = f) ;
+    return u;
+  }, "o"), r = [1, 9], s = [1, 10], l = [
+    1,
+    5,
+    10,
+    12
+  ], h = {
+    trace: /* @__PURE__ */ g(function() {
+    }, "trace"),
+    yy: {},
+    symbols_: {
+      error: 2,
+      start: 3,
+      SANKEY: 4,
+      NEWLINE: 5,
+      csv: 6,
+      opt_eof: 7,
+      record: 8,
+      csv_tail: 9,
+      EOF: 10,
+      "field[source]": 11,
+      COMMA: 12,
+      "field[target]": 13,
+      "field[value]": 14,
+      field: 15,
+      escaped: 16,
+      non_escaped: 17,
+      DQUOTE: 18,
+      ESCAPED_TEXT: 19,
+      NON_ESCAPED_TEXT: 20,
+      $accept: 0,
+      $end: 1
+    },
+    terminals_: {
+      2: "error",
+      4: "SANKEY",
+      5: "NEWLINE",
+      10: "EOF",
+      11: "field[source]",
+      12: "COMMA",
+      13: "field[target]",
+      14: "field[value]",
+      18: "DQUOTE",
+      19: "ESCAPED_TEXT",
+      20: "NON_ESCAPED_TEXT"
+    },
+    productions_: [
+      0,
+      [3, 4],
+      [6, 2],
+      [9, 2],
+      [9, 0],
+      [7, 1],
+      [7, 0],
+      [8, 5],
+      [15, 1],
+      [15, 1],
+      [16, 3],
+      [17, 1]
+    ],
+    performAction: /* @__PURE__ */ g(function(n, f, u, y, _, d, A) {
+      var v = d.length - 1;
+      switch (_) {
+        case 7:
+          let x = y.findOrCreateNode(d[v - 4].trim().replaceAll('""', '"')), $ = y.findOrCreateNode(d[v - 2].trim().replaceAll('""', '"')), I = parseFloat(d[v].trim());
+          y.addLink(x, $, I);
+          break;
+        case 8:
+        case 9:
+        case 11:
+          this.$ = d[v];
+          break;
+        case 10:
+          this.$ = d[v - 1];
+          break;
+      }
+    }, "anonymous"),
+    table: [
+      {
+        3: 1,
+        4: [1, 2]
+      },
+      { 1: [3] },
+      { 5: [1, 3] },
+      {
+        6: 4,
+        8: 5,
+        15: 6,
+        16: 7,
+        17: 8,
+        18: r,
+        20: s
+      },
+      {
+        1: [2, 6],
+        7: 11,
+        10: [1, 12]
+      },
+      t(s, [2, 4], {
+        9: 13,
+        5: [1, 14]
+      }),
+      { 12: [1, 15] },
+      t(l, [2, 8]),
+      t(l, [2, 9]),
+      { 19: [1, 16] },
+      t(l, [2, 11]),
+      { 1: [2, 1] },
+      { 1: [2, 5] },
+      t(s, [2, 2]),
+      {
+        6: 17,
+        8: 5,
+        15: 6,
+        16: 7,
+        17: 8,
+        18: r,
+        20: s
+      },
+      {
+        15: 18,
+        16: 7,
+        17: 8,
+        18: r,
+        20: s
+      },
+      { 18: [1, 19] },
+      t(s, [2, 3]),
+      { 12: [1, 20] },
+      t(l, [2, 10]),
+      {
+        15: 21,
+        16: 7,
+        17: 8,
+        18: r,
+        20: s
+      },
+      t([
+        1,
+        5,
+        10
+      ], [2, 7])
+    ],
+    defaultActions: {
+      11: [2, 1],
+      12: [2, 5]
+    },
+    parseError: /* @__PURE__ */ g(function(n, f) {
+      if (f.recoverable) this.trace(n);
+      else {
+        var u = Error(n);
+        throw u.hash = f, u;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ g(function(n) {
+      var f = this, u = [0], y = [], _ = [null], d = [], A = this.table, v = "", x = 0, $ = 0, I = 0, T = 2, C = 1, P = d.slice.call(arguments, 1), k = Object.create(this.lexer), S = { yy: {} };
+      for (var D in this.yy) Object.prototype.hasOwnProperty.call(this.yy, D) && (S.yy[D] = this.yy[D]);
+      k.setInput(n, S.yy), S.yy.lexer = k, S.yy.parser = this, k.yylloc === void 0 && (k.yylloc = {});
+      var j = k.yylloc;
+      d.push(j);
+      var U = k.options && k.options.ranges;
+      typeof S.yy.parseError == "function" ? this.parseError = S.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function N(E) {
+        u.length -= 2 * E, _.length -= E, d.length -= E;
+      }
+      g(N, "popStack");
+      function z() {
+        var E = y.pop() || k.lex() || C;
+        return typeof E != "number" && (E instanceof Array && (y = E, E = y.pop()), E = f.symbols_[E] || E), E;
+      }
+      g(z, "lex");
+      for (var L, F, M, w, i, c = {}, e, o, a, p; ; ) {
+        if (M = u[u.length - 1], this.defaultActions[M] ? w = this.defaultActions[M] : (L ??= z(), w = A[M] && A[M][L]), w === void 0 || !w.length || !w[0]) {
+          var b = "";
+          for (e in p = [], A[M]) this.terminals_[e] && e > T && p.push("'" + this.terminals_[e] + "'");
+          b = k.showPosition ? "Parse error on line " + (x + 1) + `:
+` + k.showPosition() + `
+Expecting ` + p.join(", ") + ", got '" + (this.terminals_[L] || L) + "'" : "Parse error on line " + (x + 1) + ": Unexpected " + (L == C ? "end of input" : "'" + (this.terminals_[L] || L) + "'"), this.parseError(b, {
+            text: k.match,
+            token: this.terminals_[L] || L,
+            line: k.yylineno,
+            loc: j,
+            expected: p
+          });
+        }
+        if (w[0] instanceof Array && w.length > 1) throw Error("Parse Error: multiple actions possible at state: " + M + ", token: " + L);
+        switch (w[0]) {
+          case 1:
+            u.push(L), _.push(k.yytext), d.push(k.yylloc), u.push(w[1]), L = null, F ? (L = F, F = null) : ($ = k.yyleng, v = k.yytext, x = k.yylineno, j = k.yylloc, I > 0);
+            break;
+          case 2:
+            if (o = this.productions_[w[1]][1], c.$ = _[_.length - o], c._$ = {
+              first_line: d[d.length - (o || 1)].first_line,
+              last_line: d[d.length - 1].last_line,
+              first_column: d[d.length - (o || 1)].first_column,
+              last_column: d[d.length - 1].last_column
+            }, U && (c._$.range = [d[d.length - (o || 1)].range[0], d[d.length - 1].range[1]]), i = this.performAction.apply(c, [
+              v,
+              $,
+              x,
+              S.yy,
+              w[1],
+              _,
+              d
+            ].concat(P)), i !== void 0) return i;
+            o && (u = u.slice(0, -1 * o * 2), _ = _.slice(0, -1 * o), d = d.slice(0, -1 * o)), u.push(this.productions_[w[1]][0]), _.push(c.$), d.push(c._$), a = A[u[u.length - 2]][u[u.length - 1]], u.push(a);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }, "parse")
+  };
+  h.lexer = /* @__PURE__ */ (function() {
+    return {
+      EOF: 1,
+      parseError: /* @__PURE__ */ g(function(n, f) {
+        if (this.yy.parser) this.yy.parser.parseError(n, f);
+        else throw Error(n);
+      }, "parseError"),
+      setInput: /* @__PURE__ */ g(function(n, f) {
+        return this.yy = f || this.yy || {}, this._input = n, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = ["INITIAL"], this.yylloc = {
+          first_line: 1,
+          first_column: 0,
+          last_line: 1,
+          last_column: 0
+        }, this.options.ranges && (this.yylloc.range = [0, 0]), this.offset = 0, this;
+      }, "setInput"),
+      input: /* @__PURE__ */ g(function() {
+        var n = this._input[0];
+        return this.yytext += n, this.yyleng++, this.offset++, this.match += n, this.matched += n, n.match(/(?:\r\n?|\n).*/g) ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), n;
+      }, "input"),
+      unput: /* @__PURE__ */ g(function(n) {
+        var f = n.length, u = n.split(/(?:\r\n?|\n)/g);
+        this._input = n + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - f), this.offset -= f;
+        var y = this.match.split(/(?:\r\n?|\n)/g);
+        this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), u.length - 1 && (this.yylineno -= u.length - 1);
+        var _ = this.yylloc.range;
+        return this.yylloc = {
+          first_line: this.yylloc.first_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.first_column,
+          last_column: u ? (u.length === y.length ? this.yylloc.first_column : 0) + y[y.length - u.length].length - u[0].length : this.yylloc.first_column - f
+        }, this.options.ranges && (this.yylloc.range = [_[0], _[0] + this.yyleng - f]), this.yyleng = this.yytext.length, this;
+      }, "unput"),
+      more: /* @__PURE__ */ g(function() {
+        return this._more = !0, this;
+      }, "more"),
+      reject: /* @__PURE__ */ g(function() {
+        if (this.options.backtrack_lexer) this._backtrack = !0;
+        else return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+        return this;
+      }, "reject"),
+      less: /* @__PURE__ */ g(function(n) {
+        this.unput(this.match.slice(n));
+      }, "less"),
+      pastInput: /* @__PURE__ */ g(function() {
+        var n = this.matched.substr(0, this.matched.length - this.match.length);
+        return (n.length > 20 ? "..." : "") + n.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      upcomingInput: /* @__PURE__ */ g(function() {
+        var n = this.match;
+        return n.length < 20 && (n += this._input.substr(0, 20 - n.length)), (n.substr(0, 20) + (n.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      showPosition: /* @__PURE__ */ g(function() {
+        var n = this.pastInput(), f = Array(n.length + 1).join("-");
+        return n + this.upcomingInput() + `
+` + f + "^";
+      }, "showPosition"),
+      test_match: /* @__PURE__ */ g(function(n, f) {
+        var u, y, _;
+        if (this.options.backtrack_lexer && (_ = {
+          yylineno: this.yylineno,
+          yylloc: {
+            first_line: this.yylloc.first_line,
+            last_line: this.last_line,
+            first_column: this.yylloc.first_column,
+            last_column: this.yylloc.last_column
+          },
+          yytext: this.yytext,
+          match: this.match,
+          matches: this.matches,
+          matched: this.matched,
+          yyleng: this.yyleng,
+          offset: this.offset,
+          _more: this._more,
+          _input: this._input,
+          yy: this.yy,
+          conditionStack: this.conditionStack.slice(0),
+          done: this.done
+        }, this.options.ranges && (_.yylloc.range = this.yylloc.range.slice(0))), y = n[0].match(/(?:\r\n?|\n).*/g), y && (this.yylineno += y.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: y ? y[y.length - 1].length - y[y.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + n[0].length
+        }, this.yytext += n[0], this.match += n[0], this.matches = n, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(n[0].length), this.matched += n[0], u = this.performAction.call(this, this.yy, this, f, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), u) return u;
+        if (this._backtrack) {
+          for (var d in _) this[d] = _[d];
+          return !1;
+        }
+        return !1;
+      }, "test_match"),
+      next: /* @__PURE__ */ g(function() {
+        if (this.done) return this.EOF;
+        this._input || (this.done = !0);
+        var n, f, u, y;
+        this._more || (this.yytext = "", this.match = "");
+        for (var _ = this._currentRules(), d = 0; d < _.length; d++) if (u = this._input.match(this.rules[_[d]]), u && (!f || u[0].length > f[0].length)) {
+          if (f = u, y = d, this.options.backtrack_lexer) {
+            if (n = this.test_match(u, _[d]), n !== !1) return n;
+            if (this._backtrack) {
+              f = !1;
+              continue;
+            } else return !1;
+          } else if (!this.options.flex) break;
+        }
+        return f ? (n = this.test_match(f, _[y]), n === !1 ? !1 : n) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      }, "next"),
+      lex: /* @__PURE__ */ g(function() {
+        return this.next() || this.lex();
+      }, "lex"),
+      begin: /* @__PURE__ */ g(function(n) {
+        this.conditionStack.push(n);
+      }, "begin"),
+      popState: /* @__PURE__ */ g(function() {
+        return this.conditionStack.length - 1 > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      }, "popState"),
+      _currentRules: /* @__PURE__ */ g(function() {
+        return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+      }, "_currentRules"),
+      topState: /* @__PURE__ */ g(function(n) {
+        return n = this.conditionStack.length - 1 - Math.abs(n || 0), n >= 0 ? this.conditionStack[n] : "INITIAL";
+      }, "topState"),
+      pushState: /* @__PURE__ */ g(function(n) {
+        this.begin(n);
+      }, "pushState"),
+      stateStackSize: /* @__PURE__ */ g(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: { "case-insensitive": !0 },
+      performAction: /* @__PURE__ */ g(function(n, f, u, y) {
+        switch (u) {
+          case 0:
+            return this.pushState("csv"), 4;
+          case 1:
+            return this.pushState("csv"), 4;
+          case 2:
+            return 10;
+          case 3:
+            return 5;
+          case 4:
+            return 12;
+          case 5:
+            return this.pushState("escaped_text"), 18;
+          case 6:
+            return 20;
+          case 7:
+            return this.popState("escaped_text"), 18;
+          case 8:
+            return 19;
+        }
+      }, "anonymous"),
+      rules: [
+        /^(?:sankey-beta\b)/i,
+        /^(?:sankey\b)/i,
+        /^(?:$)/i,
+        /^(?:((\u000D\u000A)|(\u000A)))/i,
+        /^(?:(\u002C))/i,
+        /^(?:(\u0022))/i,
+        /^(?:([\u0020-\u0021\u0023-\u002B\u002D-\u007E])*)/i,
+        /^(?:(\u0022)(?!(\u0022)))/i,
+        /^(?:(([\u0020-\u0021\u0023-\u002B\u002D-\u007E])|(\u002C)|(\u000D)|(\u000A)|(\u0022)(\u0022))*)/i
+      ],
+      conditions: {
+        csv: {
+          rules: [
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8
+          ],
+          inclusive: !1
+        },
+        escaped_text: {
+          rules: [7, 8],
+          inclusive: !1
+        },
+        INITIAL: {
+          rules: [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8
+          ],
+          inclusive: !0
+        }
+      }
+    };
+  })();
+  function m() {
+    this.yy = {};
+  }
+  return g(m, "Parser"), m.prototype = h, h.Parser = m, new m();
+})();
+lt.parser = lt;
+var Y = lt, J = [], Z = [], H = /* @__PURE__ */ new Map(), Yt = /* @__PURE__ */ g(() => {
+  J = [], Z = [], H = /* @__PURE__ */ new Map(), Mt();
+}, "clear"), q, Jt = (q = class {
+  constructor(r, s, l = 0) {
+    this.source = r, this.target = s, this.value = l;
+  }
+}, g(q, "SankeyLink"), q), te = /* @__PURE__ */ g((t, r, s) => {
+  J.push(new Jt(t, r, s));
+}, "addLink"), B, ee = (B = class {
+  constructor(r) {
+    this.ID = r;
+  }
+}, g(B, "SankeyNode"), B), ne = {
+  nodesMap: H,
+  getConfig: /* @__PURE__ */ g(() => it().sankey, "getConfig"),
+  getNodes: /* @__PURE__ */ g(() => Z, "getNodes"),
+  getLinks: /* @__PURE__ */ g(() => J, "getLinks"),
+  getGraph: /* @__PURE__ */ g(() => ({
+    nodes: Z.map((t) => ({ id: t.ID })),
+    links: J.map((t) => ({
+      source: t.source.ID,
+      target: t.target.ID,
+      value: t.value
+    }))
+  }), "getGraph"),
+  addLink: te,
+  findOrCreateNode: /* @__PURE__ */ g((t) => {
+    t = St.sanitizeText(t, it());
+    let r = H.get(t);
+    return r === void 0 && (r = new ee(t), H.set(t, r), Z.push(r)), r;
+  }, "findOrCreateNode"),
+  getAccTitle: Et,
+  setAccTitle: Lt,
+  getAccDescription: vt,
+  setAccDescription: bt,
+  getDiagramTitle: kt,
+  setDiagramTitle: xt,
+  clear: Yt
+}, O, gt = (O = class {
+  static next(r) {
+    return new O(r + ++O.count);
+  }
+  constructor(r) {
+    this.id = r, this.href = `#${r}`;
+  }
+  toString() {
+    return "url(" + this.href + ")";
+  }
+}, g(O, "Uid"), O.count = 0, O), ie = {
+  left: Ct,
+  right: Ot,
+  center: Tt,
+  justify: _t
+}, re = /* @__PURE__ */ g((t) => {
+  let r = 0, s = 0;
+  for (let l of t) {
+    let h = l.value ?? 0;
+    h > r && (r = h, s = l.layer ?? 0);
+  }
+  return s;
+}, "findCentralNodeLayer"), se = { draw: /* @__PURE__ */ g(function(t, r, s, l) {
+  let { securityLevel: h, sankey: m } = it(), n = wt.sankey, f;
+  h === "sandbox" && (f = tt("#i" + r));
+  let u = tt(h === "sandbox" ? f.nodes()[0].contentDocument.body : "body"), y = h === "sandbox" ? u.select(`[id="${r}"]`) : tt(`[id="${r}"]`), _ = m?.width ?? n.width, d = m?.height ?? n.width, A = m?.useMaxWidth ?? n.useMaxWidth, v = m?.nodeAlignment ?? n.nodeAlignment, x = m?.prefix ?? n.prefix, $ = m?.suffix ?? n.suffix, I = m?.showValues ?? n.showValues, T = m?.nodeWidth ?? n.nodeWidth ?? 10, C = m?.nodePadding ?? n.nodePadding ?? 12, P = m?.labelStyle ?? n.labelStyle ?? "legacy", k = m?.nodeColors ?? {}, S = l.db.getGraph(), D = ie[v];
+  Ft().nodeId((e) => e.id).nodeWidth(T).nodePadding(C + (I ? 15 : 0)).nodeAlign(D).extent([[0, 0], [_, d]])(S);
+  let j = re(S.nodes), U = It(Pt), N = /* @__PURE__ */ g((e) => k[e] ?? U(e), "getNodeColor");
+  y.append("g").attr("class", "nodes").selectAll(".node").data(S.nodes).join("g").attr("class", "node").attr("id", (e) => (e.uid = gt.next("node-")).id).attr("transform", function(e) {
+    return "translate(" + e.x0 + "," + e.y0 + ")";
+  }).attr("x", (e) => e.x0).attr("y", (e) => e.y0).append("rect").attr("height", (e) => e.y1 - e.y0).attr("width", (e) => e.x1 - e.x0).attr("fill", (e) => N(e.id));
+  let z = /* @__PURE__ */ g(({ id: e, value: o }) => I ? `${e}
+${x}${Math.round(o * 100) / 100}${$}` : e, "getText"), L = /* @__PURE__ */ g((e) => P === "outlined" ? (e.layer ?? 0) < j ? {
+    x: e.x0 - 6,
+    anchor: "end"
+  } : {
+    x: e.x1 + 6,
+    anchor: "start"
+  } : e.x0 < _ / 2 ? {
+    x: e.x1 + 6,
+    anchor: "start"
+  } : {
+    x: e.x0 - 6,
+    anchor: "end"
+  }, "getLabelPosition"), F = y.append("g").attr("class", "node-labels").attr("font-size", 14), M = /* @__PURE__ */ g((e) => F.selectAll(e ? `.${e}` : "text").data(S.nodes).join("text").attr("class", e ?? null).attr("x", (o) => L(o).x).attr("y", (o) => (o.y1 + o.y0) / 2).attr("dy", `${I ? "0" : "0.35"}em`).attr("text-anchor", (o) => L(o).anchor).text(z), "appendLabel");
+  P === "outlined" ? (M("sankey-label-bg"), M("sankey-label-fg")) : M();
+  let w = y.append("g").attr("class", "links").attr("fill", "none").attr("stroke-opacity", 0.5).selectAll(".link").data(S.links).join("g").attr("class", "link").style("mix-blend-mode", "multiply"), i = m?.linkColor ?? "gradient";
+  if (i === "gradient") {
+    let e = w.append("linearGradient").attr("id", (o) => (o.uid = gt.next("linearGradient-")).id).attr("gradientUnits", "userSpaceOnUse").attr("x1", (o) => o.source.x1).attr("x2", (o) => o.target.x0);
+    e.append("stop").attr("offset", "0%").attr("stop-color", (o) => N(o.source.id)), e.append("stop").attr("offset", "100%").attr("stop-color", (o) => N(o.target.id));
+  }
+  let c;
+  switch (i) {
+    case "gradient":
+      c = /* @__PURE__ */ g((e) => e.uid, "coloring");
+      break;
+    case "source":
+      c = /* @__PURE__ */ g((e) => N(e.source.id), "coloring");
+      break;
+    case "target":
+      c = /* @__PURE__ */ g((e) => N(e.target.id), "coloring");
+      break;
+    default:
+      c = i;
+  }
+  w.append("path").attr("d", Qt()).attr("stroke", c).attr("stroke-width", (e) => Math.max(1, e.width)), At(void 0, y, 0, A);
+}, "draw") }, oe = /* @__PURE__ */ g((t) => t.replaceAll(/^[^\S\n\r]+|[^\S\n\r]+$/g, "").replaceAll(/([\n\r])+/g, `
+`).trim(), "prepareTextForParsing"), le = /* @__PURE__ */ g((t) => `.label {
+    font-family: ${t.fontFamily};
+  }
+
+  .node-labels {
+    font-family: ${t.fontFamily};
+  }
+
+  /* Outlined label style - background stroke for better readability */
+  .sankey-label-bg {
+    stroke: ${t.mainBkg || t.background || "#fff"};
+    stroke-width: 4px;
+    stroke-linejoin: round;
+    paint-order: stroke;
+  }
+
+  /* Foreground label text */
+  .sankey-label-fg {
+    fill: ${t.textColor};
+  }
+
+  /* Node styling */
+  .node rect {
+    shape-rendering: crispEdges;
+  }
+
+  /* Link styling */
+  .link {
+    fill: none;
+    stroke-opacity: 0.5;
+    mix-blend-mode: multiply;
+  }
+`, "getStyles"), ae = Y.parse.bind(Y);
+Y.parse = (t) => ae(oe(t));
+var ce = {
+  styles: le,
+  parser: Y,
+  db: ne,
+  renderer: se
+};
+export {
+  ce as diagram
+};