lowcoder-comps 0.0.21 → 0.0.23

package/fc7a026c.js

@@ -0,0 +1,502 @@
+import { U as H, V as at, B as lt, D as ct, s as ot, g as ht, b as ut, a as yt, E as ft, d as pt, c as et, l as it, W as gt, T as dt, i as mt, X as _t } from "./6ddb6f97.js";
+import { a as tt } from "./d0baa7b9.js";
+import { o as vt } from "./92e85b65.js";
+import { a as xt } from "./2ff2c7a6.js";
+import { c as z } from "./256b619e.js";
+import "./f9637058.js";
+function kt(e, u) {
+  return u < e ? -1 : u > e ? 1 : u >= e ? 0 : NaN;
+}
+function bt(e) {
+  return e;
+}
+function St() {
+  var e = bt, u = kt, $ = null, f = z(0), b = z(H), w = z(0);
+  function o(r) {
+    var l, g = (r = xt(r)).length, S, T, V = 0, d = new Array(g), x = new Array(g), m = +f.apply(this, arguments), h = Math.min(H, Math.max(-H, b.apply(this, arguments) - m)), A, I = Math.min(Math.abs(h) / g, w.apply(this, arguments)), p = I * (h < 0 ? -1 : 1), t;
+    for (l = 0; l < g; ++l)
+      (t = x[d[l] = l] = +e(r[l], l, r)) > 0 && (V += t);
+    for (u != null ? d.sort(function(i, n) {
+      return u(x[i], x[n]);
+    }) : $ != null && d.sort(function(i, n) {
+      return $(r[i], r[n]);
+    }), l = 0, T = V ? (h - g * p) / V : 0; l < g; ++l, m = A)
+      S = d[l], t = x[S], A = m + (t > 0 ? t * T : 0) + p, x[S] = {
+        data: r[S],
+        index: l,
+        value: t,
+        startAngle: m,
+        endAngle: A,
+        padAngle: I
+      };
+    return x;
+  }
+  return o.value = function(r) {
+    return arguments.length ? (e = typeof r == "function" ? r : z(+r), o) : e;
+  }, o.sortValues = function(r) {
+    return arguments.length ? (u = r, $ = null, o) : u;
+  }, o.sort = function(r) {
+    return arguments.length ? ($ = r, u = null, o) : $;
+  }, o.startAngle = function(r) {
+    return arguments.length ? (f = typeof r == "function" ? r : z(+r), o) : f;
+  }, o.endAngle = function(r) {
+    return arguments.length ? (b = typeof r == "function" ? r : z(+r), o) : b;
+  }, o.padAngle = function(r) {
+    return arguments.length ? (w = typeof r == "function" ? r : z(+r), o) : w;
+  }, o;
+}
+var J = function() {
+  var e = function(p, t, i, n) {
+    for (i = i || {}, n = p.length; n--; i[p[n]] = t)
+      ;
+    return i;
+  }, u = [1, 3], $ = [1, 4], f = [1, 5], b = [1, 6], w = [1, 10, 12, 14, 16, 18, 19, 20, 21, 22], o = [2, 4], r = [1, 5, 10, 12, 14, 16, 18, 19, 20, 21, 22], l = [20, 21, 22], g = [2, 7], S = [1, 12], T = [1, 13], V = [1, 14], d = [1, 15], x = [1, 16], m = [1, 17], h = {
+    trace: function() {
+    },
+    yy: {},
+    symbols_: { error: 2, start: 3, eol: 4, PIE: 5, document: 6, showData: 7, line: 8, statement: 9, txt: 10, value: 11, title: 12, title_value: 13, acc_title: 14, acc_title_value: 15, acc_descr: 16, acc_descr_value: 17, acc_descr_multiline_value: 18, section: 19, NEWLINE: 20, ";": 21, EOF: 22, $accept: 0, $end: 1 },
+    terminals_: { 2: "error", 5: "PIE", 7: "showData", 10: "txt", 11: "value", 12: "title", 13: "title_value", 14: "acc_title", 15: "acc_title_value", 16: "acc_descr", 17: "acc_descr_value", 18: "acc_descr_multiline_value", 19: "section", 20: "NEWLINE", 21: ";", 22: "EOF" },
+    productions_: [0, [3, 2], [3, 2], [3, 3], [6, 0], [6, 2], [8, 2], [9, 0], [9, 2], [9, 2], [9, 2], [9, 2], [9, 1], [9, 1], [4, 1], [4, 1], [4, 1]],
+    performAction: function(t, i, n, a, c, s, P) {
+      var _ = s.length - 1;
+      switch (c) {
+        case 3:
+          a.setShowData(!0);
+          break;
+        case 6:
+          this.$ = s[_ - 1];
+          break;
+        case 8:
+          a.addSection(s[_ - 1], a.cleanupValue(s[_]));
+          break;
+        case 9:
+          this.$ = s[_].trim(), a.setDiagramTitle(this.$);
+          break;
+        case 10:
+          this.$ = s[_].trim(), a.setAccTitle(this.$);
+          break;
+        case 11:
+        case 12:
+          this.$ = s[_].trim(), a.setAccDescription(this.$);
+          break;
+        case 13:
+          a.addSection(s[_].substr(8)), this.$ = s[_].substr(8);
+          break;
+      }
+    },
+    table: [{ 3: 1, 4: 2, 5: u, 20: $, 21: f, 22: b }, { 1: [3] }, { 3: 7, 4: 2, 5: u, 20: $, 21: f, 22: b }, e(w, o, { 6: 8, 7: [1, 9] }), e(r, [2, 14]), e(r, [2, 15]), e(r, [2, 16]), { 1: [2, 1] }, e(l, g, { 8: 10, 9: 11, 1: [2, 2], 10: S, 12: T, 14: V, 16: d, 18: x, 19: m }), e(w, o, { 6: 18 }), e(w, [2, 5]), { 4: 19, 20: $, 21: f, 22: b }, { 11: [1, 20] }, { 13: [1, 21] }, { 15: [1, 22] }, { 17: [1, 23] }, e(l, [2, 12]), e(l, [2, 13]), e(l, g, { 8: 10, 9: 11, 1: [2, 3], 10: S, 12: T, 14: V, 16: d, 18: x, 19: m }), e(w, [2, 6]), e(l, [2, 8]), e(l, [2, 9]), e(l, [2, 10]), e(l, [2, 11])],
+    defaultActions: { 7: [2, 1] },
+    parseError: function(t, i) {
+      if (i.recoverable)
+        this.trace(t);
+      else {
+        var n = new Error(t);
+        throw n.hash = i, n;
+      }
+    },
+    parse: function(t) {
+      var i = this, n = [0], a = [], c = [null], s = [], P = this.table, _ = "", N = 0, k = 0, R = 2, L = 1, B = s.slice.call(arguments, 1), y = Object.create(this.lexer), D = { yy: {} };
+      for (var Y in this.yy)
+        Object.prototype.hasOwnProperty.call(this.yy, Y) && (D.yy[Y] = this.yy[Y]);
+      y.setInput(t, D.yy), D.yy.lexer = y, D.yy.parser = this, typeof y.yylloc == "undefined" && (y.yylloc = {});
+      var X = y.yylloc;
+      s.push(X);
+      var st = y.options && y.options.ranges;
+      typeof D.yy.parseError == "function" ? this.parseError = D.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function rt() {
+        var O;
+        return O = a.pop() || y.lex() || L, typeof O != "number" && (O instanceof Array && (a = O, O = a.pop()), O = i.symbols_[O] || O), O;
+      }
+      for (var v, F, E, Z, j = {}, M, C, Q, G; ; ) {
+        if (F = n[n.length - 1], this.defaultActions[F] ? E = this.defaultActions[F] : ((v === null || typeof v == "undefined") && (v = rt()), E = P[F] && P[F][v]), typeof E == "undefined" || !E.length || !E[0]) {
+          var q = "";
+          G = [];
+          for (M in P[F])
+            this.terminals_[M] && M > R && G.push("'" + this.terminals_[M] + "'");
+          y.showPosition ? q = "Parse error on line " + (N + 1) + `:
+` + y.showPosition() + `
+Expecting ` + G.join(", ") + ", got '" + (this.terminals_[v] || v) + "'" : q = "Parse error on line " + (N + 1) + ": Unexpected " + (v == L ? "end of input" : "'" + (this.terminals_[v] || v) + "'"), this.parseError(q, {
+            text: y.match,
+            token: this.terminals_[v] || v,
+            line: y.yylineno,
+            loc: X,
+            expected: G
+          });
+        }
+        if (E[0] instanceof Array && E.length > 1)
+          throw new Error("Parse Error: multiple actions possible at state: " + F + ", token: " + v);
+        switch (E[0]) {
+          case 1:
+            n.push(v), c.push(y.yytext), s.push(y.yylloc), n.push(E[1]), v = null, k = y.yyleng, _ = y.yytext, N = y.yylineno, X = y.yylloc;
+            break;
+          case 2:
+            if (C = this.productions_[E[1]][1], j.$ = c[c.length - C], j._$ = {
+              first_line: s[s.length - (C || 1)].first_line,
+              last_line: s[s.length - 1].last_line,
+              first_column: s[s.length - (C || 1)].first_column,
+              last_column: s[s.length - 1].last_column
+            }, st && (j._$.range = [
+              s[s.length - (C || 1)].range[0],
+              s[s.length - 1].range[1]
+            ]), Z = this.performAction.apply(j, [
+              _,
+              k,
+              N,
+              D.yy,
+              E[1],
+              c,
+              s
+            ].concat(B)), typeof Z != "undefined")
+              return Z;
+            C && (n = n.slice(0, -1 * C * 2), c = c.slice(0, -1 * C), s = s.slice(0, -1 * C)), n.push(this.productions_[E[1]][0]), c.push(j.$), s.push(j._$), Q = P[n[n.length - 2]][n[n.length - 1]], n.push(Q);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }
+  }, A = function() {
+    var p = {
+      EOF: 1,
+      parseError: function(i, n) {
+        if (this.yy.parser)
+          this.yy.parser.parseError(i, n);
+        else
+          throw new Error(i);
+      },
+      // resets the lexer, sets new input
+      setInput: function(t, i) {
+        return this.yy = i || this.yy || {}, this._input = t, 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;
+      },
+      // consumes and returns one char from the input
+      input: function() {
+        var t = this._input[0];
+        this.yytext += t, this.yyleng++, this.offset++, this.match += t, this.matched += t;
+        var i = t.match(/(?:\r\n?|\n).*/g);
+        return i ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), t;
+      },
+      // unshifts one char (or a string) into the input
+      unput: function(t) {
+        var i = t.length, n = t.split(/(?:\r\n?|\n)/g);
+        this._input = t + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - i), this.offset -= i;
+        var a = 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), n.length - 1 && (this.yylineno -= n.length - 1);
+        var c = 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: n ? (n.length === a.length ? this.yylloc.first_column : 0) + a[a.length - n.length].length - n[0].length : this.yylloc.first_column - i
+        }, this.options.ranges && (this.yylloc.range = [c[0], c[0] + this.yyleng - i]), this.yyleng = this.yytext.length, this;
+      },
+      // When called from action, caches matched text and appends it on next action
+      more: function() {
+        return this._more = !0, this;
+      },
+      // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+      reject: 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;
+      },
+      // retain first n characters of the match
+      less: function(t) {
+        this.unput(this.match.slice(t));
+      },
+      // displays already matched input, i.e. for error messages
+      pastInput: function() {
+        var t = this.matched.substr(0, this.matched.length - this.match.length);
+        return (t.length > 20 ? "..." : "") + t.substr(-20).replace(/\n/g, "");
+      },
+      // displays upcoming input, i.e. for error messages
+      upcomingInput: function() {
+        var t = this.match;
+        return t.length < 20 && (t += this._input.substr(0, 20 - t.length)), (t.substr(0, 20) + (t.length > 20 ? "..." : "")).replace(/\n/g, "");
+      },
+      // displays the character position where the lexing error occurred, i.e. for error messages
+      showPosition: function() {
+        var t = this.pastInput(), i = new Array(t.length + 1).join("-");
+        return t + this.upcomingInput() + `
+` + i + "^";
+      },
+      // test the lexed token: return FALSE when not a match, otherwise return token
+      test_match: function(t, i) {
+        var n, a, c;
+        if (this.options.backtrack_lexer && (c = {
+          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 && (c.yylloc.range = this.yylloc.range.slice(0))), a = t[0].match(/(?:\r\n?|\n).*/g), a && (this.yylineno += a.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: a ? a[a.length - 1].length - a[a.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + t[0].length
+        }, this.yytext += t[0], this.match += t[0], this.matches = t, 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(t[0].length), this.matched += t[0], n = this.performAction.call(this, this.yy, this, i, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), n)
+          return n;
+        if (this._backtrack) {
+          for (var s in c)
+            this[s] = c[s];
+          return !1;
+        }
+        return !1;
+      },
+      // return next match in input
+      next: function() {
+        if (this.done)
+          return this.EOF;
+        this._input || (this.done = !0);
+        var t, i, n, a;
+        this._more || (this.yytext = "", this.match = "");
+        for (var c = this._currentRules(), s = 0; s < c.length; s++)
+          if (n = this._input.match(this.rules[c[s]]), n && (!i || n[0].length > i[0].length)) {
+            if (i = n, a = s, this.options.backtrack_lexer) {
+              if (t = this.test_match(n, c[s]), t !== !1)
+                return t;
+              if (this._backtrack) {
+                i = !1;
+                continue;
+              } else
+                return !1;
+            } else if (!this.options.flex)
+              break;
+          }
+        return i ? (t = this.test_match(i, c[a]), t !== !1 ? t : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      },
+      // return next match that has a token
+      lex: function() {
+        var i = this.next();
+        return i || this.lex();
+      },
+      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+      begin: function(i) {
+        this.conditionStack.push(i);
+      },
+      // pop the previously active lexer condition state off the condition stack
+      popState: function() {
+        var i = this.conditionStack.length - 1;
+        return i > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      },
+      // produce the lexer rule set which is active for the currently active lexer condition state
+      _currentRules: function() {
+        return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+      },
+      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+      topState: function(i) {
+        return i = this.conditionStack.length - 1 - Math.abs(i || 0), i >= 0 ? this.conditionStack[i] : "INITIAL";
+      },
+      // alias for begin(condition)
+      pushState: function(i) {
+        this.begin(i);
+      },
+      // return the number of states currently on the stack
+      stateStackSize: function() {
+        return this.conditionStack.length;
+      },
+      options: { "case-insensitive": !0 },
+      performAction: function(i, n, a, c) {
+        switch (a) {
+          case 0:
+            break;
+          case 1:
+            break;
+          case 2:
+            return 20;
+          case 3:
+            break;
+          case 4:
+            break;
+          case 5:
+            return this.begin("title"), 12;
+          case 6:
+            return this.popState(), "title_value";
+          case 7:
+            return this.begin("acc_title"), 14;
+          case 8:
+            return this.popState(), "acc_title_value";
+          case 9:
+            return this.begin("acc_descr"), 16;
+          case 10:
+            return this.popState(), "acc_descr_value";
+          case 11:
+            this.begin("acc_descr_multiline");
+            break;
+          case 12:
+            this.popState();
+            break;
+          case 13:
+            return "acc_descr_multiline_value";
+          case 14:
+            this.begin("string");
+            break;
+          case 15:
+            this.popState();
+            break;
+          case 16:
+            return "txt";
+          case 17:
+            return 5;
+          case 18:
+            return 7;
+          case 19:
+            return "value";
+          case 20:
+            return 22;
+        }
+      },
+      rules: [/^(?:%%(?!\{)[^\n]*)/i, /^(?:[^\}]%%[^\n]*)/i, /^(?:[\n\r]+)/i, /^(?:%%[^\n]*)/i, /^(?:[\s]+)/i, /^(?:title\b)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accTitle\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*\{\s*)/i, /^(?:[\}])/i, /^(?:[^\}]*)/i, /^(?:["])/i, /^(?:["])/i, /^(?:[^"]*)/i, /^(?:pie\b)/i, /^(?:showData\b)/i, /^(?::[\s]*[\d]+(?:\.[\d]+)?)/i, /^(?:$)/i],
+      conditions: { acc_descr_multiline: { rules: [12, 13], inclusive: !1 }, acc_descr: { rules: [10], inclusive: !1 }, acc_title: { rules: [8], inclusive: !1 }, title: { rules: [6], inclusive: !1 }, string: { rules: [15, 16], inclusive: !1 }, INITIAL: { rules: [0, 1, 2, 3, 4, 5, 7, 9, 11, 14, 17, 18, 19, 20], inclusive: !0 } }
+    };
+    return p;
+  }();
+  h.lexer = A;
+  function I() {
+    this.yy = {};
+  }
+  return I.prototype = h, h.Parser = I, new I();
+}();
+J.parser = J;
+const Et = J, nt = at.pie, W = {
+  sections: {},
+  showData: !1,
+  config: nt
+};
+let U = W.sections, K = W.showData;
+const $t = structuredClone(nt), wt = () => structuredClone($t), At = () => {
+  U = structuredClone(W.sections), K = W.showData, ft();
+}, Tt = (e, u) => {
+  e = pt(e, et()), U[e] === void 0 && (U[e] = u, it.debug(`added new section: ${e}, with value: ${u}`));
+}, It = () => U, Dt = (e) => (e.substring(0, 1) === ":" && (e = e.substring(1).trim()), Number(e.trim())), Ct = (e) => {
+  K = e;
+}, Ot = () => K, Vt = {
+  getConfig: wt,
+  clear: At,
+  setDiagramTitle: lt,
+  getDiagramTitle: ct,
+  setAccTitle: ot,
+  getAccTitle: ht,
+  setAccDescription: ut,
+  getAccDescription: yt,
+  addSection: Tt,
+  getSections: It,
+  cleanupValue: Dt,
+  setShowData: Ct,
+  getShowData: Ot
+}, Pt = (e) => `
+  .pieCircle{
+    stroke: ${e.pieStrokeColor};
+    stroke-width : ${e.pieStrokeWidth};
+    opacity : ${e.pieOpacity};
+  }
+  .pieOuterCircle{
+    stroke: ${e.pieOuterStrokeColor};
+    stroke-width: ${e.pieOuterStrokeWidth};
+    fill: none;
+  }
+  .pieTitleText {
+    text-anchor: middle;
+    font-size: ${e.pieTitleTextSize};
+    fill: ${e.pieTitleTextColor};
+    font-family: ${e.fontFamily};
+  }
+  .slice {
+    font-family: ${e.fontFamily};
+    fill: ${e.pieSectionTextColor};
+    font-size:${e.pieSectionTextSize};
+    // fill: white;
+  }
+  .legend text {
+    fill: ${e.pieLegendTextColor};
+    font-family: ${e.fontFamily};
+    font-size: ${e.pieLegendTextSize};
+  }
+`, Nt = Pt, Lt = (e) => {
+  const u = Object.entries(e).map((f) => ({
+    label: f[0],
+    value: f[1]
+  })).sort((f, b) => b.value - f.value);
+  return St().value(
+    (f) => f.value
+  )(u);
+}, Ft = (e, u, $, f) => {
+  var N;
+  var b, w;
+  it.debug(`rendering pie chart
+` + e);
+  const o = f.db, r = et(), l = gt(o.getConfig(), r.pie), g = 450, S = (N = (w = (b = document.getElementById(u)) == null ? void 0 : b.parentElement) == null ? void 0 : w.offsetWidth) != null ? N : l.useWidth, T = dt(u);
+  T.attr("viewBox", `0 0 ${S} ${g}`), mt(T, g, S, l.useMaxWidth);
+  const V = 40, d = 18, x = 4, m = T.append("g");
+  m.attr("transform", "translate(" + S / 2 + "," + g / 2 + ")");
+  const { themeVariables: h } = r;
+  let [A] = _t(h.pieOuterStrokeWidth);
+  A != null || (A = 2);
+  const I = l.textPosition, p = Math.min(S, g) / 2 - V, t = tt().innerRadius(0).outerRadius(p), i = tt().innerRadius(p * I).outerRadius(p * I);
+  m.append("circle").attr("cx", 0).attr("cy", 0).attr("r", p + A / 2).attr("class", "pieOuterCircle");
+  const n = o.getSections(), a = Lt(n), c = [
+    h.pie1,
+    h.pie2,
+    h.pie3,
+    h.pie4,
+    h.pie5,
+    h.pie6,
+    h.pie7,
+    h.pie8,
+    h.pie9,
+    h.pie10,
+    h.pie11,
+    h.pie12
+  ], s = vt(c);
+  m.selectAll("mySlices").data(a).enter().append("path").attr("d", t).attr("fill", (k) => s(k.data.label)).attr("class", "pieCircle");
+  let P = 0;
+  Object.keys(n).forEach((k) => {
+    P += n[k];
+  }), m.selectAll("mySlices").data(a).enter().append("text").text((k) => (k.data.value / P * 100).toFixed(0) + "%").attr("transform", (k) => "translate(" + i.centroid(k) + ")").style("text-anchor", "middle").attr("class", "slice"), m.append("text").text(o.getDiagramTitle()).attr("x", 0).attr("y", -(g - 50) / 2).attr("class", "pieTitleText");
+  const _ = m.selectAll(".legend").data(s.domain()).enter().append("g").attr("class", "legend").attr("transform", (k, R) => {
+    const L = d + x, B = L * s.domain().length / 2, y = 12 * d, D = R * L - B;
+    return "translate(" + y + "," + D + ")";
+  });
+  _.append("rect").attr("width", d).attr("height", d).style("fill", s).style("stroke", s), _.data(a).append("text").attr("x", d + x).attr("y", d - x).text((k) => {
+    const { label: R, value: L } = k.data;
+    return o.getShowData() ? `${R} [${L}]` : R;
+  });
+}, zt = { draw: Ft }, Bt = {
+  parser: Et,
+  db: Vt,
+  renderer: zt,
+  styles: Nt
+};
+export {
+  Bt as diagram
+};