@digipair/skill-web-chatbot 0.91.0-0 → 0.92.0

package/xychartDiagram-e5e6b652.esm.js

@@ -0,0 +1,3148 @@
+import { a$ as up, b0 as $t, aM as nl, aL as yp, F as F_, A as A_, M as M_, h as O_, E as E_, L as L_, j as B_, c as L, aK as z_, O as Ol, a as ai$1 } from './index.esm2.js';
+import { Q as Qr } from './createText-03b82060.esm.js';
+import { t } from './init-f9637058.esm.js';
+import { h } from './ordinal-5695958c.esm.js';
+import { H as Hn } from './linear-9bcf74c4.esm.js';
+import { P } from './line-24d93f1b.esm.js';
+import './array-2ff2c7a6.esm.js';
+import './path-428ebac9.esm.js';
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function Jt(e, t, i) {
+    e = +e, t = +t, i = (n = arguments.length) < 2 ? (t = e, e = 0, 1) : n < 3 ? 1 : +i;
+    for(var s = -1, n = Math.max(0, Math.ceil((t - e) / i)) | 0, o = new Array(n); ++s < n;)o[s] = e + s * i;
+    return o;
+}
+function st() {
+    var e = h().unknown(void 0), t$1 = e.domain, i = e.range, s = 0, n = 1, o, c, f = !1, d = 0, R = 0, _ = 0.5;
+    delete e.unknown;
+    function A() {
+        var m = t$1().length, T = n < s, S = T ? n : s, P = T ? s : n;
+        o = (P - S) / Math.max(1, m - d + R * 2), f && (o = Math.floor(o)), S += (P - S - o * (m - d)) * _, c = o * (1 - d), f && (S = Math.round(S), c = Math.round(c));
+        var p = Jt(m).map(function(C) {
+            return S + o * C;
+        });
+        return i(T ? p.reverse() : p);
+    }
+    return e.domain = function(m) {
+        return arguments.length ? (t$1(m), A()) : t$1();
+    }, e.range = function(m) {
+        var ref;
+        return arguments.length ? (ref = _sliced_to_array(m, 2), s = ref[0], n = ref[1], s = +s, n = +n, A()) : [
+            s,
+            n
+        ];
+    }, e.rangeRound = function(m) {
+        var ref;
+        return ref = _sliced_to_array(m, 2), s = ref[0], n = ref[1], s = +s, n = +n, f = !0, A();
+    }, e.bandwidth = function() {
+        return c;
+    }, e.step = function() {
+        return o;
+    }, e.round = function(m) {
+        return arguments.length ? (f = !!m, A()) : f;
+    }, e.padding = function(m) {
+        return arguments.length ? (d = Math.min(1, R = +m), A()) : d;
+    }, e.paddingInner = function(m) {
+        return arguments.length ? (d = Math.min(1, m), A()) : d;
+    }, e.paddingOuter = function(m) {
+        return arguments.length ? (R = +m, A()) : R;
+    }, e.align = function(m) {
+        return arguments.length ? (_ = Math.max(0, Math.min(1, m)), A()) : _;
+    }, e.copy = function() {
+        return st(t$1(), [
+            s,
+            n
+        ]).round(f).paddingInner(d).paddingOuter(R).align(_);
+    }, t.apply(A(), arguments);
+}
+var nt = function() {
+    var e = function e(V, r, l, u) {
+        for(l = l || {}, u = V.length; u--; l[V[u]] = r);
+        return l;
+    }, t = [
+        1,
+        10,
+        12,
+        14,
+        16,
+        18,
+        19,
+        21,
+        23
+    ], i = [
+        2,
+        6
+    ], s = [
+        1,
+        3
+    ], n = [
+        1,
+        5
+    ], o = [
+        1,
+        6
+    ], c = [
+        1,
+        7
+    ], f = [
+        1,
+        5,
+        10,
+        12,
+        14,
+        16,
+        18,
+        19,
+        21,
+        23,
+        34,
+        35,
+        36
+    ], d = [
+        1,
+        25
+    ], R = [
+        1,
+        26
+    ], _ = [
+        1,
+        28
+    ], A = [
+        1,
+        29
+    ], m = [
+        1,
+        30
+    ], T = [
+        1,
+        31
+    ], S = [
+        1,
+        32
+    ], P = [
+        1,
+        33
+    ], p = [
+        1,
+        34
+    ], C = [
+        1,
+        35
+    ], h = [
+        1,
+        36
+    ], L = [
+        1,
+        37
+    ], z = [
+        1,
+        43
+    ], lt = [
+        1,
+        42
+    ], ct = [
+        1,
+        47
+    ], U = [
+        1,
+        50
+    ], w = [
+        1,
+        10,
+        12,
+        14,
+        16,
+        18,
+        19,
+        21,
+        23,
+        34,
+        35,
+        36
+    ], Q = [
+        1,
+        10,
+        12,
+        14,
+        16,
+        18,
+        19,
+        21,
+        23,
+        24,
+        26,
+        27,
+        28,
+        34,
+        35,
+        36
+    ], E = [
+        1,
+        10,
+        12,
+        14,
+        16,
+        18,
+        19,
+        21,
+        23,
+        24,
+        26,
+        27,
+        28,
+        34,
+        35,
+        36,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50
+    ], ut = [
+        1,
+        64
+    ], K = {
+        trace: function trace() {},
+        yy: {},
+        symbols_: {
+            error: 2,
+            start: 3,
+            eol: 4,
+            XYCHART: 5,
+            chartConfig: 6,
+            document: 7,
+            CHART_ORIENTATION: 8,
+            statement: 9,
+            title: 10,
+            text: 11,
+            X_AXIS: 12,
+            parseXAxis: 13,
+            Y_AXIS: 14,
+            parseYAxis: 15,
+            LINE: 16,
+            plotData: 17,
+            BAR: 18,
+            acc_title: 19,
+            acc_title_value: 20,
+            acc_descr: 21,
+            acc_descr_value: 22,
+            acc_descr_multiline_value: 23,
+            SQUARE_BRACES_START: 24,
+            commaSeparatedNumbers: 25,
+            SQUARE_BRACES_END: 26,
+            NUMBER_WITH_DECIMAL: 27,
+            COMMA: 28,
+            xAxisData: 29,
+            bandData: 30,
+            ARROW_DELIMITER: 31,
+            commaSeparatedTexts: 32,
+            yAxisData: 33,
+            NEWLINE: 34,
+            SEMI: 35,
+            EOF: 36,
+            alphaNum: 37,
+            STR: 38,
+            MD_STR: 39,
+            alphaNumToken: 40,
+            AMP: 41,
+            NUM: 42,
+            ALPHA: 43,
+            PLUS: 44,
+            EQUALS: 45,
+            MULT: 46,
+            DOT: 47,
+            BRKT: 48,
+            MINUS: 49,
+            UNDERSCORE: 50,
+            $accept: 0,
+            $end: 1
+        },
+        terminals_: {
+            2: "error",
+            5: "XYCHART",
+            8: "CHART_ORIENTATION",
+            10: "title",
+            12: "X_AXIS",
+            14: "Y_AXIS",
+            16: "LINE",
+            18: "BAR",
+            19: "acc_title",
+            20: "acc_title_value",
+            21: "acc_descr",
+            22: "acc_descr_value",
+            23: "acc_descr_multiline_value",
+            24: "SQUARE_BRACES_START",
+            26: "SQUARE_BRACES_END",
+            27: "NUMBER_WITH_DECIMAL",
+            28: "COMMA",
+            31: "ARROW_DELIMITER",
+            34: "NEWLINE",
+            35: "SEMI",
+            36: "EOF",
+            38: "STR",
+            39: "MD_STR",
+            41: "AMP",
+            42: "NUM",
+            43: "ALPHA",
+            44: "PLUS",
+            45: "EQUALS",
+            46: "MULT",
+            47: "DOT",
+            48: "BRKT",
+            49: "MINUS",
+            50: "UNDERSCORE"
+        },
+        productions_: [
+            0,
+            [
+                3,
+                2
+            ],
+            [
+                3,
+                3
+            ],
+            [
+                3,
+                2
+            ],
+            [
+                3,
+                1
+            ],
+            [
+                6,
+                1
+            ],
+            [
+                7,
+                0
+            ],
+            [
+                7,
+                2
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                3
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                3
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                2
+            ],
+            [
+                9,
+                1
+            ],
+            [
+                17,
+                3
+            ],
+            [
+                25,
+                3
+            ],
+            [
+                25,
+                1
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                13,
+                2
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                29,
+                1
+            ],
+            [
+                29,
+                3
+            ],
+            [
+                30,
+                3
+            ],
+            [
+                32,
+                3
+            ],
+            [
+                32,
+                1
+            ],
+            [
+                15,
+                1
+            ],
+            [
+                15,
+                2
+            ],
+            [
+                15,
+                1
+            ],
+            [
+                33,
+                3
+            ],
+            [
+                4,
+                1
+            ],
+            [
+                4,
+                1
+            ],
+            [
+                4,
+                1
+            ],
+            [
+                11,
+                1
+            ],
+            [
+                11,
+                1
+            ],
+            [
+                11,
+                1
+            ],
+            [
+                37,
+                1
+            ],
+            [
+                37,
+                2
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ],
+            [
+                40,
+                1
+            ]
+        ],
+        performAction: function performAction(r, l, u, g, b, a, F) {
+            var x = a.length - 1;
+            switch(b){
+                case 5:
+                    g.setOrientation(a[x]);
+                    break;
+                case 9:
+                    g.setDiagramTitle(a[x].text.trim());
+                    break;
+                case 12:
+                    g.setLineData({
+                        text: "",
+                        type: "text"
+                    }, a[x]);
+                    break;
+                case 13:
+                    g.setLineData(a[x - 1], a[x]);
+                    break;
+                case 14:
+                    g.setBarData({
+                        text: "",
+                        type: "text"
+                    }, a[x]);
+                    break;
+                case 15:
+                    g.setBarData(a[x - 1], a[x]);
+                    break;
+                case 16:
+                    this.$ = a[x].trim(), g.setAccTitle(this.$);
+                    break;
+                case 17:
+                case 18:
+                    this.$ = a[x].trim(), g.setAccDescription(this.$);
+                    break;
+                case 19:
+                    this.$ = a[x - 1];
+                    break;
+                case 20:
+                    this.$ = [
+                        Number(a[x - 2])
+                    ].concat(_to_consumable_array(a[x]));
+                    break;
+                case 21:
+                    this.$ = [
+                        Number(a[x])
+                    ];
+                    break;
+                case 22:
+                    g.setXAxisTitle(a[x]);
+                    break;
+                case 23:
+                    g.setXAxisTitle(a[x - 1]);
+                    break;
+                case 24:
+                    g.setXAxisTitle({
+                        type: "text",
+                        text: ""
+                    });
+                    break;
+                case 25:
+                    g.setXAxisBand(a[x]);
+                    break;
+                case 26:
+                    g.setXAxisRangeData(Number(a[x - 2]), Number(a[x]));
+                    break;
+                case 27:
+                    this.$ = a[x - 1];
+                    break;
+                case 28:
+                    this.$ = [
+                        a[x - 2]
+                    ].concat(_to_consumable_array(a[x]));
+                    break;
+                case 29:
+                    this.$ = [
+                        a[x]
+                    ];
+                    break;
+                case 30:
+                    g.setYAxisTitle(a[x]);
+                    break;
+                case 31:
+                    g.setYAxisTitle(a[x - 1]);
+                    break;
+                case 32:
+                    g.setYAxisTitle({
+                        type: "text",
+                        text: ""
+                    });
+                    break;
+                case 33:
+                    g.setYAxisRangeData(Number(a[x - 2]), Number(a[x]));
+                    break;
+                case 37:
+                    this.$ = {
+                        text: a[x],
+                        type: "text"
+                    };
+                    break;
+                case 38:
+                    this.$ = {
+                        text: a[x],
+                        type: "text"
+                    };
+                    break;
+                case 39:
+                    this.$ = {
+                        text: a[x],
+                        type: "markdown"
+                    };
+                    break;
+                case 40:
+                    this.$ = a[x];
+                    break;
+                case 41:
+                    this.$ = a[x - 1] + "" + a[x];
+                    break;
+            }
+        },
+        table: [
+            e(t, i, {
+                3: 1,
+                4: 2,
+                7: 4,
+                5: s,
+                34: n,
+                35: o,
+                36: c
+            }),
+            {
+                1: [
+                    3
+                ]
+            },
+            e(t, i, {
+                4: 2,
+                7: 4,
+                3: 8,
+                5: s,
+                34: n,
+                35: o,
+                36: c
+            }),
+            e(t, i, {
+                4: 2,
+                7: 4,
+                6: 9,
+                3: 10,
+                5: s,
+                8: [
+                    1,
+                    11
+                ],
+                34: n,
+                35: o,
+                36: c
+            }),
+            {
+                1: [
+                    2,
+                    4
+                ],
+                9: 12,
+                10: [
+                    1,
+                    13
+                ],
+                12: [
+                    1,
+                    14
+                ],
+                14: [
+                    1,
+                    15
+                ],
+                16: [
+                    1,
+                    16
+                ],
+                18: [
+                    1,
+                    17
+                ],
+                19: [
+                    1,
+                    18
+                ],
+                21: [
+                    1,
+                    19
+                ],
+                23: [
+                    1,
+                    20
+                ]
+            },
+            e(f, [
+                2,
+                34
+            ]),
+            e(f, [
+                2,
+                35
+            ]),
+            e(f, [
+                2,
+                36
+            ]),
+            {
+                1: [
+                    2,
+                    1
+                ]
+            },
+            e(t, i, {
+                4: 2,
+                7: 4,
+                3: 21,
+                5: s,
+                34: n,
+                35: o,
+                36: c
+            }),
+            {
+                1: [
+                    2,
+                    3
+                ]
+            },
+            e(f, [
+                2,
+                5
+            ]),
+            e(t, [
+                2,
+                7
+            ], {
+                4: 22,
+                34: n,
+                35: o,
+                36: c
+            }),
+            {
+                11: 23,
+                37: 24,
+                38: d,
+                39: R,
+                40: 27,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            },
+            {
+                11: 39,
+                13: 38,
+                24: z,
+                27: lt,
+                29: 40,
+                30: 41,
+                37: 24,
+                38: d,
+                39: R,
+                40: 27,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            },
+            {
+                11: 45,
+                15: 44,
+                27: ct,
+                33: 46,
+                37: 24,
+                38: d,
+                39: R,
+                40: 27,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            },
+            {
+                11: 49,
+                17: 48,
+                24: U,
+                37: 24,
+                38: d,
+                39: R,
+                40: 27,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            },
+            {
+                11: 52,
+                17: 51,
+                24: U,
+                37: 24,
+                38: d,
+                39: R,
+                40: 27,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            },
+            {
+                20: [
+                    1,
+                    53
+                ]
+            },
+            {
+                22: [
+                    1,
+                    54
+                ]
+            },
+            e(w, [
+                2,
+                18
+            ]),
+            {
+                1: [
+                    2,
+                    2
+                ]
+            },
+            e(w, [
+                2,
+                8
+            ]),
+            e(w, [
+                2,
+                9
+            ]),
+            e(Q, [
+                2,
+                37
+            ], {
+                40: 55,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            }),
+            e(Q, [
+                2,
+                38
+            ]),
+            e(Q, [
+                2,
+                39
+            ]),
+            e(E, [
+                2,
+                40
+            ]),
+            e(E, [
+                2,
+                42
+            ]),
+            e(E, [
+                2,
+                43
+            ]),
+            e(E, [
+                2,
+                44
+            ]),
+            e(E, [
+                2,
+                45
+            ]),
+            e(E, [
+                2,
+                46
+            ]),
+            e(E, [
+                2,
+                47
+            ]),
+            e(E, [
+                2,
+                48
+            ]),
+            e(E, [
+                2,
+                49
+            ]),
+            e(E, [
+                2,
+                50
+            ]),
+            e(E, [
+                2,
+                51
+            ]),
+            e(w, [
+                2,
+                10
+            ]),
+            e(w, [
+                2,
+                22
+            ], {
+                30: 41,
+                29: 56,
+                24: z,
+                27: lt
+            }),
+            e(w, [
+                2,
+                24
+            ]),
+            e(w, [
+                2,
+                25
+            ]),
+            {
+                31: [
+                    1,
+                    57
+                ]
+            },
+            {
+                11: 59,
+                32: 58,
+                37: 24,
+                38: d,
+                39: R,
+                40: 27,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            },
+            e(w, [
+                2,
+                11
+            ]),
+            e(w, [
+                2,
+                30
+            ], {
+                33: 60,
+                27: ct
+            }),
+            e(w, [
+                2,
+                32
+            ]),
+            {
+                31: [
+                    1,
+                    61
+                ]
+            },
+            e(w, [
+                2,
+                12
+            ]),
+            {
+                17: 62,
+                24: U
+            },
+            {
+                25: 63,
+                27: ut
+            },
+            e(w, [
+                2,
+                14
+            ]),
+            {
+                17: 65,
+                24: U
+            },
+            e(w, [
+                2,
+                16
+            ]),
+            e(w, [
+                2,
+                17
+            ]),
+            e(E, [
+                2,
+                41
+            ]),
+            e(w, [
+                2,
+                23
+            ]),
+            {
+                27: [
+                    1,
+                    66
+                ]
+            },
+            {
+                26: [
+                    1,
+                    67
+                ]
+            },
+            {
+                26: [
+                    2,
+                    29
+                ],
+                28: [
+                    1,
+                    68
+                ]
+            },
+            e(w, [
+                2,
+                31
+            ]),
+            {
+                27: [
+                    1,
+                    69
+                ]
+            },
+            e(w, [
+                2,
+                13
+            ]),
+            {
+                26: [
+                    1,
+                    70
+                ]
+            },
+            {
+                26: [
+                    2,
+                    21
+                ],
+                28: [
+                    1,
+                    71
+                ]
+            },
+            e(w, [
+                2,
+                15
+            ]),
+            e(w, [
+                2,
+                26
+            ]),
+            e(w, [
+                2,
+                27
+            ]),
+            {
+                11: 59,
+                32: 72,
+                37: 24,
+                38: d,
+                39: R,
+                40: 27,
+                41: _,
+                42: A,
+                43: m,
+                44: T,
+                45: S,
+                46: P,
+                47: p,
+                48: C,
+                49: h,
+                50: L
+            },
+            e(w, [
+                2,
+                33
+            ]),
+            e(w, [
+                2,
+                19
+            ]),
+            {
+                25: 73,
+                27: ut
+            },
+            {
+                26: [
+                    2,
+                    28
+                ]
+            },
+            {
+                26: [
+                    2,
+                    20
+                ]
+            }
+        ],
+        defaultActions: {
+            8: [
+                2,
+                1
+            ],
+            10: [
+                2,
+                3
+            ],
+            21: [
+                2,
+                2
+            ],
+            72: [
+                2,
+                28
+            ],
+            73: [
+                2,
+                20
+            ]
+        },
+        parseError: function parseError(r, l) {
+            if (l.recoverable) this.trace(r);
+            else {
+                var u = new Error(r);
+                throw u.hash = l, u;
+            }
+        },
+        parse: function parse(r) {
+            var l = this, u = [
+                0
+            ], g = [], b = [
+                null
+            ], a = [], F = this.table, x = "", $ = 0, gt = 0, Vt = 2, xt = 1, Wt = a.slice.call(arguments, 1), k = Object.create(this.lexer), W = {
+                yy: {}
+            };
+            for(var J in this.yy)Object.prototype.hasOwnProperty.call(this.yy, J) && (W.yy[J] = this.yy[J]);
+            k.setInput(r, W.yy), W.yy.lexer = k, W.yy.parser = this, _type_of(k.yylloc) > "u" && (k.yylloc = {});
+            var tt = k.yylloc;
+            a.push(tt);
+            var Bt = k.options && k.options.ranges;
+            typeof W.yy.parseError == "function" ? this.parseError = W.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+            function Ot() {
+                var I;
+                return I = g.pop() || k.lex() || xt, typeof I != "number" && (_instanceof(I, Array) && (g = I, I = g.pop()), I = l.symbols_[I] || I), I;
+            }
+            for(var D, B, v, it, O = {}, q, M, dt, j;;){
+                if (B = u[u.length - 1], this.defaultActions[B] ? v = this.defaultActions[B] : ((D === null || (typeof D === "undefined" ? "undefined" : _type_of(D)) > "u") && (D = Ot()), v = F[B] && F[B][D]), (typeof v === "undefined" ? "undefined" : _type_of(v)) > "u" || !v.length || !v[0]) {
+                    var et = "";
+                    j = [];
+                    for(q in F[B])this.terminals_[q] && q > Vt && j.push("'" + this.terminals_[q] + "'");
+                    k.showPosition ? et = "Parse error on line " + ($ + 1) + ":\n" + k.showPosition() + "\nExpecting " + j.join(", ") + ", got '" + (this.terminals_[D] || D) + "'" : et = "Parse error on line " + ($ + 1) + ": Unexpected " + (D == xt ? "end of input" : "'" + (this.terminals_[D] || D) + "'"), this.parseError(et, {
+                        text: k.match,
+                        token: this.terminals_[D] || D,
+                        line: k.yylineno,
+                        loc: tt,
+                        expected: j
+                    });
+                }
+                if (_instanceof(v[0], Array) && v.length > 1) throw new Error("Parse Error: multiple actions possible at state: " + B + ", token: " + D);
+                switch(v[0]){
+                    case 1:
+                        u.push(D), b.push(k.yytext), a.push(k.yylloc), u.push(v[1]), D = null, gt = k.yyleng, x = k.yytext, $ = k.yylineno, tt = k.yylloc;
+                        break;
+                    case 2:
+                        if (M = this.productions_[v[1]][1], O.$ = b[b.length - M], O._$ = {
+                            first_line: a[a.length - (M || 1)].first_line,
+                            last_line: a[a.length - 1].last_line,
+                            first_column: a[a.length - (M || 1)].first_column,
+                            last_column: a[a.length - 1].last_column
+                        }, Bt && (O._$.range = [
+                            a[a.length - (M || 1)].range[0],
+                            a[a.length - 1].range[1]
+                        ]), it = this.performAction.apply(O, [
+                            x,
+                            gt,
+                            $,
+                            W.yy,
+                            v[1],
+                            b,
+                            a
+                        ].concat(Wt)), (typeof it === "undefined" ? "undefined" : _type_of(it)) < "u") return it;
+                        M && (u = u.slice(0, -1 * M * 2), b = b.slice(0, -1 * M), a = a.slice(0, -1 * M)), u.push(this.productions_[v[1]][0]), b.push(O.$), a.push(O._$), dt = F[u[u.length - 2]][u[u.length - 1]], u.push(dt);
+                        break;
+                    case 3:
+                        return !0;
+                }
+            }
+            return !0;
+        }
+    }, It = function() {
+        var V = {
+            EOF: 1,
+            parseError: function parseError(l, u) {
+                if (this.yy.parser) this.yy.parser.parseError(l, u);
+                else throw new Error(l);
+            },
+            // resets the lexer, sets new input
+            setInput: function setInput(r, l) {
+                return this.yy = l || this.yy || {}, this._input = r, 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 input() {
+                var r = this._input[0];
+                this.yytext += r, this.yyleng++, this.offset++, this.match += r, this.matched += r;
+                var l = r.match(/(?:\r\n?|\n).*/g);
+                return l ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), r;
+            },
+            // unshifts one char (or a string) into the input
+            unput: function unput(r) {
+                var l = r.length, u = r.split(/(?:\r\n?|\n)/g);
+                this._input = r + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - l), this.offset -= l;
+                var g = this.match.split(/(?:\r\n?|\n)/g);
+                this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), u.length - 1 && (this.yylineno -= u.length - 1);
+                var b = this.yylloc.range;
+                return this.yylloc = {
+                    first_line: this.yylloc.first_line,
+                    last_line: this.yylineno + 1,
+                    first_column: this.yylloc.first_column,
+                    last_column: u ? (u.length === g.length ? this.yylloc.first_column : 0) + g[g.length - u.length].length - u[0].length : this.yylloc.first_column - l
+                }, this.options.ranges && (this.yylloc.range = [
+                    b[0],
+                    b[0] + this.yyleng - l
+                ]), this.yyleng = this.yytext.length, this;
+            },
+            // When called from action, caches matched text and appends it on next action
+            more: function more() {
+                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 reject() {
+                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).\n" + this.showPosition(), {
+                    text: "",
+                    token: null,
+                    line: this.yylineno
+                });
+                return this;
+            },
+            // retain first n characters of the match
+            less: function less(r) {
+                this.unput(this.match.slice(r));
+            },
+            // displays already matched input, i.e. for error messages
+            pastInput: function pastInput() {
+                var r = this.matched.substr(0, this.matched.length - this.match.length);
+                return (r.length > 20 ? "..." : "") + r.substr(-20).replace(/\n/g, "");
+            },
+            // displays upcoming input, i.e. for error messages
+            upcomingInput: function upcomingInput() {
+                var r = this.match;
+                return r.length < 20 && (r += this._input.substr(0, 20 - r.length)), (r.substr(0, 20) + (r.length > 20 ? "..." : "")).replace(/\n/g, "");
+            },
+            // displays the character position where the lexing error occurred, i.e. for error messages
+            showPosition: function showPosition() {
+                var r = this.pastInput(), l = new Array(r.length + 1).join("-");
+                return r + this.upcomingInput() + "\n" + l + "^";
+            },
+            // test the lexed token: return FALSE when not a match, otherwise return token
+            test_match: function test_match(r, l) {
+                var u, g, b;
+                if (this.options.backtrack_lexer && (b = {
+                    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 && (b.yylloc.range = this.yylloc.range.slice(0))), g = r[0].match(/(?:\r\n?|\n).*/g), g && (this.yylineno += g.length), this.yylloc = {
+                    first_line: this.yylloc.last_line,
+                    last_line: this.yylineno + 1,
+                    first_column: this.yylloc.last_column,
+                    last_column: g ? g[g.length - 1].length - g[g.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + r[0].length
+                }, this.yytext += r[0], this.match += r[0], this.matches = r, 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(r[0].length), this.matched += r[0], u = this.performAction.call(this, this.yy, this, l, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), u) return u;
+                if (this._backtrack) {
+                    for(var a in b)this[a] = b[a];
+                    return !1;
+                }
+                return !1;
+            },
+            // return next match in input
+            next: function next() {
+                if (this.done) return this.EOF;
+                this._input || (this.done = !0);
+                var r, l, u, g;
+                this._more || (this.yytext = "", this.match = "");
+                for(var b = this._currentRules(), a = 0; a < b.length; a++)if (u = this._input.match(this.rules[b[a]]), u && (!l || u[0].length > l[0].length)) {
+                    if (l = u, g = a, this.options.backtrack_lexer) {
+                        if (r = this.test_match(u, b[a]), r !== !1) return r;
+                        if (this._backtrack) {
+                            l = !1;
+                            continue;
+                        } else return !1;
+                    } else if (!this.options.flex) break;
+                }
+                return l ? (r = this.test_match(l, b[g]), r !== !1 ? r : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
+                    text: "",
+                    token: null,
+                    line: this.yylineno
+                });
+            },
+            // return next match that has a token
+            lex: function lex() {
+                var l = this.next();
+                return l || this.lex();
+            },
+            // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+            begin: function begin(l) {
+                this.conditionStack.push(l);
+            },
+            // pop the previously active lexer condition state off the condition stack
+            popState: function popState() {
+                var l = this.conditionStack.length - 1;
+                return l > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+            },
+            // produce the lexer rule set which is active for the currently active lexer condition state
+            _currentRules: function _currentRules() {
+                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 topState(l) {
+                return l = this.conditionStack.length - 1 - Math.abs(l || 0), l >= 0 ? this.conditionStack[l] : "INITIAL";
+            },
+            // alias for begin(condition)
+            pushState: function pushState(l) {
+                this.begin(l);
+            },
+            // return the number of states currently on the stack
+            stateStackSize: function stateStackSize() {
+                return this.conditionStack.length;
+            },
+            options: {
+                "case-insensitive": !0
+            },
+            performAction: function performAction(l, u, g, b) {
+                switch(g){
+                    case 0:
+                        break;
+                    case 1:
+                        break;
+                    case 2:
+                        return this.popState(), 34;
+                    case 3:
+                        return this.popState(), 34;
+                    case 4:
+                        return 34;
+                    case 5:
+                        break;
+                    case 6:
+                        return 10;
+                    case 7:
+                        return this.pushState("acc_title"), 19;
+                    case 8:
+                        return this.popState(), "acc_title_value";
+                    case 9:
+                        return this.pushState("acc_descr"), 21;
+                    case 10:
+                        return this.popState(), "acc_descr_value";
+                    case 11:
+                        this.pushState("acc_descr_multiline");
+                        break;
+                    case 12:
+                        this.popState();
+                        break;
+                    case 13:
+                        return "acc_descr_multiline_value";
+                    case 14:
+                        return 5;
+                    case 15:
+                        return 8;
+                    case 16:
+                        return this.pushState("axis_data"), "X_AXIS";
+                    case 17:
+                        return this.pushState("axis_data"), "Y_AXIS";
+                    case 18:
+                        return this.pushState("axis_band_data"), 24;
+                    case 19:
+                        return 31;
+                    case 20:
+                        return this.pushState("data"), 16;
+                    case 21:
+                        return this.pushState("data"), 18;
+                    case 22:
+                        return this.pushState("data_inner"), 24;
+                    case 23:
+                        return 27;
+                    case 24:
+                        return this.popState(), 26;
+                    case 25:
+                        this.popState();
+                        break;
+                    case 26:
+                        this.pushState("string");
+                        break;
+                    case 27:
+                        this.popState();
+                        break;
+                    case 28:
+                        return "STR";
+                    case 29:
+                        return 24;
+                    case 30:
+                        return 26;
+                    case 31:
+                        return 43;
+                    case 32:
+                        return "COLON";
+                    case 33:
+                        return 44;
+                    case 34:
+                        return 28;
+                    case 35:
+                        return 45;
+                    case 36:
+                        return 46;
+                    case 37:
+                        return 48;
+                    case 38:
+                        return 50;
+                    case 39:
+                        return 47;
+                    case 40:
+                        return 41;
+                    case 41:
+                        return 49;
+                    case 42:
+                        return 42;
+                    case 43:
+                        break;
+                    case 44:
+                        return 35;
+                    case 45:
+                        return 36;
+                }
+            },
+            rules: [
+                /^(?:%%(?!\{)[^\n]*)/i,
+                /^(?:[^\}]%%[^\n]*)/i,
+                /^(?:(\r?\n))/i,
+                /^(?:(\r?\n))/i,
+                /^(?:[\n\r]+)/i,
+                /^(?:%%[^\n]*)/i,
+                /^(?:title\b)/i,
+                /^(?:accTitle\s*:\s*)/i,
+                /^(?:(?!\n||)*[^\n]*)/i,
+                /^(?:accDescr\s*:\s*)/i,
+                /^(?:(?!\n||)*[^\n]*)/i,
+                /^(?:accDescr\s*\{\s*)/i,
+                /^(?:\{)/i,
+                /^(?:[^\}]*)/i,
+                /^(?:xychart-beta\b)/i,
+                /^(?:(?:vertical|horizontal))/i,
+                /^(?:x-axis\b)/i,
+                /^(?:y-axis\b)/i,
+                /^(?:\[)/i,
+                /^(?:-->)/i,
+                /^(?:line\b)/i,
+                /^(?:bar\b)/i,
+                /^(?:\[)/i,
+                /^(?:[+-]?(?:\d+(?:\.\d+)?|\.\d+))/i,
+                /^(?:\])/i,
+                /^(?:(?:`\)                                    \{ this\.pushState\(md_string\); \}\n<md_string>\(\?:\(\?!`"\)\.\)\+                  \{ return MD_STR; \}\n<md_string>\(\?:`))/i,
+                /^(?:["])/i,
+                /^(?:["])/i,
+                /^(?:[^"]*)/i,
+                /^(?:\[)/i,
+                /^(?:\])/i,
+                /^(?:[A-Za-z]+)/i,
+                /^(?::)/i,
+                /^(?:\+)/i,
+                /^(?:,)/i,
+                /^(?:=)/i,
+                /^(?:\*)/i,
+                /^(?:#)/i,
+                /^(?:[\_])/i,
+                /^(?:\.)/i,
+                /^(?:&)/i,
+                /^(?:-)/i,
+                /^(?:[0-9]+)/i,
+                /^(?:\s+)/i,
+                /^(?:;)/i,
+                /^(?:$)/i
+            ],
+            conditions: {
+                data_inner: {
+                    rules: [
+                        0,
+                        1,
+                        4,
+                        5,
+                        6,
+                        7,
+                        9,
+                        11,
+                        14,
+                        15,
+                        16,
+                        17,
+                        20,
+                        21,
+                        23,
+                        24,
+                        25,
+                        26,
+                        29,
+                        30,
+                        31,
+                        32,
+                        33,
+                        34,
+                        35,
+                        36,
+                        37,
+                        38,
+                        39,
+                        40,
+                        41,
+                        42,
+                        43,
+                        44,
+                        45
+                    ],
+                    inclusive: !0
+                },
+                data: {
+                    rules: [
+                        0,
+                        1,
+                        3,
+                        4,
+                        5,
+                        6,
+                        7,
+                        9,
+                        11,
+                        14,
+                        15,
+                        16,
+                        17,
+                        20,
+                        21,
+                        22,
+                        25,
+                        26,
+                        29,
+                        30,
+                        31,
+                        32,
+                        33,
+                        34,
+                        35,
+                        36,
+                        37,
+                        38,
+                        39,
+                        40,
+                        41,
+                        42,
+                        43,
+                        44,
+                        45
+                    ],
+                    inclusive: !0
+                },
+                axis_band_data: {
+                    rules: [
+                        0,
+                        1,
+                        4,
+                        5,
+                        6,
+                        7,
+                        9,
+                        11,
+                        14,
+                        15,
+                        16,
+                        17,
+                        20,
+                        21,
+                        24,
+                        25,
+                        26,
+                        29,
+                        30,
+                        31,
+                        32,
+                        33,
+                        34,
+                        35,
+                        36,
+                        37,
+                        38,
+                        39,
+                        40,
+                        41,
+                        42,
+                        43,
+                        44,
+                        45
+                    ],
+                    inclusive: !0
+                },
+                axis_data: {
+                    rules: [
+                        0,
+                        1,
+                        2,
+                        4,
+                        5,
+                        6,
+                        7,
+                        9,
+                        11,
+                        14,
+                        15,
+                        16,
+                        17,
+                        18,
+                        19,
+                        20,
+                        21,
+                        23,
+                        25,
+                        26,
+                        29,
+                        30,
+                        31,
+                        32,
+                        33,
+                        34,
+                        35,
+                        36,
+                        37,
+                        38,
+                        39,
+                        40,
+                        41,
+                        42,
+                        43,
+                        44,
+                        45
+                    ],
+                    inclusive: !0
+                },
+                acc_descr_multiline: {
+                    rules: [
+                        12,
+                        13
+                    ],
+                    inclusive: !1
+                },
+                acc_descr: {
+                    rules: [
+                        10
+                    ],
+                    inclusive: !1
+                },
+                acc_title: {
+                    rules: [
+                        8
+                    ],
+                    inclusive: !1
+                },
+                title: {
+                    rules: [],
+                    inclusive: !1
+                },
+                md_string: {
+                    rules: [],
+                    inclusive: !1
+                },
+                string: {
+                    rules: [
+                        27,
+                        28
+                    ],
+                    inclusive: !1
+                },
+                INITIAL: {
+                    rules: [
+                        0,
+                        1,
+                        4,
+                        5,
+                        6,
+                        7,
+                        9,
+                        11,
+                        14,
+                        15,
+                        16,
+                        17,
+                        20,
+                        21,
+                        25,
+                        26,
+                        29,
+                        30,
+                        31,
+                        32,
+                        33,
+                        34,
+                        35,
+                        36,
+                        37,
+                        38,
+                        39,
+                        40,
+                        41,
+                        42,
+                        43,
+                        44,
+                        45
+                    ],
+                    inclusive: !0
+                }
+            }
+        };
+        return V;
+    }();
+    K.lexer = It;
+    function Z() {
+        this.yy = {};
+    }
+    return Z.prototype = K, K.Parser = Z, new Z();
+}();
+nt.parser = nt;
+var ti = nt;
+function mt(e) {
+    return e.type === "bar";
+}
+function _t(e) {
+    return e.type === "band";
+}
+function N(e) {
+    return e.type === "linear";
+}
+var kt = /*#__PURE__*/ function() {
+    function kt(t) {
+        _class_call_check(this, kt);
+        this.parentGroup = t;
+    }
+    _create_class(kt, [
+        {
+            key: "getMaxDimension",
+            value: function getMaxDimension(t, i) {
+                if (!this.parentGroup) return {
+                    width: t.reduce(function(o, c) {
+                        return Math.max(c.length, o);
+                    }, 0) * i,
+                    height: i
+                };
+                var s = {
+                    width: 0,
+                    height: 0
+                }, n = this.parentGroup.append("g").attr("visibility", "hidden").attr("font-size", i);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = t[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var o = _step.value;
+                        var c = Qr(n, 1, o), f = c ? c.width : o.length * i, d = c ? c.height : i;
+                        s.width = Math.max(s.width, f), s.height = Math.max(s.height, d);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return n.remove(), s;
+            }
+        }
+    ]);
+    return kt;
+}();
+var yt = 0.7, bt = 0.2;
+var Rt = /*#__PURE__*/ function() {
+    function Rt(t, i, s, n) {
+        _class_call_check(this, Rt);
+        this.axisConfig = t, this.title = i, this.textDimensionCalculator = s, this.axisThemeConfig = n, this.boundingRect = {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }, this.axisPosition = "left", this.showTitle = !1, this.showLabel = !1, this.showTick = !1, this.showAxisLine = !1, this.outerPadding = 0, this.titleTextHeight = 0, this.labelTextHeight = 0, this.range = [
+            0,
+            10
+        ], this.boundingRect = {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }, this.axisPosition = "left";
+    }
+    _create_class(Rt, [
+        {
+            key: "setRange",
+            value: function setRange(t) {
+                this.range = t, this.axisPosition === "left" || this.axisPosition === "right" ? this.boundingRect.height = t[1] - t[0] : this.boundingRect.width = t[1] - t[0], this.recalculateScale();
+            }
+        },
+        {
+            key: "getRange",
+            value: function getRange() {
+                return [
+                    this.range[0] + this.outerPadding,
+                    this.range[1] - this.outerPadding
+                ];
+            }
+        },
+        {
+            key: "setAxisPosition",
+            value: function setAxisPosition(t) {
+                this.axisPosition = t, this.setRange(this.range);
+            }
+        },
+        {
+            key: "getTickDistance",
+            value: function getTickDistance() {
+                var t = this.getRange();
+                return Math.abs(t[0] - t[1]) / this.getTickValues().length;
+            }
+        },
+        {
+            key: "getAxisOuterPadding",
+            value: function getAxisOuterPadding() {
+                return this.outerPadding;
+            }
+        },
+        {
+            key: "getLabelDimension",
+            value: function getLabelDimension() {
+                return this.textDimensionCalculator.getMaxDimension(this.getTickValues().map(function(t) {
+                    return t.toString();
+                }), this.axisConfig.labelFontSize);
+            }
+        },
+        {
+            key: "recalculateOuterPaddingToDrawBar",
+            value: function recalculateOuterPaddingToDrawBar() {
+                yt * this.getTickDistance() > this.outerPadding * 2 && (this.outerPadding = Math.floor(yt * this.getTickDistance() / 2)), this.recalculateScale();
+            }
+        },
+        {
+            key: "calculateSpaceIfDrawnHorizontally",
+            value: function calculateSpaceIfDrawnHorizontally(t) {
+                var i = t.height;
+                if (this.axisConfig.showAxisLine && i > this.axisConfig.axisLineWidth && (i -= this.axisConfig.axisLineWidth, this.showAxisLine = !0), this.axisConfig.showLabel) {
+                    var s = this.getLabelDimension(), n = bt * t.width;
+                    this.outerPadding = Math.min(s.width / 2, n);
+                    var o = s.height + this.axisConfig.labelPadding * 2;
+                    this.labelTextHeight = s.height, o <= i && (i -= o, this.showLabel = !0);
+                }
+                if (this.axisConfig.showTick && i >= this.axisConfig.tickLength && (this.showTick = !0, i -= this.axisConfig.tickLength), this.axisConfig.showTitle && this.title) {
+                    var s1 = this.textDimensionCalculator.getMaxDimension([
+                        this.title
+                    ], this.axisConfig.titleFontSize), n1 = s1.height + this.axisConfig.titlePadding * 2;
+                    this.titleTextHeight = s1.height, n1 <= i && (i -= n1, this.showTitle = !0);
+                }
+                this.boundingRect.width = t.width, this.boundingRect.height = t.height - i;
+            }
+        },
+        {
+            key: "calculateSpaceIfDrawnVertical",
+            value: function calculateSpaceIfDrawnVertical(t) {
+                var i = t.width;
+                if (this.axisConfig.showAxisLine && i > this.axisConfig.axisLineWidth && (i -= this.axisConfig.axisLineWidth, this.showAxisLine = !0), this.axisConfig.showLabel) {
+                    var s = this.getLabelDimension(), n = bt * t.height;
+                    this.outerPadding = Math.min(s.height / 2, n);
+                    var o = s.width + this.axisConfig.labelPadding * 2;
+                    o <= i && (i -= o, this.showLabel = !0);
+                }
+                if (this.axisConfig.showTick && i >= this.axisConfig.tickLength && (this.showTick = !0, i -= this.axisConfig.tickLength), this.axisConfig.showTitle && this.title) {
+                    var s1 = this.textDimensionCalculator.getMaxDimension([
+                        this.title
+                    ], this.axisConfig.titleFontSize), n1 = s1.height + this.axisConfig.titlePadding * 2;
+                    this.titleTextHeight = s1.height, n1 <= i && (i -= n1, this.showTitle = !0);
+                }
+                this.boundingRect.width = t.width - i, this.boundingRect.height = t.height;
+            }
+        },
+        {
+            key: "calculateSpace",
+            value: function calculateSpace(t) {
+                return this.axisPosition === "left" || this.axisPosition === "right" ? this.calculateSpaceIfDrawnVertical(t) : this.calculateSpaceIfDrawnHorizontally(t), this.recalculateScale(), {
+                    width: this.boundingRect.width,
+                    height: this.boundingRect.height
+                };
+            }
+        },
+        {
+            key: "setBoundingBoxXY",
+            value: function setBoundingBoxXY(t) {
+                this.boundingRect.x = t.x, this.boundingRect.y = t.y;
+            }
+        },
+        {
+            key: "getDrawableElementsForLeftAxis",
+            value: function getDrawableElementsForLeftAxis() {
+                var _this = this;
+                var t = [];
+                if (this.showAxisLine) {
+                    var i = this.boundingRect.x + this.boundingRect.width - this.axisConfig.axisLineWidth / 2;
+                    t.push({
+                        type: "path",
+                        groupTexts: [
+                            "left-axis",
+                            "axisl-line"
+                        ],
+                        data: [
+                            {
+                                path: "M ".concat(i, ",").concat(this.boundingRect.y, " L ").concat(i, ",").concat(this.boundingRect.y + this.boundingRect.height, " "),
+                                strokeFill: this.axisThemeConfig.axisLineColor,
+                                strokeWidth: this.axisConfig.axisLineWidth
+                            }
+                        ]
+                    });
+                }
+                if (this.showLabel && t.push({
+                    type: "text",
+                    groupTexts: [
+                        "left-axis",
+                        "label"
+                    ],
+                    data: this.getTickValues().map(function(i) {
+                        return {
+                            text: i.toString(),
+                            x: _this.boundingRect.x + _this.boundingRect.width - (_this.showLabel ? _this.axisConfig.labelPadding : 0) - (_this.showTick ? _this.axisConfig.tickLength : 0) - (_this.showAxisLine ? _this.axisConfig.axisLineWidth : 0),
+                            y: _this.getScaleValue(i),
+                            fill: _this.axisThemeConfig.labelColor,
+                            fontSize: _this.axisConfig.labelFontSize,
+                            rotation: 0,
+                            verticalPos: "middle",
+                            horizontalPos: "right"
+                        };
+                    })
+                }), this.showTick) {
+                    var i1 = this.boundingRect.x + this.boundingRect.width - (this.showAxisLine ? this.axisConfig.axisLineWidth : 0);
+                    t.push({
+                        type: "path",
+                        groupTexts: [
+                            "left-axis",
+                            "ticks"
+                        ],
+                        data: this.getTickValues().map(function(s) {
+                            return {
+                                path: "M ".concat(i1, ",").concat(_this.getScaleValue(s), " L ").concat(i1 - _this.axisConfig.tickLength, ",").concat(_this.getScaleValue(s)),
+                                strokeFill: _this.axisThemeConfig.tickColor,
+                                strokeWidth: _this.axisConfig.tickWidth
+                            };
+                        })
+                    });
+                }
+                return this.showTitle && t.push({
+                    type: "text",
+                    groupTexts: [
+                        "left-axis",
+                        "title"
+                    ],
+                    data: [
+                        {
+                            text: this.title,
+                            x: this.boundingRect.x + this.axisConfig.titlePadding,
+                            y: this.boundingRect.y + this.boundingRect.height / 2,
+                            fill: this.axisThemeConfig.titleColor,
+                            fontSize: this.axisConfig.titleFontSize,
+                            rotation: 270,
+                            verticalPos: "top",
+                            horizontalPos: "center"
+                        }
+                    ]
+                }), t;
+            }
+        },
+        {
+            key: "getDrawableElementsForBottomAxis",
+            value: function getDrawableElementsForBottomAxis() {
+                var _this = this;
+                var t = [];
+                if (this.showAxisLine) {
+                    var i = this.boundingRect.y + this.axisConfig.axisLineWidth / 2;
+                    t.push({
+                        type: "path",
+                        groupTexts: [
+                            "bottom-axis",
+                            "axis-line"
+                        ],
+                        data: [
+                            {
+                                path: "M ".concat(this.boundingRect.x, ",").concat(i, " L ").concat(this.boundingRect.x + this.boundingRect.width, ",").concat(i),
+                                strokeFill: this.axisThemeConfig.axisLineColor,
+                                strokeWidth: this.axisConfig.axisLineWidth
+                            }
+                        ]
+                    });
+                }
+                if (this.showLabel && t.push({
+                    type: "text",
+                    groupTexts: [
+                        "bottom-axis",
+                        "label"
+                    ],
+                    data: this.getTickValues().map(function(i) {
+                        return {
+                            text: i.toString(),
+                            x: _this.getScaleValue(i),
+                            y: _this.boundingRect.y + _this.axisConfig.labelPadding + (_this.showTick ? _this.axisConfig.tickLength : 0) + (_this.showAxisLine ? _this.axisConfig.axisLineWidth : 0),
+                            fill: _this.axisThemeConfig.labelColor,
+                            fontSize: _this.axisConfig.labelFontSize,
+                            rotation: 0,
+                            verticalPos: "top",
+                            horizontalPos: "center"
+                        };
+                    })
+                }), this.showTick) {
+                    var i1 = this.boundingRect.y + (this.showAxisLine ? this.axisConfig.axisLineWidth : 0);
+                    t.push({
+                        type: "path",
+                        groupTexts: [
+                            "bottom-axis",
+                            "ticks"
+                        ],
+                        data: this.getTickValues().map(function(s) {
+                            return {
+                                path: "M ".concat(_this.getScaleValue(s), ",").concat(i1, " L ").concat(_this.getScaleValue(s), ",").concat(i1 + _this.axisConfig.tickLength),
+                                strokeFill: _this.axisThemeConfig.tickColor,
+                                strokeWidth: _this.axisConfig.tickWidth
+                            };
+                        })
+                    });
+                }
+                return this.showTitle && t.push({
+                    type: "text",
+                    groupTexts: [
+                        "bottom-axis",
+                        "title"
+                    ],
+                    data: [
+                        {
+                            text: this.title,
+                            x: this.range[0] + (this.range[1] - this.range[0]) / 2,
+                            y: this.boundingRect.y + this.boundingRect.height - this.axisConfig.titlePadding - this.titleTextHeight,
+                            fill: this.axisThemeConfig.titleColor,
+                            fontSize: this.axisConfig.titleFontSize,
+                            rotation: 0,
+                            verticalPos: "top",
+                            horizontalPos: "center"
+                        }
+                    ]
+                }), t;
+            }
+        },
+        {
+            key: "getDrawableElementsForTopAxis",
+            value: function getDrawableElementsForTopAxis() {
+                var _this = this;
+                var t = [];
+                if (this.showAxisLine) {
+                    var i = this.boundingRect.y + this.boundingRect.height - this.axisConfig.axisLineWidth / 2;
+                    t.push({
+                        type: "path",
+                        groupTexts: [
+                            "top-axis",
+                            "axis-line"
+                        ],
+                        data: [
+                            {
+                                path: "M ".concat(this.boundingRect.x, ",").concat(i, " L ").concat(this.boundingRect.x + this.boundingRect.width, ",").concat(i),
+                                strokeFill: this.axisThemeConfig.axisLineColor,
+                                strokeWidth: this.axisConfig.axisLineWidth
+                            }
+                        ]
+                    });
+                }
+                if (this.showLabel && t.push({
+                    type: "text",
+                    groupTexts: [
+                        "top-axis",
+                        "label"
+                    ],
+                    data: this.getTickValues().map(function(i) {
+                        return {
+                            text: i.toString(),
+                            x: _this.getScaleValue(i),
+                            y: _this.boundingRect.y + (_this.showTitle ? _this.titleTextHeight + _this.axisConfig.titlePadding * 2 : 0) + _this.axisConfig.labelPadding,
+                            fill: _this.axisThemeConfig.labelColor,
+                            fontSize: _this.axisConfig.labelFontSize,
+                            rotation: 0,
+                            verticalPos: "top",
+                            horizontalPos: "center"
+                        };
+                    })
+                }), this.showTick) {
+                    var i1 = this.boundingRect.y;
+                    t.push({
+                        type: "path",
+                        groupTexts: [
+                            "top-axis",
+                            "ticks"
+                        ],
+                        data: this.getTickValues().map(function(s) {
+                            return {
+                                path: "M ".concat(_this.getScaleValue(s), ",").concat(i1 + _this.boundingRect.height - (_this.showAxisLine ? _this.axisConfig.axisLineWidth : 0), " L ").concat(_this.getScaleValue(s), ",").concat(i1 + _this.boundingRect.height - _this.axisConfig.tickLength - (_this.showAxisLine ? _this.axisConfig.axisLineWidth : 0)),
+                                strokeFill: _this.axisThemeConfig.tickColor,
+                                strokeWidth: _this.axisConfig.tickWidth
+                            };
+                        })
+                    });
+                }
+                return this.showTitle && t.push({
+                    type: "text",
+                    groupTexts: [
+                        "top-axis",
+                        "title"
+                    ],
+                    data: [
+                        {
+                            text: this.title,
+                            x: this.boundingRect.x + this.boundingRect.width / 2,
+                            y: this.boundingRect.y + this.axisConfig.titlePadding,
+                            fill: this.axisThemeConfig.titleColor,
+                            fontSize: this.axisConfig.titleFontSize,
+                            rotation: 0,
+                            verticalPos: "top",
+                            horizontalPos: "center"
+                        }
+                    ]
+                }), t;
+            }
+        },
+        {
+            key: "getDrawableElements",
+            value: function getDrawableElements() {
+                if (this.axisPosition === "left") return this.getDrawableElementsForLeftAxis();
+                if (this.axisPosition === "right") throw Error("Drawing of right axis is not implemented");
+                return this.axisPosition === "bottom" ? this.getDrawableElementsForBottomAxis() : this.axisPosition === "top" ? this.getDrawableElementsForTopAxis() : [];
+            }
+        }
+    ]);
+    return Rt;
+}();
+var ii = /*#__PURE__*/ function(Rt) {
+    _inherits(ii, Rt);
+    var _super = _create_super(ii);
+    function ii(t, i, s, n, o) {
+        _class_call_check(this, ii);
+        var _this;
+        _this = _super.call(this, t, n, o, i), _this.categories = s, _this.scale = st().domain(_this.categories).range(_this.getRange());
+        return _possible_constructor_return(_this);
+    }
+    _create_class(ii, [
+        {
+            key: "setRange",
+            value: function setRange(t) {
+                _get(_get_prototype_of(ii.prototype), "setRange", this).call(this, t);
+            }
+        },
+        {
+            key: "recalculateScale",
+            value: function recalculateScale() {
+                this.scale = st().domain(this.categories).range(this.getRange()).paddingInner(1).paddingOuter(0).align(0.5), L.trace("BandAxis axis final categories, range: ", this.categories, this.getRange());
+            }
+        },
+        {
+            key: "getTickValues",
+            value: function getTickValues() {
+                return this.categories;
+            }
+        },
+        {
+            key: "getScaleValue",
+            value: function getScaleValue(t) {
+                return this.scale(t) || this.getRange()[0];
+            }
+        }
+    ]);
+    return ii;
+}(Rt);
+var ei = /*#__PURE__*/ function(Rt) {
+    _inherits(ei, Rt);
+    var _super = _create_super(ei);
+    function ei(t, i, s, n, o) {
+        _class_call_check(this, ei);
+        var _this;
+        _this = _super.call(this, t, n, o, i), _this.domain = s, _this.scale = Hn().domain(_this.domain).range(_this.getRange());
+        return _possible_constructor_return(_this);
+    }
+    _create_class(ei, [
+        {
+            key: "getTickValues",
+            value: function getTickValues() {
+                return this.scale.ticks();
+            }
+        },
+        {
+            key: "recalculateScale",
+            value: function recalculateScale() {
+                var t = _to_consumable_array(this.domain);
+                this.axisPosition === "left" && t.reverse(), this.scale = Hn().domain(t).range(this.getRange());
+            }
+        },
+        {
+            key: "getScaleValue",
+            value: function getScaleValue(t) {
+                return this.scale(t);
+            }
+        }
+    ]);
+    return ei;
+}(Rt);
+function At(e, t, i, s) {
+    var n = new kt(s);
+    return _t(e) ? new ii(t, i, e.categories, e.title, n) : new ei(t, i, [
+        e.min,
+        e.max
+    ], e.title, n);
+}
+var si = /*#__PURE__*/ function() {
+    function si(t, i, s, n) {
+        _class_call_check(this, si);
+        this.textDimensionCalculator = t, this.chartConfig = i, this.chartData = s, this.chartThemeConfig = n, this.boundingRect = {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }, this.showChartTitle = !1;
+    }
+    _create_class(si, [
+        {
+            key: "setBoundingBoxXY",
+            value: function setBoundingBoxXY(t) {
+                this.boundingRect.x = t.x, this.boundingRect.y = t.y;
+            }
+        },
+        {
+            key: "calculateSpace",
+            value: function calculateSpace(t) {
+                var i = this.textDimensionCalculator.getMaxDimension([
+                    this.chartData.title
+                ], this.chartConfig.titleFontSize), s = Math.max(i.width, t.width), n = i.height + 2 * this.chartConfig.titlePadding;
+                return i.width <= s && i.height <= n && this.chartConfig.showTitle && this.chartData.title && (this.boundingRect.width = s, this.boundingRect.height = n, this.showChartTitle = !0), {
+                    width: this.boundingRect.width,
+                    height: this.boundingRect.height
+                };
+            }
+        },
+        {
+            key: "getDrawableElements",
+            value: function getDrawableElements() {
+                var t = [];
+                return this.showChartTitle && t.push({
+                    groupTexts: [
+                        "chart-title"
+                    ],
+                    type: "text",
+                    data: [
+                        {
+                            fontSize: this.chartConfig.titleFontSize,
+                            text: this.chartData.title,
+                            verticalPos: "middle",
+                            horizontalPos: "center",
+                            x: this.boundingRect.x + this.boundingRect.width / 2,
+                            y: this.boundingRect.y + this.boundingRect.height / 2,
+                            fill: this.chartThemeConfig.titleColor,
+                            rotation: 0
+                        }
+                    ]
+                }), t;
+            }
+        }
+    ]);
+    return si;
+}();
+function ni(e, t, i, s) {
+    var n = new kt(s);
+    return new si(n, e, t, i);
+}
+var ai = /*#__PURE__*/ function() {
+    function ai(t, i, s, n, o) {
+        _class_call_check(this, ai);
+        this.plotData = t, this.xAxis = i, this.yAxis = s, this.orientation = n, this.plotIndex = o;
+    }
+    _create_class(ai, [
+        {
+            key: "getDrawableElement",
+            value: function getDrawableElement() {
+                var _this = this;
+                var t = this.plotData.data.map(function(s) {
+                    return [
+                        _this.xAxis.getScaleValue(s[0]),
+                        _this.yAxis.getScaleValue(s[1])
+                    ];
+                });
+                var i;
+                return this.orientation === "horizontal" ? i = P().y(function(s) {
+                    return s[0];
+                }).x(function(s) {
+                    return s[1];
+                })(t) : i = P().x(function(s) {
+                    return s[0];
+                }).y(function(s) {
+                    return s[1];
+                })(t), i ? [
+                    {
+                        groupTexts: [
+                            "plot",
+                            "line-plot-".concat(this.plotIndex)
+                        ],
+                        type: "path",
+                        data: [
+                            {
+                                path: i,
+                                strokeFill: this.plotData.strokeFill,
+                                strokeWidth: this.plotData.strokeWidth
+                            }
+                        ]
+                    }
+                ] : [];
+            }
+        }
+    ]);
+    return ai;
+}();
+var oi = /*#__PURE__*/ function() {
+    function oi(t, i, s, n, o, c) {
+        _class_call_check(this, oi);
+        this.barData = t, this.boundingRect = i, this.xAxis = s, this.yAxis = n, this.orientation = o, this.plotIndex = c;
+    }
+    _create_class(oi, [
+        {
+            key: "getDrawableElement",
+            value: function getDrawableElement() {
+                var _this = this;
+                var t = this.barData.data.map(function(o) {
+                    return [
+                        _this.xAxis.getScaleValue(o[0]),
+                        _this.yAxis.getScaleValue(o[1])
+                    ];
+                }), i = 0.05, s = Math.min(this.xAxis.getAxisOuterPadding() * 2, this.xAxis.getTickDistance()) * (1 - i), n = s / 2;
+                return this.orientation === "horizontal" ? [
+                    {
+                        groupTexts: [
+                            "plot",
+                            "bar-plot-".concat(this.plotIndex)
+                        ],
+                        type: "rect",
+                        data: t.map(function(o) {
+                            return {
+                                x: _this.boundingRect.x,
+                                y: o[0] - n,
+                                height: s,
+                                width: o[1] - _this.boundingRect.x,
+                                fill: _this.barData.fill,
+                                strokeWidth: 0,
+                                strokeFill: _this.barData.fill
+                            };
+                        })
+                    }
+                ] : [
+                    {
+                        groupTexts: [
+                            "plot",
+                            "bar-plot-".concat(this.plotIndex)
+                        ],
+                        type: "rect",
+                        data: t.map(function(o) {
+                            return {
+                                x: o[0] - n,
+                                y: o[1],
+                                width: s,
+                                height: _this.boundingRect.y + _this.boundingRect.height - o[1],
+                                fill: _this.barData.fill,
+                                strokeWidth: 0,
+                                strokeFill: _this.barData.fill
+                            };
+                        })
+                    }
+                ];
+            }
+        }
+    ]);
+    return oi;
+}();
+var ri = /*#__PURE__*/ function() {
+    function ri(t, i, s) {
+        _class_call_check(this, ri);
+        this.chartConfig = t, this.chartData = i, this.chartThemeConfig = s, this.boundingRect = {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        };
+    }
+    _create_class(ri, [
+        {
+            key: "setAxes",
+            value: function setAxes(t, i) {
+                this.xAxis = t, this.yAxis = i;
+            }
+        },
+        {
+            key: "setBoundingBoxXY",
+            value: function setBoundingBoxXY(t) {
+                this.boundingRect.x = t.x, this.boundingRect.y = t.y;
+            }
+        },
+        {
+            key: "calculateSpace",
+            value: function calculateSpace(t) {
+                return this.boundingRect.width = t.width, this.boundingRect.height = t.height, {
+                    width: this.boundingRect.width,
+                    height: this.boundingRect.height
+                };
+            }
+        },
+        {
+            key: "getDrawableElements",
+            value: function getDrawableElements() {
+                if (!(this.xAxis && this.yAxis)) throw Error("Axes must be passed to render Plots");
+                var t = [];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this.chartData.plots.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _step_value = _sliced_to_array(_step.value, 2), i = _step_value[0], s = _step_value[1];
+                        switch(s.type){
+                            case "line":
+                                {
+                                    var _t;
+                                    var n = new ai(s, this.xAxis, this.yAxis, this.chartConfig.chartOrientation, i);
+                                    (_t = t).push.apply(_t, _to_consumable_array(n.getDrawableElement()));
+                                }
+                                break;
+                            case "bar":
+                                {
+                                    var _t1;
+                                    var n1 = new oi(s, this.boundingRect, this.xAxis, this.yAxis, this.chartConfig.chartOrientation, i);
+                                    (_t1 = t).push.apply(_t1, _to_consumable_array(n1.getDrawableElement()));
+                                }
+                                break;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return t;
+            }
+        }
+    ]);
+    return ri;
+}();
+function hi(e, t, i) {
+    return new ri(e, t, i);
+}
+var li = /*#__PURE__*/ function() {
+    function li(t, i, s, n) {
+        _class_call_check(this, li);
+        this.chartConfig = t, this.chartData = i, this.componentStore = {
+            title: ni(t, i, s, n),
+            plot: hi(t, i, s),
+            xAxis: At(i.xAxis, t.xAxis, {
+                titleColor: s.xAxisTitleColor,
+                labelColor: s.xAxisLabelColor,
+                tickColor: s.xAxisTickColor,
+                axisLineColor: s.xAxisLineColor
+            }, n),
+            yAxis: At(i.yAxis, t.yAxis, {
+                titleColor: s.yAxisTitleColor,
+                labelColor: s.yAxisLabelColor,
+                tickColor: s.yAxisTickColor,
+                axisLineColor: s.yAxisLineColor
+            }, n)
+        };
+    }
+    _create_class(li, [
+        {
+            key: "calculateVerticalSpace",
+            value: function calculateVerticalSpace() {
+                var t = this.chartConfig.width, i = this.chartConfig.height, s = 0, n = 0, o = Math.floor(t * this.chartConfig.plotReservedSpacePercent / 100), c = Math.floor(i * this.chartConfig.plotReservedSpacePercent / 100), f = this.componentStore.plot.calculateSpace({
+                    width: o,
+                    height: c
+                });
+                t -= f.width, i -= f.height, f = this.componentStore.title.calculateSpace({
+                    width: this.chartConfig.width,
+                    height: i
+                }), n = f.height, i -= f.height, this.componentStore.xAxis.setAxisPosition("bottom"), f = this.componentStore.xAxis.calculateSpace({
+                    width: t,
+                    height: i
+                }), i -= f.height, this.componentStore.yAxis.setAxisPosition("left"), f = this.componentStore.yAxis.calculateSpace({
+                    width: t,
+                    height: i
+                }), s = f.width, t -= f.width, t > 0 && (o += t, t = 0), i > 0 && (c += i, i = 0), this.componentStore.plot.calculateSpace({
+                    width: o,
+                    height: c
+                }), this.componentStore.plot.setBoundingBoxXY({
+                    x: s,
+                    y: n
+                }), this.componentStore.xAxis.setRange([
+                    s,
+                    s + o
+                ]), this.componentStore.xAxis.setBoundingBoxXY({
+                    x: s,
+                    y: n + c
+                }), this.componentStore.yAxis.setRange([
+                    n,
+                    n + c
+                ]), this.componentStore.yAxis.setBoundingBoxXY({
+                    x: 0,
+                    y: n
+                }), this.chartData.plots.some(function(d) {
+                    return mt(d);
+                }) && this.componentStore.xAxis.recalculateOuterPaddingToDrawBar();
+            }
+        },
+        {
+            key: "calculateHorizontalSpace",
+            value: function calculateHorizontalSpace() {
+                var t = this.chartConfig.width, i = this.chartConfig.height, s = 0, n = 0, o = 0, c = Math.floor(t * this.chartConfig.plotReservedSpacePercent / 100), f = Math.floor(i * this.chartConfig.plotReservedSpacePercent / 100), d = this.componentStore.plot.calculateSpace({
+                    width: c,
+                    height: f
+                });
+                t -= d.width, i -= d.height, d = this.componentStore.title.calculateSpace({
+                    width: this.chartConfig.width,
+                    height: i
+                }), s = d.height, i -= d.height, this.componentStore.xAxis.setAxisPosition("left"), d = this.componentStore.xAxis.calculateSpace({
+                    width: t,
+                    height: i
+                }), t -= d.width, n = d.width, this.componentStore.yAxis.setAxisPosition("top"), d = this.componentStore.yAxis.calculateSpace({
+                    width: t,
+                    height: i
+                }), i -= d.height, o = s + d.height, t > 0 && (c += t, t = 0), i > 0 && (f += i, i = 0), this.componentStore.plot.calculateSpace({
+                    width: c,
+                    height: f
+                }), this.componentStore.plot.setBoundingBoxXY({
+                    x: n,
+                    y: o
+                }), this.componentStore.yAxis.setRange([
+                    n,
+                    n + c
+                ]), this.componentStore.yAxis.setBoundingBoxXY({
+                    x: n,
+                    y: s
+                }), this.componentStore.xAxis.setRange([
+                    o,
+                    o + f
+                ]), this.componentStore.xAxis.setBoundingBoxXY({
+                    x: 0,
+                    y: o
+                }), this.chartData.plots.some(function(R) {
+                    return mt(R);
+                }) && this.componentStore.xAxis.recalculateOuterPaddingToDrawBar();
+            }
+        },
+        {
+            key: "calculateSpace",
+            value: function calculateSpace() {
+                this.chartConfig.chartOrientation === "horizontal" ? this.calculateHorizontalSpace() : this.calculateVerticalSpace();
+            }
+        },
+        {
+            key: "getDrawableElement",
+            value: function getDrawableElement() {
+                var _t;
+                this.calculateSpace();
+                var t = [];
+                this.componentStore.plot.setAxes(this.componentStore.xAxis, this.componentStore.yAxis);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Object.values(this.componentStore)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var i = _step.value;
+                        (_t = t).push.apply(_t, _to_consumable_array(i.getDrawableElements()));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return t;
+            }
+        }
+    ]);
+    return li;
+}();
+var ci = /*#__PURE__*/ function() {
+    function ci() {
+        _class_call_check(this, ci);
+    }
+    _create_class(ci, null, [
+        {
+            key: "build",
+            value: function build(t, i, s, n) {
+                return new li(t, i, s, n).getDrawableElement();
+            }
+        }
+    ]);
+    return ci;
+}();
+var X = 0, Tt, Y = Pt(), H = Dt(), y = Lt(), at = H.plotColorPalette.split(",").map(function(e) {
+    return e.trim();
+}), G = !1, rt = !1;
+function Dt() {
+    var e = up(), t = $t();
+    return nl(e.xyChart, t.themeVariables.xyChart);
+}
+function Pt() {
+    var e = $t();
+    return nl(yp.xyChart, e.xyChart);
+}
+function Lt() {
+    return {
+        yAxis: {
+            type: "linear",
+            title: "",
+            min: 1 / 0,
+            max: -1 / 0
+        },
+        xAxis: {
+            type: "band",
+            title: "",
+            categories: []
+        },
+        title: "",
+        plots: []
+    };
+}
+function ht(e) {
+    var t = $t();
+    return ai$1(e.trim(), t);
+}
+function ui(e) {
+    Tt = e;
+}
+function gi(e) {
+    e === "horizontal" ? Y.chartOrientation = "horizontal" : Y.chartOrientation = "vertical";
+}
+function xi(e) {
+    y.xAxis.title = ht(e.text);
+}
+function Et(e, t) {
+    y.xAxis = {
+        type: "linear",
+        title: y.xAxis.title,
+        min: e,
+        max: t
+    }, G = !0;
+}
+function di(e) {
+    y.xAxis = {
+        type: "band",
+        title: y.xAxis.title,
+        categories: e.map(function(t) {
+            return ht(t.text);
+        })
+    }, G = !0;
+}
+function fi(e) {
+    y.yAxis.title = ht(e.text);
+}
+function pi(e, t) {
+    y.yAxis = {
+        type: "linear",
+        title: y.yAxis.title,
+        min: e,
+        max: t
+    }, rt = !0;
+}
+function mi(e) {
+    var _Math, _Math1;
+    var t = (_Math = Math).min.apply(_Math, _to_consumable_array(e)), i = (_Math1 = Math).max.apply(_Math1, _to_consumable_array(e)), s = N(y.yAxis) ? y.yAxis.min : 1 / 0, n = N(y.yAxis) ? y.yAxis.max : -1 / 0;
+    y.yAxis = {
+        type: "linear",
+        title: y.yAxis.title,
+        min: Math.min(s, t),
+        max: Math.max(n, i)
+    };
+}
+function vt(e) {
+    var t = [];
+    if (e.length === 0) return t;
+    if (!G) {
+        var i = N(y.xAxis) ? y.xAxis.min : 1 / 0, s = N(y.xAxis) ? y.xAxis.max : -1 / 0;
+        Et(Math.min(i, 1), Math.max(s, e.length));
+    }
+    if (rt || mi(e), _t(y.xAxis) && (t = y.xAxis.categories.map(function(i, s) {
+        return [
+            i,
+            e[s]
+        ];
+    })), N(y.xAxis)) {
+        var i1 = y.xAxis.min, s1 = y.xAxis.max, n = (s1 - i1 + 1) / e.length, o = [];
+        for(var c = i1; c <= s1; c += n)o.push("".concat(c));
+        t = o.map(function(c, f) {
+            return [
+                c,
+                e[f]
+            ];
+        });
+    }
+    return t;
+}
+function Mt(e) {
+    return at[e === 0 ? 0 : e % at.length];
+}
+function yi(e, t) {
+    var i = vt(t);
+    y.plots.push({
+        type: "line",
+        strokeFill: Mt(X),
+        strokeWidth: 2,
+        data: i
+    }), X++;
+}
+function bi(e, t) {
+    var i = vt(t);
+    y.plots.push({
+        type: "bar",
+        fill: Mt(X),
+        data: i
+    }), X++;
+}
+function Ai() {
+    if (y.plots.length === 0) throw Error("No Plot to render, please provide a plot with some data");
+    return y.title = O_(), ci.build(Y, y, H, Tt);
+}
+function wi() {
+    return H;
+}
+function Si() {
+    return Y;
+}
+var Ci = function Ci() {
+    B_(), X = 0, Y = Pt(), y = Lt(), H = Dt(), at = H.plotColorPalette.split(",").map(function(e) {
+        return e.trim();
+    }), G = !1, rt = !1;
+}, _i = {
+    getDrawableElem: Ai,
+    clear: Ci,
+    setAccTitle: F_,
+    getAccTitle: A_,
+    setDiagramTitle: M_,
+    getDiagramTitle: O_,
+    getAccDescription: E_,
+    setAccDescription: L_,
+    setOrientation: gi,
+    setXAxisTitle: xi,
+    setXAxisRangeData: Et,
+    setXAxisBand: di,
+    setYAxisTitle: fi,
+    setYAxisRangeData: pi,
+    setLineData: yi,
+    setBarData: bi,
+    setTmpSVGG: ui,
+    getChartThemeConfig: wi,
+    getChartConfig: Si
+}, ki = function(e, t, i, s) {
+    var f = function f(p) {
+        return p === "top" ? "text-before-edge" : "middle";
+    };
+    var d = function d(p) {
+        return p === "left" ? "start" : p === "right" ? "end" : "middle";
+    };
+    var R = function R(p) {
+        return "translate(".concat(p.x, ", ").concat(p.y, ") rotate(").concat(p.rotation || 0, ")");
+    };
+    var P = function P(p) {
+        var C = A, h = "";
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = p.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 1), L = _step_value[0];
+                var z = A;
+                L > 0 && S[h] && (z = S[h]), h += p[L], C = S[h], C || (C = S[h] = z.append("g").attr("class", p[L]));
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return C;
+    };
+    var n = s.db, o = n.getChartThemeConfig(), c = n.getChartConfig();
+    L.debug("Rendering xychart chart\n" + e);
+    var _ = z_(t), A = _.append("g").attr("class", "main"), m = A.append("rect").attr("width", c.width).attr("height", c.height).attr("class", "background");
+    Ol(_, c.height, c.width, !0), _.attr("viewBox", "0 0 ".concat(c.width, " ").concat(c.height)), m.attr("fill", o.backgroundColor), n.setTmpSVGG(_.append("g").attr("class", "mermaid-tmp-group"));
+    var T = n.getDrawableElem(), S = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = T[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var p = _step.value;
+            if (p.data.length === 0) continue;
+            var C = P(p.groupTexts);
+            switch(p.type){
+                case "rect":
+                    C.selectAll("rect").data(p.data).enter().append("rect").attr("x", function(h) {
+                        return h.x;
+                    }).attr("y", function(h) {
+                        return h.y;
+                    }).attr("width", function(h) {
+                        return h.width;
+                    }).attr("height", function(h) {
+                        return h.height;
+                    }).attr("fill", function(h) {
+                        return h.fill;
+                    }).attr("stroke", function(h) {
+                        return h.strokeFill;
+                    }).attr("stroke-width", function(h) {
+                        return h.strokeWidth;
+                    });
+                    break;
+                case "text":
+                    C.selectAll("text").data(p.data).enter().append("text").attr("x", 0).attr("y", 0).attr("fill", function(h) {
+                        return h.fill;
+                    }).attr("font-size", function(h) {
+                        return h.fontSize;
+                    }).attr("dominant-baseline", function(h) {
+                        return f(h.verticalPos);
+                    }).attr("text-anchor", function(h) {
+                        return d(h.horizontalPos);
+                    }).attr("transform", function(h) {
+                        return R(h);
+                    }).text(function(h) {
+                        return h.text;
+                    });
+                    break;
+                case "path":
+                    C.selectAll("path").data(p.data).enter().append("path").attr("d", function(h) {
+                        return h.path;
+                    }).attr("fill", function(h) {
+                        return h.fill ? h.fill : "none";
+                    }).attr("stroke", function(h) {
+                        return h.strokeFill;
+                    }).attr("stroke-width", function(h) {
+                        return h.strokeWidth;
+                    });
+                    break;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}, Ri = {
+    draw: ki
+}, Vi = {
+    parser: ti,
+    db: _i,
+    renderer: Ri
+};
+
+export { Vi as diagram };