@marimo-team/islands 0.23.17-dev9 → 0.24.0

package/dist/ishikawaDiagram-WSZJBQD7-BrOMFBYy.js

@@ -0,0 +1,731 @@
+var _a;
+import "./purify.es-DR5PNXwx.js";
+import { m as parseFontSize } from "./chunk-NSK5VX7P-BmmoJBbx.js";
+import "./src-BwVZVGyf.js";
+import { n as __name } from "./chunk-Y2CYZVJY-DX3DSigL.js";
+import { H as setAccDescription, K as setDiagramTitle, U as setAccTitle, a as clear, c as configureSvgSize, s as common_default, v as getAccDescription, w as getDiagramTitle, x as getConfig2, y as getAccTitle } from "./chunk-I66GZJ75-9xAsFrdW.js";
+import { t as selectSvgElement } from "./chunk-3NCLNEKW-BPlp8K7N.js";
+import "./dist-HaLHv0k5.js";
+import { t as at } from "./rough.esm-lGyFQ0B-.js";
+var parser = (function() {
+  var e = /* @__PURE__ */ __name(function(e2, n, r2, i2) {
+    for (r2 || (r2 = {}), i2 = e2.length; i2--; r2[e2[i2]] = n) ;
+    return r2;
+  }, "o"), r = [1, 4], i = [1, 14], a = [1, 12], o = [1, 13], s = [
+    6,
+    7,
+    8
+  ], c = [1, 20], l = [1, 18], u = [1, 19], d = [
+    6,
+    7,
+    11
+  ], f = [
+    1,
+    6,
+    13,
+    14
+  ], p = [1, 23], m = [1, 24], h = [
+    1,
+    6,
+    7,
+    11,
+    13,
+    14
+  ], g = {
+    trace: /* @__PURE__ */ __name(function() {
+    }, "trace"),
+    yy: {},
+    symbols_: {
+      error: 2,
+      start: 3,
+      ishikawa: 4,
+      spaceLines: 5,
+      SPACELINE: 6,
+      NL: 7,
+      ISHIKAWA: 8,
+      document: 9,
+      stop: 10,
+      EOF: 11,
+      statement: 12,
+      SPACELIST: 13,
+      TEXT: 14,
+      $accept: 0,
+      $end: 1
+    },
+    terminals_: {
+      2: "error",
+      6: "SPACELINE",
+      7: "NL",
+      8: "ISHIKAWA",
+      11: "EOF",
+      13: "SPACELIST",
+      14: "TEXT"
+    },
+    productions_: [
+      0,
+      [3, 1],
+      [3, 2],
+      [5, 1],
+      [5, 2],
+      [5, 2],
+      [4, 2],
+      [4, 3],
+      [10, 1],
+      [10, 1],
+      [10, 1],
+      [10, 2],
+      [10, 2],
+      [9, 3],
+      [9, 2],
+      [12, 2],
+      [12, 1],
+      [12, 1],
+      [12, 1]
+    ],
+    performAction: /* @__PURE__ */ __name(function(e2, n, r2, i2, a2, o2, s2) {
+      var c2 = o2.length - 1;
+      switch (a2) {
+        case 6:
+        case 7:
+          return i2;
+        case 15:
+          i2.addNode(o2[c2 - 1].length, o2[c2].trim());
+          break;
+        case 16:
+          i2.addNode(0, o2[c2].trim());
+          break;
+      }
+    }, "anonymous"),
+    table: [
+      {
+        3: 1,
+        4: 2,
+        5: 3,
+        6: [1, 5],
+        8: r
+      },
+      { 1: [3] },
+      { 1: [2, 1] },
+      {
+        4: 6,
+        6: [1, 7],
+        7: [1, 8],
+        8: r
+      },
+      {
+        6: i,
+        7: [1, 10],
+        9: 9,
+        12: 11,
+        13: a,
+        14: o
+      },
+      e(s, [2, 3]),
+      { 1: [2, 2] },
+      e(s, [2, 4]),
+      e(s, [2, 5]),
+      {
+        1: [2, 6],
+        6: i,
+        12: 15,
+        13: a,
+        14: o
+      },
+      {
+        6: i,
+        9: 16,
+        12: 11,
+        13: a,
+        14: o
+      },
+      {
+        6: c,
+        7: l,
+        10: 17,
+        11: u
+      },
+      e(d, [2, 18], { 14: [1, 21] }),
+      e(d, [2, 16]),
+      e(d, [2, 17]),
+      {
+        6: c,
+        7: l,
+        10: 22,
+        11: u
+      },
+      {
+        1: [2, 7],
+        6: i,
+        12: 15,
+        13: a,
+        14: o
+      },
+      e(f, [2, 14], {
+        7: p,
+        11: m
+      }),
+      e(h, [2, 8]),
+      e(h, [2, 9]),
+      e(h, [2, 10]),
+      e(d, [2, 15]),
+      e(f, [2, 13], {
+        7: p,
+        11: m
+      }),
+      e(h, [2, 11]),
+      e(h, [2, 12])
+    ],
+    defaultActions: {
+      2: [2, 1],
+      6: [2, 2]
+    },
+    parseError: /* @__PURE__ */ __name(function(e2, n) {
+      if (n.recoverable) this.trace(e2);
+      else {
+        var r2 = Error(e2);
+        throw r2.hash = n, r2;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ __name(function(e2) {
+      var r2 = this, i2 = [0], a2 = [], o2 = [null], s2 = [], c2 = this.table, l2 = "", u2 = 0, d2 = 0, f2 = 0, p2 = 2, m2 = 1, h2 = s2.slice.call(arguments, 1), g2 = Object.create(this.lexer), _2 = { yy: {} };
+      for (var v in this.yy) Object.prototype.hasOwnProperty.call(this.yy, v) && (_2.yy[v] = this.yy[v]);
+      g2.setInput(e2, _2.yy), _2.yy.lexer = g2, _2.yy.parser = this, g2.yylloc === void 0 && (g2.yylloc = {});
+      var y = g2.yylloc;
+      s2.push(y);
+      var b = g2.options && g2.options.ranges;
+      typeof _2.yy.parseError == "function" ? this.parseError = _2.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function x(e3) {
+        i2.length -= 2 * e3, o2.length -= e3, s2.length -= e3;
+      }
+      __name(x, "popStack");
+      function S() {
+        var e3 = a2.pop() || g2.lex() || m2;
+        return typeof e3 != "number" && (e3 instanceof Array && (a2 = e3, e3 = a2.pop()), e3 = r2.symbols_[e3] || e3), e3;
+      }
+      __name(S, "lex");
+      for (var C, w, T, E, D, O = {}, k, A, j, M; ; ) {
+        if (T = i2[i2.length - 1], this.defaultActions[T] ? E = this.defaultActions[T] : (C ?? (C = S()), E = c2[T] && c2[T][C]), E === void 0 || !E.length || !E[0]) {
+          var N = "";
+          for (k in M = [], c2[T]) this.terminals_[k] && k > p2 && M.push("'" + this.terminals_[k] + "'");
+          N = g2.showPosition ? "Parse error on line " + (u2 + 1) + ":\n" + g2.showPosition() + "\nExpecting " + M.join(", ") + ", got '" + (this.terminals_[C] || C) + "'" : "Parse error on line " + (u2 + 1) + ": Unexpected " + (C == m2 ? "end of input" : "'" + (this.terminals_[C] || C) + "'"), this.parseError(N, {
+            text: g2.match,
+            token: this.terminals_[C] || C,
+            line: g2.yylineno,
+            loc: y,
+            expected: M
+          });
+        }
+        if (E[0] instanceof Array && E.length > 1) throw Error("Parse Error: multiple actions possible at state: " + T + ", token: " + C);
+        switch (E[0]) {
+          case 1:
+            i2.push(C), o2.push(g2.yytext), s2.push(g2.yylloc), i2.push(E[1]), C = null, w ? (C = w, w = null) : (d2 = g2.yyleng, l2 = g2.yytext, u2 = g2.yylineno, y = g2.yylloc, f2 > 0 && f2--);
+            break;
+          case 2:
+            if (A = this.productions_[E[1]][1], O.$ = o2[o2.length - A], O._$ = {
+              first_line: s2[s2.length - (A || 1)].first_line,
+              last_line: s2[s2.length - 1].last_line,
+              first_column: s2[s2.length - (A || 1)].first_column,
+              last_column: s2[s2.length - 1].last_column
+            }, b && (O._$.range = [s2[s2.length - (A || 1)].range[0], s2[s2.length - 1].range[1]]), D = this.performAction.apply(O, [
+              l2,
+              d2,
+              u2,
+              _2.yy,
+              E[1],
+              o2,
+              s2
+            ].concat(h2)), D !== void 0) return D;
+            A && (i2 = i2.slice(0, -1 * A * 2), o2 = o2.slice(0, -1 * A), s2 = s2.slice(0, -1 * A)), i2.push(this.productions_[E[1]][0]), o2.push(O.$), s2.push(O._$), j = c2[i2[i2.length - 2]][i2[i2.length - 1]], i2.push(j);
+            break;
+          case 3:
+            return true;
+        }
+      }
+      return true;
+    }, "parse")
+  };
+  g.lexer = /* @__PURE__ */ (function() {
+    return {
+      EOF: 1,
+      parseError: /* @__PURE__ */ __name(function(e2, n) {
+        if (this.yy.parser) this.yy.parser.parseError(e2, n);
+        else throw Error(e2);
+      }, "parseError"),
+      setInput: /* @__PURE__ */ __name(function(e2, n) {
+        return this.yy = n || this.yy || {}, this._input = e2, 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 e2 = this._input[0];
+        return this.yytext += e2, this.yyleng++, this.offset++, this.match += e2, this.matched += e2, e2.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), e2;
+      }, "input"),
+      unput: /* @__PURE__ */ __name(function(e2) {
+        var n = e2.length, r2 = e2.split(/(?:\r\n?|\n)/g);
+        this._input = e2 + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - n), this.offset -= n;
+        var i2 = 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), r2.length - 1 && (this.yylineno -= r2.length - 1);
+        var a2 = 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: r2 ? (r2.length === i2.length ? this.yylloc.first_column : 0) + i2[i2.length - r2.length].length - r2[0].length : this.yylloc.first_column - n
+        }, this.options.ranges && (this.yylloc.range = [a2[0], a2[0] + this.yyleng - n]), 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(e2) {
+        this.unput(this.match.slice(e2));
+      }, "less"),
+      pastInput: /* @__PURE__ */ __name(function() {
+        var e2 = this.matched.substr(0, this.matched.length - this.match.length);
+        return (e2.length > 20 ? "..." : "") + e2.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      upcomingInput: /* @__PURE__ */ __name(function() {
+        var e2 = this.match;
+        return e2.length < 20 && (e2 += this._input.substr(0, 20 - e2.length)), (e2.substr(0, 20) + (e2.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      showPosition: /* @__PURE__ */ __name(function() {
+        var e2 = this.pastInput(), n = Array(e2.length + 1).join("-");
+        return e2 + this.upcomingInput() + "\n" + n + "^";
+      }, "showPosition"),
+      test_match: /* @__PURE__ */ __name(function(e2, n) {
+        var r2, i2, a2;
+        if (this.options.backtrack_lexer && (a2 = {
+          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 && (a2.yylloc.range = this.yylloc.range.slice(0))), i2 = e2[0].match(/(?:\r\n?|\n).*/g), i2 && (this.yylineno += i2.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: i2 ? i2[i2.length - 1].length - i2[i2.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + e2[0].length
+        }, this.yytext += e2[0], this.match += e2[0], this.matches = e2, 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(e2[0].length), this.matched += e2[0], r2 = this.performAction.call(this, this.yy, this, n, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = false), r2) return r2;
+        if (this._backtrack) {
+          for (var o2 in a2) this[o2] = a2[o2];
+          return false;
+        }
+        return false;
+      }, "test_match"),
+      next: /* @__PURE__ */ __name(function() {
+        if (this.done) return this.EOF;
+        this._input || (this.done = true);
+        var e2, n, r2, i2;
+        this._more || (this.yytext = "", this.match = "");
+        for (var a2 = this._currentRules(), o2 = 0; o2 < a2.length; o2++) if (r2 = this._input.match(this.rules[a2[o2]]), r2 && (!n || r2[0].length > n[0].length)) {
+          if (n = r2, i2 = o2, this.options.backtrack_lexer) {
+            if (e2 = this.test_match(r2, a2[o2]), e2 !== false) return e2;
+            if (this._backtrack) {
+              n = false;
+              continue;
+            } else return false;
+          } else if (!this.options.flex) break;
+        }
+        return n ? (e2 = this.test_match(n, a2[i2]), e2 === false ? false : e2) : 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(e2) {
+        this.conditionStack.push(e2);
+      }, "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(e2) {
+        return e2 = this.conditionStack.length - 1 - Math.abs(e2 || 0), e2 >= 0 ? this.conditionStack[e2] : "INITIAL";
+      }, "topState"),
+      pushState: /* @__PURE__ */ __name(function(e2) {
+        this.begin(e2);
+      }, "pushState"),
+      stateStackSize: /* @__PURE__ */ __name(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: { "case-insensitive": true },
+      performAction: /* @__PURE__ */ __name(function(e2, n, r2, i2) {
+        switch (r2) {
+          case 0:
+            return 6;
+          case 1:
+            return 8;
+          case 2:
+            return 8;
+          case 3:
+            return 6;
+          case 4:
+            return 7;
+          case 5:
+            return 13;
+          case 6:
+            return 14;
+          case 7:
+            return 11;
+        }
+      }, "anonymous"),
+      rules: [
+        /^(?:\s*%%.*)/i,
+        /^(?:ishikawa-beta\b)/i,
+        /^(?:ishikawa\b)/i,
+        /^(?:[\s]+[\n])/i,
+        /^(?:[\n]+)/i,
+        /^(?:[\s]+)/i,
+        /^(?:[^\n]+)/i,
+        /^(?:$)/i
+      ],
+      conditions: { INITIAL: {
+        rules: [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7
+        ],
+        inclusive: true
+      } }
+    };
+  })();
+  function _() {
+    this.yy = {};
+  }
+  return __name(_, "Parser"), _.prototype = g, g.Parser = _, new _();
+})();
+parser.parser = parser;
+var ishikawa_default = parser, IshikawaDB = (_a = class {
+  constructor() {
+    this.stack = [], this.clear = this.clear.bind(this), this.addNode = this.addNode.bind(this), this.getRoot = this.getRoot.bind(this);
+  }
+  clear() {
+    this.root = void 0, this.stack = [], this.baseLevel = void 0, clear();
+  }
+  getRoot() {
+    return this.root;
+  }
+  addNode(e, n) {
+    let r = common_default.sanitizeText(n, getConfig2());
+    if (!this.root) {
+      this.root = {
+        text: r,
+        children: []
+      }, this.stack = [{
+        level: 0,
+        node: this.root
+      }], setDiagramTitle(r);
+      return;
+    }
+    this.baseLevel ?? (this.baseLevel = e);
+    let a = e - this.baseLevel + 1;
+    for (a <= 0 && (a = 1); this.stack.length > 1 && this.stack[this.stack.length - 1].level >= a; ) this.stack.pop();
+    let o = this.stack[this.stack.length - 1].node, s = {
+      text: r,
+      children: []
+    };
+    o.children.push(s), this.stack.push({
+      level: a,
+      node: s
+    });
+  }
+  getAccTitle() {
+    return getAccTitle();
+  }
+  setAccTitle(e) {
+    setAccTitle(e);
+  }
+  getAccDescription() {
+    return getAccDescription();
+  }
+  setAccDescription(e) {
+    setAccDescription(e);
+  }
+  getDiagramTitle() {
+    return getDiagramTitle();
+  }
+  setDiagramTitle(e) {
+    setDiagramTitle(e);
+  }
+}, __name(_a, "IshikawaDB"), _a), FONT_SIZE_DEFAULT = 14, SPINE_BASE_LENGTH = 250, BONE_STUB = 30, BONE_BASE = 60, BONE_PER_CHILD = 5, ANGLE = 82 * Math.PI / 180, COS_A = Math.cos(ANGLE), SIN_A = Math.sin(ANGLE), applyPaddedViewBox = /* @__PURE__ */ __name((e, n, r) => {
+  let i = e.node().getBBox(), a = i.width + n * 2, o = i.height + n * 2;
+  configureSvgSize(e, o, a, r), e.attr("viewBox", `${i.x - n} ${i.y - n} ${a} ${o}`);
+}, "applyPaddedViewBox"), draw = /* @__PURE__ */ __name((n, r, i, a) => {
+  var _a2, _b;
+  let o = a.db.getRoot();
+  if (!o) return;
+  let s = getConfig2(), { look: c, handDrawnSeed: l, themeVariables: u } = s, f = parseFontSize(s.fontSize)[0] ?? FONT_SIZE_DEFAULT, h = c === "handDrawn", g = o.children ?? [], _ = ((_a2 = s.ishikawa) == null ? void 0 : _a2.diagramPadding) ?? 20, b = ((_b = s.ishikawa) == null ? void 0 : _b.useMaxWidth) ?? false, x = selectSvgElement(r), S = x.append("g").attr("class", "ishikawa"), C = h ? at.svg(x.node()) : void 0, w = C ? {
+    roughSvg: C,
+    seed: l ?? 0,
+    lineColor: (u == null ? void 0 : u.lineColor) ?? "#333",
+    fillColor: (u == null ? void 0 : u.mainBkg) ?? "#fff"
+  } : void 0, T = `ishikawa-arrow-${r}`;
+  h || S.append("defs").append("marker").attr("id", T).attr("viewBox", "0 0 10 10").attr("refX", 0).attr("refY", 5).attr("markerWidth", 6).attr("markerHeight", 6).attr("orient", "auto").append("path").attr("d", "M 10 0 L 0 5 L 10 10 Z").attr("class", "ishikawa-arrow");
+  let D = 0, A = SPINE_BASE_LENGTH, j = h ? void 0 : drawLine(S, D, A, D, A, "ishikawa-spine");
+  if (drawHead(S, D, A, o.text, f, w), !g.length) {
+    h && drawLine(S, D, A, D, A, "ishikawa-spine", w), applyPaddedViewBox(x, _, b);
+    return;
+  }
+  D -= 20;
+  let M = g.filter((e, n2) => n2 % 2 == 0), P = g.filter((e, n2) => n2 % 2 == 1), F = sideStats(M), I = sideStats(P), L = F.total + I.total, R = SPINE_BASE_LENGTH, z = SPINE_BASE_LENGTH;
+  if (L > 0) {
+    let e = SPINE_BASE_LENGTH * 2, n2 = SPINE_BASE_LENGTH * 0.3;
+    R = Math.max(n2, e * (F.total / L)), z = Math.max(n2, e * (I.total / L));
+  }
+  let B = f * 2;
+  R = Math.max(R, F.max * B), z = Math.max(z, I.max * B), A = Math.max(R, SPINE_BASE_LENGTH), j && j.attr("y1", A).attr("y2", A), S.select(".ishikawa-head-group").attr("transform", `translate(0,${A})`);
+  let V = Math.ceil(g.length / 2);
+  for (let e = 0; e < V; e++) {
+    let n2 = S.append("g").attr("class", "ishikawa-pair");
+    for (let [r2, i2, a2] of [[
+      g[e * 2],
+      -1,
+      R
+    ], [
+      g[e * 2 + 1],
+      1,
+      z
+    ]]) r2 && drawBranch(n2, r2, D, A, i2, a2, f, w);
+    D = n2.selectAll("text").nodes().reduce((e2, n3) => Math.min(e2, n3.getBBox().x), Infinity);
+  }
+  if (h) drawLine(S, D, A, 0, A, "ishikawa-spine", w);
+  else {
+    j.attr("x1", D);
+    let e = `url(#${T})`;
+    S.selectAll("line.ishikawa-branch, line.ishikawa-sub-branch").attr("marker-start", e);
+  }
+  applyPaddedViewBox(x, _, b);
+}, "draw"), sideStats = /* @__PURE__ */ __name((e) => {
+  let r = /* @__PURE__ */ __name((e2) => e2.children.reduce((e3, n) => e3 + 1 + r(n), 0), "countDescendants");
+  return e.reduce((e2, n) => {
+    let i = r(n);
+    return e2.total += i, e2.max = Math.max(e2.max, i), e2;
+  }, {
+    total: 0,
+    max: 0
+  });
+}, "sideStats"), drawHead = /* @__PURE__ */ __name((e, n, r, i, a, o) => {
+  let s = Math.max(6, Math.floor(110 / (a * 0.6))), c = e.append("g").attr("class", "ishikawa-head-group").attr("transform", `translate(${n},${r})`), l = drawMultilineText(c, wrapText(i, s), 0, 0, "ishikawa-head-label", "start", a), u = l.node().getBBox(), d = Math.max(60, u.width + 6), f = Math.max(40, u.height * 2 + 40), p = `M 0 ${-f / 2} L 0 ${f / 2} Q ${d * 2.4} 0 0 ${-f / 2} Z`;
+  if (o) {
+    let e2 = o.roughSvg.path(p, {
+      roughness: 1.5,
+      seed: o.seed,
+      fill: o.fillColor,
+      fillStyle: "hachure",
+      fillWeight: 2.5,
+      hachureGap: 5,
+      stroke: o.lineColor,
+      strokeWidth: 2
+    });
+    c.insert(() => e2, ":first-child").attr("class", "ishikawa-head");
+  } else c.insert("path", ":first-child").attr("class", "ishikawa-head").attr("d", p);
+  l.attr("transform", `translate(${(d - u.width) / 2 - u.x + 3},${-u.y - u.height / 2})`);
+}, "drawHead"), flattenTree = /* @__PURE__ */ __name((e, r) => {
+  let i = [], a = [], o = /* @__PURE__ */ __name((e2, n, s) => {
+    let c = r === -1 ? [...e2].reverse() : e2;
+    for (let e3 of c) {
+      let r2 = i.length, c2 = e3.children ?? [];
+      i.push({
+        depth: s,
+        text: wrapText(e3.text, 15),
+        parentIndex: n,
+        childCount: c2.length
+      }), s % 2 == 0 ? (a.push(r2), c2.length && o(c2, r2, s + 1)) : (c2.length && o(c2, r2, s + 1), a.push(r2));
+    }
+  }, "walk");
+  return o(e, -1, 2), {
+    entries: i,
+    yOrder: a
+  };
+}, "flattenTree"), drawCauseLabel = /* @__PURE__ */ __name((e, n, r, i, a, o, s) => {
+  let c = e.append("g").attr("class", "ishikawa-label-group"), l = drawMultilineText(c, n, r, i + 11 * a, "ishikawa-label cause", "middle", o).node().getBBox();
+  if (s) {
+    let e2 = s.roughSvg.rectangle(l.x - 20, l.y - 2, l.width + 40, l.height + 4, {
+      roughness: 1.5,
+      seed: s.seed,
+      fill: s.fillColor,
+      fillStyle: "hachure",
+      fillWeight: 2.5,
+      hachureGap: 5,
+      stroke: s.lineColor,
+      strokeWidth: 2
+    });
+    c.insert(() => e2, ":first-child").attr("class", "ishikawa-label-box");
+  } else c.insert("rect", ":first-child").attr("class", "ishikawa-label-box").attr("x", l.x - 20).attr("y", l.y - 2).attr("width", l.width + 40).attr("height", l.height + 4);
+}, "drawCauseLabel"), drawArrowMarker = /* @__PURE__ */ __name((e, n, r, i, a, o) => {
+  let s = Math.sqrt(i * i + a * a);
+  if (s === 0) return;
+  let c = i / s, l = a / s, u = -l * 6, d = c * 6, f = n, p = r, m = `M ${f} ${p} L ${f - c * 6 * 2 + u} ${p - l * 6 * 2 + d} L ${f - c * 6 * 2 - u} ${p - l * 6 * 2 - d} Z`, h = o.roughSvg.path(m, {
+    roughness: 1,
+    seed: o.seed,
+    fill: o.lineColor,
+    fillStyle: "solid",
+    stroke: o.lineColor,
+    strokeWidth: 1
+  });
+  e.append(() => h);
+}, "drawArrowMarker"), drawBranch = /* @__PURE__ */ __name((e, n, r, i, a, o, s, c) => {
+  let l = n.children ?? [], u = o * (l.length ? 1 : 0.2), d = -COS_A * u, f = SIN_A * u * a, p = r + d, m = i + f;
+  if (drawLine(e, r, i, p, m, "ishikawa-branch", c), c && drawArrowMarker(e, r, i, r - p, i - m, c), drawCauseLabel(e, n.text, p, m, a, s, c), !l.length) return;
+  let { entries: h, yOrder: g } = flattenTree(l, a), _ = h.length, v = Array(_);
+  for (let [e2, n2] of g.entries()) v[n2] = i + f * ((e2 + 1) / (_ + 1));
+  let y = /* @__PURE__ */ new Map();
+  y.set(-1, {
+    x0: r,
+    y0: i,
+    x1: p,
+    y1: m,
+    childCount: l.length,
+    childrenDrawn: 0
+  });
+  let C = -COS_A, E = SIN_A * a, D = a < 0 ? "ishikawa-label up" : "ishikawa-label down";
+  for (let [n2, r2] of h.entries()) {
+    let i2 = v[n2], a2 = y.get(r2.parentIndex), o2 = e.append("g").attr("class", "ishikawa-sub-group"), l2 = 0, u2 = 0, d2 = 0;
+    if (r2.depth % 2 == 0) {
+      let e2 = a2.y1 - a2.y0;
+      l2 = lerp(a2.x0, a2.x1, e2 ? (i2 - a2.y0) / e2 : 0.5), u2 = i2, d2 = l2 - (r2.childCount > 0 ? BONE_BASE + r2.childCount * BONE_PER_CHILD : BONE_STUB), drawLine(o2, l2, i2, d2, i2, "ishikawa-sub-branch", c), c && drawArrowMarker(o2, l2, i2, 1, 0, c), drawMultilineText(o2, r2.text, d2, i2, "ishikawa-label align", "end", s);
+    } else {
+      let e2 = a2.childrenDrawn++;
+      l2 = lerp(a2.x0, a2.x1, (a2.childCount - e2) / (a2.childCount + 1)), u2 = a2.y0, d2 = l2 + C * ((i2 - u2) / E), drawLine(o2, l2, u2, d2, i2, "ishikawa-sub-branch", c), c && drawArrowMarker(o2, l2, u2, l2 - d2, u2 - i2, c), drawMultilineText(o2, r2.text, d2, i2, D, "end", s);
+    }
+    r2.childCount > 0 && y.set(n2, {
+      x0: l2,
+      y0: u2,
+      x1: d2,
+      y1: i2,
+      childCount: r2.childCount,
+      childrenDrawn: 0
+    });
+  }
+}, "drawBranch"), splitLines = /* @__PURE__ */ __name((e) => e.split(/<br\s*\/?>|\n/), "splitLines"), wrapText = /* @__PURE__ */ __name((e, n) => {
+  if (e.length <= n) return e;
+  let r = [];
+  for (let i of e.split(/\s+/)) {
+    let e2 = r.length - 1;
+    e2 >= 0 && r[e2].length + 1 + i.length <= n ? r[e2] += " " + i : r.push(i);
+  }
+  return r.join("\n");
+}, "wrapText"), drawMultilineText = /* @__PURE__ */ __name((e, n, r, i, a, o, s) => {
+  let c = splitLines(n), l = s * 1.05, u = e.append("text").attr("class", a).attr("text-anchor", o).attr("x", r).attr("y", i - (c.length - 1) * l / 2);
+  for (let [e2, n2] of c.entries()) u.append("tspan").attr("x", r).attr("dy", e2 === 0 ? 0 : l).text(n2);
+  return u;
+}, "drawMultilineText"), lerp = /* @__PURE__ */ __name((e, n, r) => e + (n - e) * r, "lerp"), drawLine = /* @__PURE__ */ __name((e, n, r, i, a, o, s) => {
+  if (s) {
+    let c = s.roughSvg.line(n, r, i, a, {
+      roughness: 1.5,
+      seed: s.seed,
+      stroke: s.lineColor,
+      strokeWidth: 2
+    });
+    e.append(() => c).attr("class", o);
+    return;
+  }
+  return e.append("line").attr("class", o).attr("x1", n).attr("y1", r).attr("x2", i).attr("y2", a);
+}, "drawLine"), diagram = {
+  parser: ishikawa_default,
+  get db() {
+    return new IshikawaDB();
+  },
+  renderer: { draw },
+  styles: /* @__PURE__ */ __name((e) => `
+.ishikawa .ishikawa-spine,
+.ishikawa .ishikawa-branch,
+.ishikawa .ishikawa-sub-branch {
+  stroke: ${e.lineColor};
+  stroke-width: 2;
+  fill: none;
+}
+
+.ishikawa .ishikawa-sub-branch {
+  stroke-width: 1;
+}
+
+.ishikawa .ishikawa-arrow {
+  fill: ${e.lineColor};
+}
+
+.ishikawa .ishikawa-head {
+  fill: ${e.mainBkg};
+  stroke: ${e.lineColor};
+  stroke-width: 2;
+}
+
+.ishikawa .ishikawa-label-box {
+  fill: ${e.mainBkg};
+  stroke: ${e.lineColor};
+  stroke-width: 2;
+}
+
+.ishikawa text {
+  font-family: ${e.fontFamily};
+  font-size: ${e.fontSize};
+  fill: ${e.textColor};
+}
+
+.ishikawa .ishikawa-head-label {
+  font-weight: 600;
+  text-anchor: middle;
+  dominant-baseline: middle;
+  font-size: 14px;
+}
+
+.ishikawa .ishikawa-label {
+  text-anchor: end;
+}
+
+.ishikawa .ishikawa-label.cause {
+  text-anchor: middle;
+  dominant-baseline: middle;
+}
+
+.ishikawa .ishikawa-label.align {
+  text-anchor: end;
+  dominant-baseline: middle;
+}
+
+.ishikawa .ishikawa-label.up {
+  dominant-baseline: baseline;
+}
+
+.ishikawa .ishikawa-label.down {
+  dominant-baseline: hanging;
+}
+`, "getStyles")
+};
+export {
+  diagram
+};