@marimo-team/islands 0.23.17-dev9 → 0.24.1-dev0

package/dist/sankeyDiagram-W5VNT64P-D82rYiAG.js

@@ -0,0 +1,942 @@
+var _a, _b, _c;
+import "./purify.es-DR5PNXwx.js";
+import { n as ordinal } from "./ordinal-Bdajf2BE.js";
+import { t as colors_default } from "./colors-DR_aHfmQ.js";
+import { t as select_default } from "./src-BwVZVGyf.js";
+import { n as __name } from "./chunk-Y2CYZVJY-DX3DSigL.js";
+import { H as setAccDescription, J as setupGraphViewbox, K as setDiagramTitle, U as setAccTitle, a as clear, d as defaultConfig2, s as common_default, v as getAccDescription, w as getDiagramTitle, x as getConfig2, y as getAccTitle } from "./chunk-I66GZJ75-9xAsFrdW.js";
+var Tableau10_default = colors_default("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");
+function max(n, c) {
+  let l;
+  if (c === void 0) for (let c2 of n) c2 != null && (l < c2 || l === void 0 && c2 >= c2) && (l = c2);
+  else {
+    let u = -1;
+    for (let d of n) (d = c(d, ++u, n)) != null && (l < d || l === void 0 && d >= d) && (l = d);
+  }
+  return l;
+}
+function min(n, c) {
+  let l;
+  if (c === void 0) for (let c2 of n) c2 != null && (l > c2 || l === void 0 && c2 >= c2) && (l = c2);
+  else {
+    let u = -1;
+    for (let d of n) (d = c(d, ++u, n)) != null && (l > d || l === void 0 && d >= d) && (l = d);
+  }
+  return l;
+}
+function sum(n, c) {
+  let l = 0;
+  if (c === void 0) for (let c2 of n) (c2 = +c2) && (l += c2);
+  else {
+    let u = -1;
+    for (let d of n) (d = +c(d, ++u, n)) && (l += d);
+  }
+  return l;
+}
+function targetDepth(n) {
+  return n.target.depth;
+}
+function left(n) {
+  return n.depth;
+}
+function right(n, c) {
+  return c - 1 - n.height;
+}
+function justify(n, c) {
+  return n.sourceLinks.length ? n.depth : c - 1;
+}
+function center(n) {
+  return n.targetLinks.length ? n.depth : n.sourceLinks.length ? min(n.sourceLinks, targetDepth) - 1 : 0;
+}
+function constant(n) {
+  return function() {
+    return n;
+  };
+}
+function ascendingSourceBreadth(n, c) {
+  return ascendingBreadth(n.source, c.source) || n.index - c.index;
+}
+function ascendingTargetBreadth(n, c) {
+  return ascendingBreadth(n.target, c.target) || n.index - c.index;
+}
+function ascendingBreadth(n, c) {
+  return n.y0 - c.y0;
+}
+function value(n) {
+  return n.value;
+}
+function defaultId(n) {
+  return n.index;
+}
+function defaultNodes(n) {
+  return n.nodes;
+}
+function defaultLinks(n) {
+  return n.links;
+}
+function find(n, c) {
+  let l = n.get(c);
+  if (!l) throw Error("missing: " + c);
+  return l;
+}
+function computeLinkBreadths({ nodes: n }) {
+  for (let c of n) {
+    let n2 = c.y0, l = n2;
+    for (let l2 of c.sourceLinks) l2.y0 = n2 + l2.width / 2, n2 += l2.width;
+    for (let n3 of c.targetLinks) n3.y1 = l + n3.width / 2, l += n3.width;
+  }
+}
+function Sankey() {
+  let n = 0, c = 0, l = 1, u = 1, d = 24, f = 8, p, m = defaultId, h = justify, g, _, v = defaultNodes, b = defaultLinks, S = 6;
+  function C() {
+    let n2 = {
+      nodes: v.apply(null, arguments),
+      links: b.apply(null, arguments)
+    };
+    return w(n2), O(n2), k(n2), A(n2), W(n2), computeLinkBreadths(n2), n2;
+  }
+  C.update = function(n2) {
+    return computeLinkBreadths(n2), n2;
+  }, C.nodeId = function(n2) {
+    return arguments.length ? (m = typeof n2 == "function" ? n2 : constant(n2), C) : m;
+  }, C.nodeAlign = function(n2) {
+    return arguments.length ? (h = typeof n2 == "function" ? n2 : constant(n2), C) : h;
+  }, C.nodeSort = function(n2) {
+    return arguments.length ? (g = n2, C) : g;
+  }, C.nodeWidth = function(n2) {
+    return arguments.length ? (d = +n2, C) : d;
+  }, C.nodePadding = function(n2) {
+    return arguments.length ? (f = p = +n2, C) : f;
+  }, C.nodes = function(n2) {
+    return arguments.length ? (v = typeof n2 == "function" ? n2 : constant(n2), C) : v;
+  }, C.links = function(n2) {
+    return arguments.length ? (b = typeof n2 == "function" ? n2 : constant(n2), C) : b;
+  }, C.linkSort = function(n2) {
+    return arguments.length ? (_ = n2, C) : _;
+  }, C.size = function(d2) {
+    return arguments.length ? (n = c = 0, l = +d2[0], u = +d2[1], C) : [l - n, u - c];
+  }, C.extent = function(d2) {
+    return arguments.length ? (n = +d2[0][0], l = +d2[1][0], c = +d2[0][1], u = +d2[1][1], C) : [[n, c], [l, u]];
+  }, C.iterations = function(n2) {
+    return arguments.length ? (S = +n2, C) : S;
+  };
+  function w({ nodes: n2, links: c2 }) {
+    for (let [c3, l3] of n2.entries()) l3.index = c3, l3.sourceLinks = [], l3.targetLinks = [];
+    let l2 = new Map(n2.map((c3, l3) => [m(c3, l3, n2), c3]));
+    for (let [n3, u2] of c2.entries()) {
+      u2.index = n3;
+      let { source: c3, target: d2 } = u2;
+      typeof c3 != "object" && (c3 = u2.source = find(l2, c3)), typeof d2 != "object" && (d2 = u2.target = find(l2, d2)), c3.sourceLinks.push(u2), d2.targetLinks.push(u2);
+    }
+    if (_ != null) for (let { sourceLinks: c3, targetLinks: l3 } of n2) c3.sort(_), l3.sort(_);
+  }
+  function O({ nodes: n2 }) {
+    for (let c2 of n2) c2.value = c2.fixedValue === void 0 ? Math.max(sum(c2.sourceLinks, value), sum(c2.targetLinks, value)) : c2.fixedValue;
+  }
+  function k({ nodes: n2 }) {
+    let c2 = n2.length, l2 = new Set(n2), u2 = /* @__PURE__ */ new Set(), d2 = 0;
+    for (; l2.size; ) {
+      for (let n3 of l2) {
+        n3.depth = d2;
+        for (let { target: c3 } of n3.sourceLinks) u2.add(c3);
+      }
+      if (++d2 > c2) throw Error("circular link");
+      l2 = u2, u2 = /* @__PURE__ */ new Set();
+    }
+  }
+  function A({ nodes: n2 }) {
+    let c2 = n2.length, l2 = new Set(n2), u2 = /* @__PURE__ */ new Set(), d2 = 0;
+    for (; l2.size; ) {
+      for (let n3 of l2) {
+        n3.height = d2;
+        for (let { source: c3 } of n3.targetLinks) u2.add(c3);
+      }
+      if (++d2 > c2) throw Error("circular link");
+      l2 = u2, u2 = /* @__PURE__ */ new Set();
+    }
+  }
+  function M({ nodes: c2 }) {
+    let u2 = max(c2, (n2) => n2.depth) + 1, f2 = (l - n - d) / (u2 - 1), p2 = Array(u2);
+    for (let l2 of c2) {
+      let c3 = Math.max(0, Math.min(u2 - 1, Math.floor(h.call(null, l2, u2))));
+      l2.layer = c3, l2.x0 = n + c3 * f2, l2.x1 = l2.x0 + d, p2[c3] ? p2[c3].push(l2) : p2[c3] = [l2];
+    }
+    if (g) for (let n2 of p2) n2.sort(g);
+    return p2;
+  }
+  function U(n2) {
+    let l2 = min(n2, (n3) => (u - c - (n3.length - 1) * p) / sum(n3, value));
+    for (let d2 of n2) {
+      let n3 = c;
+      for (let c2 of d2) {
+        c2.y0 = n3, c2.y1 = n3 + c2.value * l2, n3 = c2.y1 + p;
+        for (let n4 of c2.sourceLinks) n4.width = n4.value * l2;
+      }
+      n3 = (u - n3 + p) / (d2.length + 1);
+      for (let c2 = 0; c2 < d2.length; ++c2) {
+        let l3 = d2[c2];
+        l3.y0 += n3 * (c2 + 1), l3.y1 += n3 * (c2 + 1);
+      }
+      Z(d2);
+    }
+  }
+  function W(n2) {
+    let l2 = M(n2);
+    p = Math.min(f, (u - c) / (max(l2, (n3) => n3.length) - 1)), U(l2);
+    for (let n3 = 0; n3 < S; ++n3) {
+      let c2 = 0.99 ** n3, u2 = Math.max(1 - c2, (n3 + 1) / S);
+      K(l2, c2, u2), G(l2, c2, u2);
+    }
+  }
+  function G(n2, c2, l2) {
+    for (let u2 = 1, d2 = n2.length; u2 < d2; ++u2) {
+      let d3 = n2[u2];
+      for (let n3 of d3) {
+        let l3 = 0, u3 = 0;
+        for (let { source: c3, value: d5 } of n3.targetLinks) {
+          let f2 = d5 * (n3.layer - c3.layer);
+          l3 += Q(c3, n3) * f2, u3 += f2;
+        }
+        if (!(u3 > 0)) continue;
+        let d4 = (l3 / u3 - n3.y0) * c2;
+        n3.y0 += d4, n3.y1 += d4, X(n3);
+      }
+      g === void 0 && d3.sort(ascendingBreadth), q(d3, l2);
+    }
+  }
+  function K(n2, c2, l2) {
+    for (let u2 = n2.length - 2; u2 >= 0; --u2) {
+      let d2 = n2[u2];
+      for (let n3 of d2) {
+        let l3 = 0, u3 = 0;
+        for (let { target: c3, value: d4 } of n3.sourceLinks) {
+          let f2 = d4 * (c3.layer - n3.layer);
+          l3 += $(n3, c3) * f2, u3 += f2;
+        }
+        if (!(u3 > 0)) continue;
+        let d3 = (l3 / u3 - n3.y0) * c2;
+        n3.y0 += d3, n3.y1 += d3, X(n3);
+      }
+      g === void 0 && d2.sort(ascendingBreadth), q(d2, l2);
+    }
+  }
+  function q(n2, l2) {
+    let d2 = n2.length >> 1, f2 = n2[d2];
+    Y(n2, f2.y0 - p, d2 - 1, l2), J(n2, f2.y1 + p, d2 + 1, l2), Y(n2, u, n2.length - 1, l2), J(n2, c, 0, l2);
+  }
+  function J(n2, c2, l2, u2) {
+    for (; l2 < n2.length; ++l2) {
+      let d2 = n2[l2], f2 = (c2 - d2.y0) * u2;
+      f2 > 1e-6 && (d2.y0 += f2, d2.y1 += f2), c2 = d2.y1 + p;
+    }
+  }
+  function Y(n2, c2, l2, u2) {
+    for (; l2 >= 0; --l2) {
+      let d2 = n2[l2], f2 = (d2.y1 - c2) * u2;
+      f2 > 1e-6 && (d2.y0 -= f2, d2.y1 -= f2), c2 = d2.y0 - p;
+    }
+  }
+  function X({ sourceLinks: n2, targetLinks: c2 }) {
+    if (_ === void 0) {
+      for (let { source: { sourceLinks: n3 } } of c2) n3.sort(ascendingTargetBreadth);
+      for (let { target: { targetLinks: c3 } } of n2) c3.sort(ascendingSourceBreadth);
+    }
+  }
+  function Z(n2) {
+    if (_ === void 0) for (let { sourceLinks: c2, targetLinks: l2 } of n2) c2.sort(ascendingTargetBreadth), l2.sort(ascendingSourceBreadth);
+  }
+  function Q(n2, c2) {
+    let l2 = n2.y0 - (n2.sourceLinks.length - 1) * p / 2;
+    for (let { target: u2, width: d2 } of n2.sourceLinks) {
+      if (u2 === c2) break;
+      l2 += d2 + p;
+    }
+    for (let { source: u2, width: d2 } of c2.targetLinks) {
+      if (u2 === n2) break;
+      l2 -= d2;
+    }
+    return l2;
+  }
+  function $(n2, c2) {
+    let l2 = c2.y0 - (c2.targetLinks.length - 1) * p / 2;
+    for (let { source: u2, width: d2 } of c2.targetLinks) {
+      if (u2 === n2) break;
+      l2 += d2 + p;
+    }
+    for (let { target: u2, width: d2 } of n2.sourceLinks) {
+      if (u2 === c2) break;
+      l2 -= d2;
+    }
+    return l2;
+  }
+  return C;
+}
+var pi = Math.PI, tau = 2 * pi, epsilon = 1e-6, tauEpsilon = tau - epsilon;
+function Path() {
+  this._x0 = this._y0 = this._x1 = this._y1 = null, this._ = "";
+}
+function path() {
+  return new Path();
+}
+Path.prototype = path.prototype = {
+  constructor: Path,
+  moveTo: function(n, c) {
+    this._ += "M" + (this._x0 = this._x1 = +n) + "," + (this._y0 = this._y1 = +c);
+  },
+  closePath: function() {
+    this._x1 !== null && (this._x1 = this._x0, this._y1 = this._y0, this._ += "Z");
+  },
+  lineTo: function(n, c) {
+    this._ += "L" + (this._x1 = +n) + "," + (this._y1 = +c);
+  },
+  quadraticCurveTo: function(n, c, l, u) {
+    this._ += "Q" + +n + "," + +c + "," + (this._x1 = +l) + "," + (this._y1 = +u);
+  },
+  bezierCurveTo: function(n, c, l, u, d, f) {
+    this._ += "C" + +n + "," + +c + "," + +l + "," + +u + "," + (this._x1 = +d) + "," + (this._y1 = +f);
+  },
+  arcTo: function(n, c, l, u, d) {
+    n = +n, c = +c, l = +l, u = +u, d = +d;
+    var f = this._x1, p = this._y1, m = l - n, h = u - c, g = f - n, _ = p - c, v = g * g + _ * _;
+    if (d < 0) throw Error("negative radius: " + d);
+    if (this._x1 === null) this._ += "M" + (this._x1 = n) + "," + (this._y1 = c);
+    else if (v > epsilon) if (!(Math.abs(_ * m - h * g) > epsilon) || !d) this._ += "L" + (this._x1 = n) + "," + (this._y1 = c);
+    else {
+      var b = l - f, S = u - p, C = m * m + h * h, w = b * b + S * S, T = Math.sqrt(C), E = Math.sqrt(v), D = d * Math.tan((pi - Math.acos((C + v - w) / (2 * T * E))) / 2), O = D / E, k = D / T;
+      Math.abs(O - 1) > epsilon && (this._ += "L" + (n + O * g) + "," + (c + O * _)), this._ += "A" + d + "," + d + ",0,0," + +(_ * b > g * S) + "," + (this._x1 = n + k * m) + "," + (this._y1 = c + k * h);
+    }
+  },
+  arc: function(n, c, l, u, d, f) {
+    n = +n, c = +c, l = +l, f = !!f;
+    var p = l * Math.cos(u), m = l * Math.sin(u), h = n + p, g = c + m, _ = 1 ^ f, v = f ? u - d : d - u;
+    if (l < 0) throw Error("negative radius: " + l);
+    this._x1 === null ? this._ += "M" + h + "," + g : (Math.abs(this._x1 - h) > epsilon || Math.abs(this._y1 - g) > epsilon) && (this._ += "L" + h + "," + g), l && (v < 0 && (v = v % tau + tau), v > tauEpsilon ? this._ += "A" + l + "," + l + ",0,1," + _ + "," + (n - p) + "," + (c - m) + "A" + l + "," + l + ",0,1," + _ + "," + (this._x1 = h) + "," + (this._y1 = g) : v > epsilon && (this._ += "A" + l + "," + l + ",0," + +(v >= pi) + "," + _ + "," + (this._x1 = n + l * Math.cos(d)) + "," + (this._y1 = c + l * Math.sin(d))));
+  },
+  rect: function(n, c, l, u) {
+    this._ += "M" + (this._x0 = this._x1 = +n) + "," + (this._y0 = this._y1 = +c) + "h" + +l + "v" + +u + "h" + -l + "Z";
+  },
+  toString: function() {
+    return this._;
+  }
+};
+var path_default = path;
+function constant_default(n) {
+  return function() {
+    return n;
+  };
+}
+function x(n) {
+  return n[0];
+}
+function y(n) {
+  return n[1];
+}
+var slice = Array.prototype.slice;
+function linkSource(n) {
+  return n.source;
+}
+function linkTarget(n) {
+  return n.target;
+}
+function link(n) {
+  var c = linkSource, l = linkTarget, u = x, d = y, f = null;
+  function p() {
+    var p2, m = slice.call(arguments), h = c.apply(this, m), g = l.apply(this, m);
+    if (f || (f = p2 = path_default()), n(f, +u.apply(this, (m[0] = h, m)), +d.apply(this, m), +u.apply(this, (m[0] = g, m)), +d.apply(this, m)), p2) return f = null, p2 + "" || null;
+  }
+  return p.source = function(n2) {
+    return arguments.length ? (c = n2, p) : c;
+  }, p.target = function(n2) {
+    return arguments.length ? (l = n2, p) : l;
+  }, p.x = function(n2) {
+    return arguments.length ? (u = typeof n2 == "function" ? n2 : constant_default(+n2), p) : u;
+  }, p.y = function(n2) {
+    return arguments.length ? (d = typeof n2 == "function" ? n2 : constant_default(+n2), p) : d;
+  }, p.context = function(n2) {
+    return arguments.length ? (f = n2 ?? null, p) : f;
+  }, p;
+}
+function curveHorizontal(n, c, l, u, d) {
+  n.moveTo(c, l), n.bezierCurveTo(c = (c + u) / 2, l, c, d, u, d);
+}
+function linkHorizontal() {
+  return link(curveHorizontal);
+}
+function horizontalSource(n) {
+  return [n.source.x1, n.y0];
+}
+function horizontalTarget(n) {
+  return [n.target.x0, n.y1];
+}
+function sankeyLinkHorizontal_default() {
+  return linkHorizontal().source(horizontalSource).target(horizontalTarget);
+}
+var parser = (function() {
+  var n = /* @__PURE__ */ __name(function(n2, c2, l2, u) {
+    for (l2 || (l2 = {}), u = n2.length; u--; l2[n2[u]] = c2) ;
+    return l2;
+  }, "o"), c = [1, 9], l = [1, 10], d = [
+    1,
+    5,
+    10,
+    12
+  ], f = {
+    trace: /* @__PURE__ */ __name(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__ */ __name(function(n2, c2, l2, u, d2, f2, p2) {
+      var m = f2.length - 1;
+      switch (d2) {
+        case 7:
+          let n3 = u.findOrCreateNode(f2[m - 4].trim().replaceAll('""', '"')), c3 = u.findOrCreateNode(f2[m - 2].trim().replaceAll('""', '"')), l3 = parseFloat(f2[m].trim());
+          u.addLink(n3, c3, l3);
+          break;
+        case 8:
+        case 9:
+        case 11:
+          this.$ = f2[m];
+          break;
+        case 10:
+          this.$ = f2[m - 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: c,
+        20: l
+      },
+      {
+        1: [2, 6],
+        7: 11,
+        10: [1, 12]
+      },
+      n(l, [2, 4], {
+        9: 13,
+        5: [1, 14]
+      }),
+      { 12: [1, 15] },
+      n(d, [2, 8]),
+      n(d, [2, 9]),
+      { 19: [1, 16] },
+      n(d, [2, 11]),
+      { 1: [2, 1] },
+      { 1: [2, 5] },
+      n(l, [2, 2]),
+      {
+        6: 17,
+        8: 5,
+        15: 6,
+        16: 7,
+        17: 8,
+        18: c,
+        20: l
+      },
+      {
+        15: 18,
+        16: 7,
+        17: 8,
+        18: c,
+        20: l
+      },
+      { 18: [1, 19] },
+      n(l, [2, 3]),
+      { 12: [1, 20] },
+      n(d, [2, 10]),
+      {
+        15: 21,
+        16: 7,
+        17: 8,
+        18: c,
+        20: l
+      },
+      n([
+        1,
+        5,
+        10
+      ], [2, 7])
+    ],
+    defaultActions: {
+      11: [2, 1],
+      12: [2, 5]
+    },
+    parseError: /* @__PURE__ */ __name(function(n2, c2) {
+      if (c2.recoverable) this.trace(n2);
+      else {
+        var l2 = Error(n2);
+        throw l2.hash = c2, l2;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ __name(function(n2) {
+      var c2 = this, l2 = [0], d2 = [], f2 = [null], p2 = [], m = this.table, h = "", g = 0, _ = 0, v = 0, b = 2, S = 1, C = p2.slice.call(arguments, 1), w = Object.create(this.lexer), T = { yy: {} };
+      for (var E in this.yy) Object.prototype.hasOwnProperty.call(this.yy, E) && (T.yy[E] = this.yy[E]);
+      w.setInput(n2, T.yy), T.yy.lexer = w, T.yy.parser = this, w.yylloc === void 0 && (w.yylloc = {});
+      var D = w.yylloc;
+      p2.push(D);
+      var O = w.options && w.options.ranges;
+      typeof T.yy.parseError == "function" ? this.parseError = T.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function k(n3) {
+        l2.length -= 2 * n3, f2.length -= n3, p2.length -= n3;
+      }
+      __name(k, "popStack");
+      function A() {
+        var n3 = d2.pop() || w.lex() || S;
+        return typeof n3 != "number" && (n3 instanceof Array && (d2 = n3, n3 = d2.pop()), n3 = c2.symbols_[n3] || n3), n3;
+      }
+      __name(A, "lex");
+      for (var j, M, N, P, F, I = {}, L, R, z, B; ; ) {
+        if (N = l2[l2.length - 1], this.defaultActions[N] ? P = this.defaultActions[N] : (j ?? (j = A()), P = m[N] && m[N][j]), P === void 0 || !P.length || !P[0]) {
+          var V = "";
+          for (L in B = [], m[N]) this.terminals_[L] && L > b && B.push("'" + this.terminals_[L] + "'");
+          V = w.showPosition ? "Parse error on line " + (g + 1) + ":\n" + w.showPosition() + "\nExpecting " + B.join(", ") + ", got '" + (this.terminals_[j] || j) + "'" : "Parse error on line " + (g + 1) + ": Unexpected " + (j == S ? "end of input" : "'" + (this.terminals_[j] || j) + "'"), this.parseError(V, {
+            text: w.match,
+            token: this.terminals_[j] || j,
+            line: w.yylineno,
+            loc: D,
+            expected: B
+          });
+        }
+        if (P[0] instanceof Array && P.length > 1) throw Error("Parse Error: multiple actions possible at state: " + N + ", token: " + j);
+        switch (P[0]) {
+          case 1:
+            l2.push(j), f2.push(w.yytext), p2.push(w.yylloc), l2.push(P[1]), j = null, M ? (j = M, M = null) : (_ = w.yyleng, h = w.yytext, g = w.yylineno, D = w.yylloc, v > 0 && v--);
+            break;
+          case 2:
+            if (R = this.productions_[P[1]][1], I.$ = f2[f2.length - R], I._$ = {
+              first_line: p2[p2.length - (R || 1)].first_line,
+              last_line: p2[p2.length - 1].last_line,
+              first_column: p2[p2.length - (R || 1)].first_column,
+              last_column: p2[p2.length - 1].last_column
+            }, O && (I._$.range = [p2[p2.length - (R || 1)].range[0], p2[p2.length - 1].range[1]]), F = this.performAction.apply(I, [
+              h,
+              _,
+              g,
+              T.yy,
+              P[1],
+              f2,
+              p2
+            ].concat(C)), F !== void 0) return F;
+            R && (l2 = l2.slice(0, -1 * R * 2), f2 = f2.slice(0, -1 * R), p2 = p2.slice(0, -1 * R)), l2.push(this.productions_[P[1]][0]), f2.push(I.$), p2.push(I._$), z = m[l2[l2.length - 2]][l2[l2.length - 1]], l2.push(z);
+            break;
+          case 3:
+            return true;
+        }
+      }
+      return true;
+    }, "parse")
+  };
+  f.lexer = /* @__PURE__ */ (function() {
+    return {
+      EOF: 1,
+      parseError: /* @__PURE__ */ __name(function(n2, c2) {
+        if (this.yy.parser) this.yy.parser.parseError(n2, c2);
+        else throw Error(n2);
+      }, "parseError"),
+      setInput: /* @__PURE__ */ __name(function(n2, c2) {
+        return this.yy = c2 || this.yy || {}, this._input = n2, this._more = this._backtrack = this.done = false, 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__ */ __name(function() {
+        var n2 = this._input[0];
+        return this.yytext += n2, this.yyleng++, this.offset++, this.match += n2, this.matched += n2, n2.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), n2;
+      }, "input"),
+      unput: /* @__PURE__ */ __name(function(n2) {
+        var c2 = n2.length, l2 = n2.split(/(?:\r\n?|\n)/g);
+        this._input = n2 + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - c2), this.offset -= c2;
+        var u = 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), l2.length - 1 && (this.yylineno -= l2.length - 1);
+        var d2 = 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: l2 ? (l2.length === u.length ? this.yylloc.first_column : 0) + u[u.length - l2.length].length - l2[0].length : this.yylloc.first_column - c2
+        }, this.options.ranges && (this.yylloc.range = [d2[0], d2[0] + this.yyleng - c2]), this.yyleng = this.yytext.length, this;
+      }, "unput"),
+      more: /* @__PURE__ */ __name(function() {
+        return this._more = true, this;
+      }, "more"),
+      reject: /* @__PURE__ */ __name(function() {
+        if (this.options.backtrack_lexer) this._backtrack = true;
+        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).\n" + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+        return this;
+      }, "reject"),
+      less: /* @__PURE__ */ __name(function(n2) {
+        this.unput(this.match.slice(n2));
+      }, "less"),
+      pastInput: /* @__PURE__ */ __name(function() {
+        var n2 = this.matched.substr(0, this.matched.length - this.match.length);
+        return (n2.length > 20 ? "..." : "") + n2.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      upcomingInput: /* @__PURE__ */ __name(function() {
+        var n2 = this.match;
+        return n2.length < 20 && (n2 += this._input.substr(0, 20 - n2.length)), (n2.substr(0, 20) + (n2.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      showPosition: /* @__PURE__ */ __name(function() {
+        var n2 = this.pastInput(), c2 = Array(n2.length + 1).join("-");
+        return n2 + this.upcomingInput() + "\n" + c2 + "^";
+      }, "showPosition"),
+      test_match: /* @__PURE__ */ __name(function(n2, c2) {
+        var l2, u, d2;
+        if (this.options.backtrack_lexer && (d2 = {
+          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 && (d2.yylloc.range = this.yylloc.range.slice(0))), u = n2[0].match(/(?:\r\n?|\n).*/g), u && (this.yylineno += u.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: u ? u[u.length - 1].length - u[u.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + n2[0].length
+        }, this.yytext += n2[0], this.match += n2[0], this.matches = n2, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = false, this._backtrack = false, this._input = this._input.slice(n2[0].length), this.matched += n2[0], l2 = this.performAction.call(this, this.yy, this, c2, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = false), l2) return l2;
+        if (this._backtrack) {
+          for (var f2 in d2) this[f2] = d2[f2];
+          return false;
+        }
+        return false;
+      }, "test_match"),
+      next: /* @__PURE__ */ __name(function() {
+        if (this.done) return this.EOF;
+        this._input || (this.done = true);
+        var n2, c2, l2, u;
+        this._more || (this.yytext = "", this.match = "");
+        for (var d2 = this._currentRules(), f2 = 0; f2 < d2.length; f2++) if (l2 = this._input.match(this.rules[d2[f2]]), l2 && (!c2 || l2[0].length > c2[0].length)) {
+          if (c2 = l2, u = f2, this.options.backtrack_lexer) {
+            if (n2 = this.test_match(l2, d2[f2]), n2 !== false) return n2;
+            if (this._backtrack) {
+              c2 = false;
+              continue;
+            } else return false;
+          } else if (!this.options.flex) break;
+        }
+        return c2 ? (n2 = this.test_match(c2, d2[u]), n2 === false ? false : n2) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      }, "next"),
+      lex: /* @__PURE__ */ __name(function() {
+        return this.next() || this.lex();
+      }, "lex"),
+      begin: /* @__PURE__ */ __name(function(n2) {
+        this.conditionStack.push(n2);
+      }, "begin"),
+      popState: /* @__PURE__ */ __name(function() {
+        return this.conditionStack.length - 1 > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      }, "popState"),
+      _currentRules: /* @__PURE__ */ __name(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__ */ __name(function(n2) {
+        return n2 = this.conditionStack.length - 1 - Math.abs(n2 || 0), n2 >= 0 ? this.conditionStack[n2] : "INITIAL";
+      }, "topState"),
+      pushState: /* @__PURE__ */ __name(function(n2) {
+        this.begin(n2);
+      }, "pushState"),
+      stateStackSize: /* @__PURE__ */ __name(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: { "case-insensitive": true },
+      performAction: /* @__PURE__ */ __name(function(n2, c2, l2, u) {
+        switch (l2) {
+          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: false
+        },
+        escaped_text: {
+          rules: [7, 8],
+          inclusive: false
+        },
+        INITIAL: {
+          rules: [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8
+          ],
+          inclusive: true
+        }
+      }
+    };
+  })();
+  function p() {
+    this.yy = {};
+  }
+  return __name(p, "Parser"), p.prototype = f, f.Parser = p, new p();
+})();
+parser.parser = parser;
+var sankey_default = parser, links = [], nodes = [], nodesMap = /* @__PURE__ */ new Map(), clear2 = /* @__PURE__ */ __name(() => {
+  links = [], nodes = [], nodesMap = /* @__PURE__ */ new Map(), clear();
+}, "clear"), SankeyLink = (_a = class {
+  constructor(n, c, l = 0) {
+    this.source = n, this.target = c, this.value = l;
+  }
+}, __name(_a, "SankeyLink"), _a), addLink = /* @__PURE__ */ __name((n, c, l) => {
+  links.push(new SankeyLink(n, c, l));
+}, "addLink"), SankeyNode = (_b = class {
+  constructor(n) {
+    this.ID = n;
+  }
+}, __name(_b, "SankeyNode"), _b), sankeyDB_default = {
+  nodesMap,
+  getConfig: /* @__PURE__ */ __name(() => getConfig2().sankey, "getConfig"),
+  getNodes: /* @__PURE__ */ __name(() => nodes, "getNodes"),
+  getLinks: /* @__PURE__ */ __name(() => links, "getLinks"),
+  getGraph: /* @__PURE__ */ __name(() => ({
+    nodes: nodes.map((n) => ({ id: n.ID })),
+    links: links.map((n) => ({
+      source: n.source.ID,
+      target: n.target.ID,
+      value: n.value
+    }))
+  }), "getGraph"),
+  addLink,
+  findOrCreateNode: /* @__PURE__ */ __name((n) => {
+    n = common_default.sanitizeText(n, getConfig2());
+    let c = nodesMap.get(n);
+    return c === void 0 && (c = new SankeyNode(n), nodesMap.set(n, c), nodes.push(c)), c;
+  }, "findOrCreateNode"),
+  getAccTitle,
+  setAccTitle,
+  getAccDescription,
+  setAccDescription,
+  getDiagramTitle,
+  setDiagramTitle,
+  clear: clear2
+}, Uid = (_c = class {
+  static next(c) {
+    return new _c(c + ++_c.count);
+  }
+  constructor(n) {
+    this.id = n, this.href = `#${n}`;
+  }
+  toString() {
+    return "url(" + this.href + ")";
+  }
+}, __name(_c, "Uid"), _c.count = 0, _c), alignmentsMap = {
+  left,
+  right,
+  center,
+  justify
+}, findCentralNodeLayer = /* @__PURE__ */ __name((n) => {
+  let c = 0, l = 0;
+  for (let u of n) {
+    let n2 = u.value ?? 0;
+    n2 > c && (c = n2, l = u.layer ?? 0);
+  }
+  return l;
+}, "findCentralNodeLayer"), sankeyRenderer_default = { draw: /* @__PURE__ */ __name(function(c, d, p, m) {
+  let { securityLevel: h, sankey: _ } = getConfig2(), v = defaultConfig2.sankey, b;
+  h === "sandbox" && (b = select_default("#i" + d));
+  let C = select_default(h === "sandbox" ? b.nodes()[0].contentDocument.body : "body"), T = h === "sandbox" ? C.select(`[id="${d}"]`) : select_default(`[id="${d}"]`), E = (_ == null ? void 0 : _.width) ?? v.width, D = (_ == null ? void 0 : _.height) ?? v.width, O = (_ == null ? void 0 : _.useMaxWidth) ?? v.useMaxWidth, k = (_ == null ? void 0 : _.nodeAlignment) ?? v.nodeAlignment, A = (_ == null ? void 0 : _.prefix) ?? v.prefix, j = (_ == null ? void 0 : _.suffix) ?? v.suffix, M = (_ == null ? void 0 : _.showValues) ?? v.showValues, N = (_ == null ? void 0 : _.nodeWidth) ?? v.nodeWidth ?? 10, P = (_ == null ? void 0 : _.nodePadding) ?? v.nodePadding ?? 12, F = (_ == null ? void 0 : _.labelStyle) ?? v.labelStyle ?? "legacy", I = (_ == null ? void 0 : _.nodeColors) ?? {}, L = m.db.getGraph(), R = alignmentsMap[k];
+  Sankey().nodeId((n) => n.id).nodeWidth(N).nodePadding(P + (M ? 15 : 0)).nodeAlign(R).extent([[0, 0], [E, D]])(L);
+  let z = findCentralNodeLayer(L.nodes), B = ordinal(Tableau10_default), V = /* @__PURE__ */ __name((n) => I[n] ?? B(n), "getNodeColor");
+  T.append("g").attr("class", "nodes").selectAll(".node").data(L.nodes).join("g").attr("class", "node").attr("id", (n) => (n.uid = Uid.next("node-")).id).attr("transform", function(n) {
+    return "translate(" + n.x0 + "," + n.y0 + ")";
+  }).attr("x", (n) => n.x0).attr("y", (n) => n.y0).append("rect").attr("height", (n) => n.y1 - n.y0).attr("width", (n) => n.x1 - n.x0).attr("fill", (n) => V(n.id));
+  let H = /* @__PURE__ */ __name(({ id: n, value: c2 }) => M ? `${n}
+${A}${Math.round(c2 * 100) / 100}${j}` : n, "getText"), W = /* @__PURE__ */ __name((n) => F === "outlined" ? (n.layer ?? 0) < z ? {
+    x: n.x0 - 6,
+    anchor: "end"
+  } : {
+    x: n.x1 + 6,
+    anchor: "start"
+  } : n.x0 < E / 2 ? {
+    x: n.x1 + 6,
+    anchor: "start"
+  } : {
+    x: n.x0 - 6,
+    anchor: "end"
+  }, "getLabelPosition"), G = T.append("g").attr("class", "node-labels").attr("font-size", 14), K = /* @__PURE__ */ __name((n) => G.selectAll(n ? `.${n}` : "text").data(L.nodes).join("text").attr("class", n ?? null).attr("x", (n2) => W(n2).x).attr("y", (n2) => (n2.y1 + n2.y0) / 2).attr("dy", `${M ? "0" : "0.35"}em`).attr("text-anchor", (n2) => W(n2).anchor).text(H), "appendLabel");
+  F === "outlined" ? (K("sankey-label-bg"), K("sankey-label-fg")) : K();
+  let q = T.append("g").attr("class", "links").attr("fill", "none").attr("stroke-opacity", 0.5).selectAll(".link").data(L.links).join("g").attr("class", "link").style("mix-blend-mode", "multiply"), J = (_ == null ? void 0 : _.linkColor) ?? "gradient";
+  if (J === "gradient") {
+    let n = q.append("linearGradient").attr("id", (n2) => (n2.uid = Uid.next("linearGradient-")).id).attr("gradientUnits", "userSpaceOnUse").attr("x1", (n2) => n2.source.x1).attr("x2", (n2) => n2.target.x0);
+    n.append("stop").attr("offset", "0%").attr("stop-color", (n2) => V(n2.source.id)), n.append("stop").attr("offset", "100%").attr("stop-color", (n2) => V(n2.target.id));
+  }
+  let Y;
+  switch (J) {
+    case "gradient":
+      Y = /* @__PURE__ */ __name((n) => n.uid, "coloring");
+      break;
+    case "source":
+      Y = /* @__PURE__ */ __name((n) => V(n.source.id), "coloring");
+      break;
+    case "target":
+      Y = /* @__PURE__ */ __name((n) => V(n.target.id), "coloring");
+      break;
+    default:
+      Y = J;
+  }
+  q.append("path").attr("d", sankeyLinkHorizontal_default()).attr("stroke", Y).attr("stroke-width", (n) => Math.max(1, n.width)), setupGraphViewbox(void 0, T, 0, O);
+}, "draw") }, prepareTextForParsing = /* @__PURE__ */ __name((n) => n.replaceAll(/^[^\S\n\r]+|[^\S\n\r]+$/g, "").replaceAll(/([\n\r])+/g, "\n").trim(), "prepareTextForParsing"), styles_default = /* @__PURE__ */ __name((n) => `.label {
+    font-family: ${n.fontFamily};
+  }
+
+  .node-labels {
+    font-family: ${n.fontFamily};
+  }
+
+  /* Outlined label style - background stroke for better readability */
+  .sankey-label-bg {
+    stroke: ${n.mainBkg || n.background || "#fff"};
+    stroke-width: 4px;
+    stroke-linejoin: round;
+    paint-order: stroke;
+  }
+
+  /* Foreground label text */
+  .sankey-label-fg {
+    fill: ${n.textColor};
+  }
+
+  /* Node styling */
+  .node rect {
+    shape-rendering: crispEdges;
+  }
+
+  /* Link styling */
+  .link {
+    fill: none;
+    stroke-opacity: 0.5;
+    mix-blend-mode: multiply;
+  }
+`, "getStyles"), originalParse = sankey_default.parse.bind(sankey_default);
+sankey_default.parse = (n) => originalParse(prepareTextForParsing(n));
+var diagram = {
+  styles: styles_default,
+  parser: sankey_default,
+  db: sankeyDB_default,
+  renderer: sankeyRenderer_default
+};
+export {
+  diagram
+};