lowcoder-comps 0.0.14 → 0.0.16

package/8fa913d2.js

@@ -0,0 +1,607 @@
+import { Q as nt, c as Q, s as gt, g as dt, z as mt, A as _t, a as vt, b as bt, m as kt, j as xt, l as U, B as St, h as rt, i as wt, S as At } from "./c7fbe06d.js";
+import { i as Et } from "./f9637058.js";
+import { a as Dt } from "./2ff2c7a6.js";
+import { c as z } from "./256b619e.js";
+import { a as ct } from "./b554013e.js";
+class ot extends Map {
+  constructor(r, o = It) {
+    if (super(), Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: o } }), r != null)
+      for (const [u, p] of r)
+        this.set(u, p);
+  }
+  get(r) {
+    return super.get(ht(this, r));
+  }
+  has(r) {
+    return super.has(ht(this, r));
+  }
+  set(r, o) {
+    return super.set($t(this, r), o);
+  }
+  delete(r) {
+    return super.delete(Tt(this, r));
+  }
+}
+function ht({ _intern: t, _key: r }, o) {
+  const u = r(o);
+  return t.has(u) ? t.get(u) : o;
+}
+function $t({ _intern: t, _key: r }, o) {
+  const u = r(o);
+  return t.has(u) ? t.get(u) : (t.set(u, o), o);
+}
+function Tt({ _intern: t, _key: r }, o) {
+  const u = r(o);
+  return t.has(u) && (o = t.get(u), t.delete(u)), o;
+}
+function It(t) {
+  return t !== null && typeof t == "object" ? t.valueOf() : t;
+}
+const ut = Symbol("implicit");
+function ft() {
+  var t = new ot(), r = [], o = [], u = ut;
+  function p(g) {
+    let f = t.get(g);
+    if (f === void 0) {
+      if (u !== ut)
+        return u;
+      t.set(g, f = r.push(g) - 1);
+    }
+    return o[f % o.length];
+  }
+  return p.domain = function(g) {
+    if (!arguments.length)
+      return r.slice();
+    r = [], t = new ot();
+    for (const f of g)
+      t.has(f) || t.set(f, r.push(f) - 1);
+    return p;
+  }, p.range = function(g) {
+    return arguments.length ? (o = Array.from(g), p) : o.slice();
+  }, p.unknown = function(g) {
+    return arguments.length ? (u = g, p) : u;
+  }, p.copy = function() {
+    return ft(r, o).unknown(u);
+  }, Et.apply(p, arguments), p;
+}
+function Vt(t, r) {
+  return r < t ? -1 : r > t ? 1 : r >= t ? 0 : NaN;
+}
+function Pt(t) {
+  return t;
+}
+function Ot() {
+  var t = Pt, r = Vt, o = null, u = z(0), p = z(nt), g = z(0);
+  function f(h) {
+    var d, y = (h = Dt(h)).length, S, N, C = 0, b = new Array(y), w = new Array(y), I = +u.apply(this, arguments), D = Math.min(nt, Math.max(-nt, p.apply(this, arguments) - I)), F, M = Math.min(Math.abs(D) / y, g.apply(this, arguments)), V = M * (D < 0 ? -1 : 1), A;
+    for (d = 0; d < y; ++d)
+      (A = w[b[d] = d] = +t(h[d], d, h)) > 0 && (C += A);
+    for (r != null ? b.sort(function(k, _) {
+      return r(w[k], w[_]);
+    }) : o != null && b.sort(function(k, _) {
+      return o(h[k], h[_]);
+    }), d = 0, N = C ? (D - y * V) / C : 0; d < y; ++d, I = F)
+      S = b[d], A = w[S], F = I + (A > 0 ? A * N : 0) + V, w[S] = {
+        data: h[S],
+        index: d,
+        value: A,
+        startAngle: I,
+        endAngle: F,
+        padAngle: M
+      };
+    return w;
+  }
+  return f.value = function(h) {
+    return arguments.length ? (t = typeof h == "function" ? h : z(+h), f) : t;
+  }, f.sortValues = function(h) {
+    return arguments.length ? (r = h, o = null, f) : r;
+  }, f.sort = function(h) {
+    return arguments.length ? (o = h, r = null, f) : o;
+  }, f.startAngle = function(h) {
+    return arguments.length ? (u = typeof h == "function" ? h : z(+h), f) : u;
+  }, f.endAngle = function(h) {
+    return arguments.length ? (p = typeof h == "function" ? h : z(+h), f) : p;
+  }, f.padAngle = function(h) {
+    return arguments.length ? (g = typeof h == "function" ? h : z(+h), f) : g;
+  }, f;
+}
+var st = function() {
+  var t = function(_, e, i, s) {
+    for (i = i || {}, s = _.length; s--; i[_[s]] = e)
+      ;
+    return i;
+  }, r = [1, 4], o = [1, 5], u = [1, 6], p = [1, 7], g = [1, 9], f = [1, 11, 13, 15, 17, 19, 20, 26, 27, 28, 29], h = [2, 5], d = [1, 6, 11, 13, 15, 17, 19, 20, 26, 27, 28, 29], y = [26, 27, 28], S = [2, 8], N = [1, 18], C = [1, 19], b = [1, 20], w = [1, 21], I = [1, 22], D = [1, 23], F = [1, 28], M = [6, 26, 27, 28, 29], V = {
+    trace: function() {
+    },
+    yy: {},
+    symbols_: { error: 2, start: 3, eol: 4, directive: 5, PIE: 6, document: 7, showData: 8, line: 9, statement: 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, openDirective: 21, typeDirective: 22, closeDirective: 23, ":": 24, argDirective: 25, NEWLINE: 26, ";": 27, EOF: 28, open_directive: 29, type_directive: 30, arg_directive: 31, close_directive: 32, $accept: 0, $end: 1 },
+    terminals_: { 2: "error", 6: "PIE", 8: "showData", 11: "txt", 12: "value", 13: "title", 14: "title_value", 15: "acc_title", 16: "acc_title_value", 17: "acc_descr", 18: "acc_descr_value", 19: "acc_descr_multiline_value", 20: "section", 24: ":", 26: "NEWLINE", 27: ";", 28: "EOF", 29: "open_directive", 30: "type_directive", 31: "arg_directive", 32: "close_directive" },
+    productions_: [0, [3, 2], [3, 2], [3, 2], [3, 3], [7, 0], [7, 2], [9, 2], [10, 0], [10, 2], [10, 2], [10, 2], [10, 2], [10, 1], [10, 1], [10, 1], [5, 3], [5, 5], [4, 1], [4, 1], [4, 1], [21, 1], [22, 1], [25, 1], [23, 1]],
+    performAction: function(e, i, s, l, a, n, E) {
+      var c = n.length - 1;
+      switch (a) {
+        case 4:
+          l.setShowData(!0);
+          break;
+        case 7:
+          this.$ = n[c - 1];
+          break;
+        case 9:
+          l.addSection(n[c - 1], l.cleanupValue(n[c]));
+          break;
+        case 10:
+          this.$ = n[c].trim(), l.setDiagramTitle(this.$);
+          break;
+        case 11:
+          this.$ = n[c].trim(), l.setAccTitle(this.$);
+          break;
+        case 12:
+        case 13:
+          this.$ = n[c].trim(), l.setAccDescription(this.$);
+          break;
+        case 14:
+          l.addSection(n[c].substr(8)), this.$ = n[c].substr(8);
+          break;
+        case 21:
+          l.parseDirective("%%{", "open_directive");
+          break;
+        case 22:
+          l.parseDirective(n[c], "type_directive");
+          break;
+        case 23:
+          n[c] = n[c].trim().replace(/'/g, '"'), l.parseDirective(n[c], "arg_directive");
+          break;
+        case 24:
+          l.parseDirective("}%%", "close_directive", "pie");
+          break;
+      }
+    },
+    table: [{ 3: 1, 4: 2, 5: 3, 6: r, 21: 8, 26: o, 27: u, 28: p, 29: g }, { 1: [3] }, { 3: 10, 4: 2, 5: 3, 6: r, 21: 8, 26: o, 27: u, 28: p, 29: g }, { 3: 11, 4: 2, 5: 3, 6: r, 21: 8, 26: o, 27: u, 28: p, 29: g }, t(f, h, { 7: 12, 8: [1, 13] }), t(d, [2, 18]), t(d, [2, 19]), t(d, [2, 20]), { 22: 14, 30: [1, 15] }, { 30: [2, 21] }, { 1: [2, 1] }, { 1: [2, 2] }, t(y, S, { 21: 8, 9: 16, 10: 17, 5: 24, 1: [2, 3], 11: N, 13: C, 15: b, 17: w, 19: I, 20: D, 29: g }), t(f, h, { 7: 25 }), { 23: 26, 24: [1, 27], 32: F }, t([24, 32], [2, 22]), t(f, [2, 6]), { 4: 29, 26: o, 27: u, 28: p }, { 12: [1, 30] }, { 14: [1, 31] }, { 16: [1, 32] }, { 18: [1, 33] }, t(y, [2, 13]), t(y, [2, 14]), t(y, [2, 15]), t(y, S, { 21: 8, 9: 16, 10: 17, 5: 24, 1: [2, 4], 11: N, 13: C, 15: b, 17: w, 19: I, 20: D, 29: g }), t(M, [2, 16]), { 25: 34, 31: [1, 35] }, t(M, [2, 24]), t(f, [2, 7]), t(y, [2, 9]), t(y, [2, 10]), t(y, [2, 11]), t(y, [2, 12]), { 23: 36, 32: F }, { 32: [2, 23] }, t(M, [2, 17])],
+    defaultActions: { 9: [2, 21], 10: [2, 1], 11: [2, 2], 35: [2, 23] },
+    parseError: function(e, i) {
+      if (i.recoverable)
+        this.trace(e);
+      else {
+        var s = new Error(e);
+        throw s.hash = i, s;
+      }
+    },
+    parse: function(e) {
+      var i = this, s = [0], l = [], a = [null], n = [], E = this.table, c = "", $ = 0, B = 0, K = 2, q = 1, X = n.slice.call(arguments, 1), m = Object.create(this.lexer), W = { yy: {} };
+      for (var Z in this.yy)
+        Object.prototype.hasOwnProperty.call(this.yy, Z) && (W.yy[Z] = this.yy[Z]);
+      m.setInput(e, W.yy), W.yy.lexer = m, W.yy.parser = this, typeof m.yylloc == "undefined" && (m.yylloc = {});
+      var tt = m.yylloc;
+      n.push(tt);
+      var pt = m.options && m.options.ranges;
+      typeof W.yy.parseError == "function" ? this.parseError = W.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function yt() {
+        var O;
+        return O = l.pop() || m.lex() || q, typeof O != "number" && (O instanceof Array && (l = O, O = l.pop()), O = i.symbols_[O] || O), O;
+      }
+      for (var v, j, x, et, R = {}, G, P, lt, H; ; ) {
+        if (j = s[s.length - 1], this.defaultActions[j] ? x = this.defaultActions[j] : ((v === null || typeof v == "undefined") && (v = yt()), x = E[j] && E[j][v]), typeof x == "undefined" || !x.length || !x[0]) {
+          var it = "";
+          H = [];
+          for (G in E[j])
+            this.terminals_[G] && G > K && H.push("'" + this.terminals_[G] + "'");
+          m.showPosition ? it = "Parse error on line " + ($ + 1) + `:
+` + m.showPosition() + `
+Expecting ` + H.join(", ") + ", got '" + (this.terminals_[v] || v) + "'" : it = "Parse error on line " + ($ + 1) + ": Unexpected " + (v == q ? "end of input" : "'" + (this.terminals_[v] || v) + "'"), this.parseError(it, {
+            text: m.match,
+            token: this.terminals_[v] || v,
+            line: m.yylineno,
+            loc: tt,
+            expected: H
+          });
+        }
+        if (x[0] instanceof Array && x.length > 1)
+          throw new Error("Parse Error: multiple actions possible at state: " + j + ", token: " + v);
+        switch (x[0]) {
+          case 1:
+            s.push(v), a.push(m.yytext), n.push(m.yylloc), s.push(x[1]), v = null, B = m.yyleng, c = m.yytext, $ = m.yylineno, tt = m.yylloc;
+            break;
+          case 2:
+            if (P = this.productions_[x[1]][1], R.$ = a[a.length - P], R._$ = {
+              first_line: n[n.length - (P || 1)].first_line,
+              last_line: n[n.length - 1].last_line,
+              first_column: n[n.length - (P || 1)].first_column,
+              last_column: n[n.length - 1].last_column
+            }, pt && (R._$.range = [
+              n[n.length - (P || 1)].range[0],
+              n[n.length - 1].range[1]
+            ]), et = this.performAction.apply(R, [
+              c,
+              B,
+              $,
+              W.yy,
+              x[1],
+              a,
+              n
+            ].concat(X)), typeof et != "undefined")
+              return et;
+            P && (s = s.slice(0, -1 * P * 2), a = a.slice(0, -1 * P), n = n.slice(0, -1 * P)), s.push(this.productions_[x[1]][0]), a.push(R.$), n.push(R._$), lt = E[s[s.length - 2]][s[s.length - 1]], s.push(lt);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }
+  }, A = function() {
+    var _ = {
+      EOF: 1,
+      parseError: function(i, s) {
+        if (this.yy.parser)
+          this.yy.parser.parseError(i, s);
+        else
+          throw new Error(i);
+      },
+      // resets the lexer, sets new input
+      setInput: function(e, i) {
+        return this.yy = i || this.yy || {}, this._input = e, 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 e = this._input[0];
+        this.yytext += e, this.yyleng++, this.offset++, this.match += e, this.matched += e;
+        var i = e.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), e;
+      },
+      // unshifts one char (or a string) into the input
+      unput: function(e) {
+        var i = e.length, s = e.split(/(?:\r\n?|\n)/g);
+        this._input = e + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - i), this.offset -= i;
+        var l = 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), s.length - 1 && (this.yylineno -= s.length - 1);
+        var a = 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: s ? (s.length === l.length ? this.yylloc.first_column : 0) + l[l.length - s.length].length - s[0].length : this.yylloc.first_column - i
+        }, this.options.ranges && (this.yylloc.range = [a[0], a[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(e) {
+        this.unput(this.match.slice(e));
+      },
+      // displays already matched input, i.e. for error messages
+      pastInput: function() {
+        var e = this.matched.substr(0, this.matched.length - this.match.length);
+        return (e.length > 20 ? "..." : "") + e.substr(-20).replace(/\n/g, "");
+      },
+      // displays upcoming input, i.e. for error messages
+      upcomingInput: function() {
+        var e = this.match;
+        return e.length < 20 && (e += this._input.substr(0, 20 - e.length)), (e.substr(0, 20) + (e.length > 20 ? "..." : "")).replace(/\n/g, "");
+      },
+      // displays the character position where the lexing error occurred, i.e. for error messages
+      showPosition: function() {
+        var e = this.pastInput(), i = new Array(e.length + 1).join("-");
+        return e + this.upcomingInput() + `
+` + i + "^";
+      },
+      // test the lexed token: return FALSE when not a match, otherwise return token
+      test_match: function(e, i) {
+        var s, l, a;
+        if (this.options.backtrack_lexer && (a = {
+          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 && (a.yylloc.range = this.yylloc.range.slice(0))), l = e[0].match(/(?:\r\n?|\n).*/g), l && (this.yylineno += l.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: l ? l[l.length - 1].length - l[l.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + e[0].length
+        }, this.yytext += e[0], this.match += e[0], this.matches = e, 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(e[0].length), this.matched += e[0], s = this.performAction.call(this, this.yy, this, i, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), s)
+          return s;
+        if (this._backtrack) {
+          for (var n in a)
+            this[n] = a[n];
+          return !1;
+        }
+        return !1;
+      },
+      // return next match in input
+      next: function() {
+        if (this.done)
+          return this.EOF;
+        this._input || (this.done = !0);
+        var e, i, s, l;
+        this._more || (this.yytext = "", this.match = "");
+        for (var a = this._currentRules(), n = 0; n < a.length; n++)
+          if (s = this._input.match(this.rules[a[n]]), s && (!i || s[0].length > i[0].length)) {
+            if (i = s, l = n, this.options.backtrack_lexer) {
+              if (e = this.test_match(s, a[n]), e !== !1)
+                return e;
+              if (this._backtrack) {
+                i = !1;
+                continue;
+              } else
+                return !1;
+            } else if (!this.options.flex)
+              break;
+          }
+        return i ? (e = this.test_match(i, a[l]), e !== !1 ? e : !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, s, l, a) {
+        switch (l) {
+          case 0:
+            return this.begin("open_directive"), 29;
+          case 1:
+            return this.begin("type_directive"), 30;
+          case 2:
+            return this.popState(), this.begin("arg_directive"), 24;
+          case 3:
+            return this.popState(), this.popState(), 32;
+          case 4:
+            return 31;
+          case 5:
+            break;
+          case 6:
+            break;
+          case 7:
+            return 26;
+          case 8:
+            break;
+          case 9:
+            break;
+          case 10:
+            return this.begin("title"), 13;
+          case 11:
+            return this.popState(), "title_value";
+          case 12:
+            return this.begin("acc_title"), 15;
+          case 13:
+            return this.popState(), "acc_title_value";
+          case 14:
+            return this.begin("acc_descr"), 17;
+          case 15:
+            return this.popState(), "acc_descr_value";
+          case 16:
+            this.begin("acc_descr_multiline");
+            break;
+          case 17:
+            this.popState();
+            break;
+          case 18:
+            return "acc_descr_multiline_value";
+          case 19:
+            this.begin("string");
+            break;
+          case 20:
+            this.popState();
+            break;
+          case 21:
+            return "txt";
+          case 22:
+            return 6;
+          case 23:
+            return 8;
+          case 24:
+            return "value";
+          case 25:
+            return 28;
+        }
+      },
+      rules: [/^(?:%%\{)/i, /^(?:((?:(?!\}%%)[^:.])*))/i, /^(?::)/i, /^(?:\}%%)/i, /^(?:((?:(?!\}%%).|\n)*))/i, /^(?:%%(?!\{)[^\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: [17, 18], inclusive: !1 }, acc_descr: { rules: [15], inclusive: !1 }, acc_title: { rules: [13], inclusive: !1 }, close_directive: { rules: [], inclusive: !1 }, arg_directive: { rules: [3, 4], inclusive: !1 }, type_directive: { rules: [2, 3], inclusive: !1 }, open_directive: { rules: [1], inclusive: !1 }, title: { rules: [11], inclusive: !1 }, string: { rules: [20, 21], inclusive: !1 }, INITIAL: { rules: [0, 5, 6, 7, 8, 9, 10, 12, 14, 16, 19, 22, 23, 24, 25], inclusive: !0 } }
+    };
+    return _;
+  }();
+  V.lexer = A;
+  function k() {
+    this.yy = {};
+  }
+  return k.prototype = V, V.Parser = k, new k();
+}();
+st.parser = st;
+const Lt = st;
+let J = {}, at = !1;
+const Nt = function(t, r, o) {
+  kt.parseDirective(this, t, r, o);
+}, Ct = function(t, r) {
+  t = xt.sanitizeText(t, Q()), J[t] === void 0 && (J[t] = r, U.debug("Added new section :", t));
+}, Ft = () => J, Mt = function(t) {
+  at = t;
+}, Wt = function() {
+  return at;
+}, jt = function(t) {
+  return t.substring(0, 1) === ":" && (t = t.substring(1).trim()), Number(t.trim());
+}, zt = function() {
+  J = {}, at = !1, St();
+}, Rt = {
+  parseDirective: Nt,
+  getConfig: () => Q().pie,
+  addSection: Ct,
+  getSections: Ft,
+  cleanupValue: jt,
+  clear: zt,
+  setAccTitle: gt,
+  getAccTitle: dt,
+  setDiagramTitle: mt,
+  getDiagramTitle: _t,
+  setShowData: Mt,
+  getShowData: Wt,
+  getAccDescription: vt,
+  setAccDescription: bt
+}, Bt = (t) => `
+  .pieCircle{
+    stroke: ${t.pieStrokeColor};
+    stroke-width : ${t.pieStrokeWidth};
+    opacity : ${t.pieOpacity};
+  }
+  .pieOuterCircle{
+    stroke: ${t.pieOuterStrokeColor};
+    stroke-width: ${t.pieOuterStrokeWidth};
+    fill: none;
+  }
+  .pieTitleText {
+    text-anchor: middle;
+    font-size: ${t.pieTitleTextSize};
+    fill: ${t.pieTitleTextColor};
+    font-family: ${t.fontFamily};
+  }
+  .slice {
+    font-family: ${t.fontFamily};
+    fill: ${t.pieSectionTextColor};
+    font-size:${t.pieSectionTextSize};
+    // fill: white;
+  }
+  .legend text {
+    fill: ${t.pieLegendTextColor};
+    font-family: ${t.fontFamily};
+    font-size: ${t.pieLegendTextSize};
+  }
+`, Yt = Bt;
+let T = Q(), L;
+const Y = 450, Ut = (t, r, o, u) => {
+  var A;
+  var p;
+  try {
+    T = Q(), U.debug(`Rendering info diagram
+` + t);
+    const k = Q().securityLevel;
+    let _;
+    k === "sandbox" && (_ = rt("#i" + r));
+    const e = k === "sandbox" ? rt(_.nodes()[0].contentDocument.body) : rt("body"), i = k === "sandbox" ? _.nodes()[0].contentDocument : document;
+    u.db.clear(), u.parser.parse(t), U.debug("Parsed info diagram");
+    const s = i.getElementById(r);
+    L = s.parentElement.offsetWidth, L === void 0 && (L = 1200), T.useWidth !== void 0 && (L = T.useWidth), T.pie.useWidth !== void 0 && (L = T.pie.useWidth);
+    const l = e.select("#" + r);
+    wt(l, Y, L, T.pie.useMaxWidth), s.setAttribute("viewBox", "0 0 " + L + " " + Y);
+    var g = 40, f = 18, h = 4, d = Math.min(L, Y) / 2 - g, y = l.append("g").attr("transform", "translate(" + L / 2 + "," + Y / 2 + ")"), S = u.db.getSections(), N = 0;
+    Object.keys(S).forEach(function(c) {
+      N += S[c];
+    });
+    const a = T.themeVariables;
+    var C = [
+      a.pie1,
+      a.pie2,
+      a.pie3,
+      a.pie4,
+      a.pie5,
+      a.pie6,
+      a.pie7,
+      a.pie8,
+      a.pie9,
+      a.pie10,
+      a.pie11,
+      a.pie12
+    ];
+    const n = (A = (p = T.pie) == null ? void 0 : p.textPosition) != null ? A : 0.75;
+    let [E] = At(a.pieOuterStrokeWidth);
+    E != null || (E = 2);
+    var b = ft().range(C), w = Object.entries(S).map(function(c, $) {
+      return {
+        order: $,
+        name: c[0],
+        value: c[1]
+      };
+    }), I = Ot().value(function(c) {
+      return c.value;
+    }).sort(function(c, $) {
+      return c.order - $.order;
+    }), D = I(w), F = ct().innerRadius(0).outerRadius(d), M = ct().innerRadius(d * n).outerRadius(d * n);
+    y.append("circle").attr("cx", 0).attr("cy", 0).attr("r", d + E / 2).attr("class", "pieOuterCircle"), y.selectAll("mySlices").data(D).enter().append("path").attr("d", F).attr("fill", function(c) {
+      return b(c.data.name);
+    }).attr("class", "pieCircle"), y.selectAll("mySlices").data(D).enter().append("text").text(function(c) {
+      return (c.data.value / N * 100).toFixed(0) + "%";
+    }).attr("transform", function(c) {
+      return "translate(" + M.centroid(c) + ")";
+    }).style("text-anchor", "middle").attr("class", "slice"), y.append("text").text(u.db.getDiagramTitle()).attr("x", 0).attr("y", -(Y - 50) / 2).attr("class", "pieTitleText");
+    var V = y.selectAll(".legend").data(b.domain()).enter().append("g").attr("class", "legend").attr("transform", function(c, $) {
+      const B = f + h, K = B * b.domain().length / 2, q = 12 * f, X = $ * B - K;
+      return "translate(" + q + "," + X + ")";
+    });
+    V.append("rect").attr("width", f).attr("height", f).style("fill", b).style("stroke", b), V.data(D).append("text").attr("x", f + h).attr("y", f - h).text(function(c) {
+      return u.db.getShowData() || T.showData || T.pie.showData ? c.data.name + " [" + c.data.value + "]" : c.data.name;
+    });
+  } catch (k) {
+    U.error("Error while rendering info diagram"), U.error(k);
+  }
+}, Qt = {
+  draw: Ut
+}, Xt = {
+  parser: Lt,
+  db: Rt,
+  renderer: Qt,
+  styles: Yt
+};
+export {
+  Xt as diagram
+};