@umami/shiso 1.12.0 → 1.13.0

package/dist/chunks/xychartDiagram-S5SC5T6Z.js

@@ -0,0 +1,2698 @@
+import { n as __name } from "./chunk-Y2CYZVJY.js";
+import { m as log } from "./src.js";
+import { D as getThemeVariables3, H as setAccDescription, K as setDiagramTitle, U as setAccTitle, a as clear, b as getConfig, c as configureSvgSize, f as defaultConfig_default, v as getAccDescription, w as getDiagramTitle, y as getAccTitle, z as sanitizeText } from "./chunk-DU6HZSFF.js";
+import { t as linear } from "./linear.js";
+import { t as ordinal } from "./ordinal.js";
+import { t as initRange } from "./init.js";
+import { i as cleanAndMerge } from "./chunk-75Z2AOVW.js";
+import { t as line_default } from "./line.js";
+import "./chunk-PWAF6VOD.js";
+import { t as computeDimensionOfText } from "./chunk-GMAD6QVW.js";
+import { f as selectSvgElement } from "./mermaid.core.js";
+
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/range.js
+function range(start, stop, step) {
+	start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+	var i = -1, n = Math.max(0, Math.ceil((stop - start) / step)) | 0, range = new Array(n);
+	while (++i < n) range[i] = start + i * step;
+	return range;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/band.js
+function band() {
+	var scale = ordinal().unknown(void 0), domain = scale.domain, ordinalRange = scale.range, r0 = 0, r1 = 1, step, bandwidth, round = false, paddingInner = 0, paddingOuter = 0, align = .5;
+	delete scale.unknown;
+	function rescale() {
+		var n = domain().length, reverse = r1 < r0, start = reverse ? r1 : r0, stop = reverse ? r0 : r1;
+		step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);
+		if (round) step = Math.floor(step);
+		start += (stop - start - step * (n - paddingInner)) * align;
+		bandwidth = step * (1 - paddingInner);
+		if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);
+		var values = range(n).map(function(i) {
+			return start + step * i;
+		});
+		return ordinalRange(reverse ? values.reverse() : values);
+	}
+	scale.domain = function(_) {
+		return arguments.length ? (domain(_), rescale()) : domain();
+	};
+	scale.range = function(_) {
+		return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [r0, r1];
+	};
+	scale.rangeRound = function(_) {
+		return [r0, r1] = _, r0 = +r0, r1 = +r1, round = true, rescale();
+	};
+	scale.bandwidth = function() {
+		return bandwidth;
+	};
+	scale.step = function() {
+		return step;
+	};
+	scale.round = function(_) {
+		return arguments.length ? (round = !!_, rescale()) : round;
+	};
+	scale.padding = function(_) {
+		return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner;
+	};
+	scale.paddingInner = function(_) {
+		return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner;
+	};
+	scale.paddingOuter = function(_) {
+		return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter;
+	};
+	scale.align = function(_) {
+		return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
+	};
+	scale.copy = function() {
+		return band(domain(), [r0, r1]).round(round).paddingInner(paddingInner).paddingOuter(paddingOuter).align(align);
+	};
+	return initRange.apply(rescale(), arguments);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/xychartDiagram-S5SC5T6Z.mjs
+var parser = (function() {
+	var o = /* @__PURE__ */ __name(function(k, v, o2, l) {
+		for (o2 = o2 || {}, l = k.length; l--; o2[k[l]] = v);
+		return o2;
+	}, "o"), $V0 = [
+		1,
+		10,
+		12,
+		14,
+		16,
+		18,
+		19,
+		21,
+		23
+	], $V1 = [2, 6], $V2 = [1, 3], $V3 = [1, 5], $V4 = [1, 6], $V5 = [1, 7], $V6 = [
+		1,
+		5,
+		10,
+		12,
+		14,
+		16,
+		18,
+		19,
+		21,
+		23,
+		36,
+		37,
+		38
+	], $V7 = [1, 25], $V8 = [1, 26], $V9 = [1, 28], $Va = [1, 29], $Vb = [1, 30], $Vc = [1, 31], $Vd = [1, 32], $Ve = [1, 33], $Vf = [1, 34], $Vg = [1, 35], $Vh = [1, 36], $Vi = [1, 37], $Vj = [1, 43], $Vk = [1, 42], $Vl = [1, 47], $Vm = [1, 50], $Vn = [
+		1,
+		10,
+		12,
+		14,
+		16,
+		18,
+		19,
+		21,
+		23,
+		36,
+		37,
+		38
+	], $Vo = [
+		1,
+		10,
+		12,
+		14,
+		16,
+		18,
+		19,
+		21,
+		23,
+		24,
+		26,
+		28,
+		29,
+		36,
+		37,
+		38
+	], $Vp = [
+		1,
+		10,
+		12,
+		14,
+		16,
+		18,
+		19,
+		21,
+		23,
+		24,
+		26,
+		28,
+		29,
+		36,
+		37,
+		38,
+		42,
+		43,
+		44,
+		45,
+		46,
+		47,
+		48,
+		49,
+		50,
+		51
+	], $Vq = [1, 65], $Vr = [26, 28];
+	var parser2 = {
+		trace: /* @__PURE__ */ __name(function trace() {}, "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,
+			"dataPoints": 25,
+			"SQUARE_BRACES_END": 26,
+			"dataPoint": 27,
+			"COMMA": 28,
+			"NUMBER_WITH_DECIMAL": 29,
+			"STR": 30,
+			"xAxisData": 31,
+			"bandData": 32,
+			"ARROW_DELIMITER": 33,
+			"commaSeparatedTexts": 34,
+			"yAxisData": 35,
+			"NEWLINE": 36,
+			"SEMI": 37,
+			"EOF": 38,
+			"alphaNum": 39,
+			"MD_STR": 40,
+			"alphaNumToken": 41,
+			"AMP": 42,
+			"NUM": 43,
+			"ALPHA": 44,
+			"PLUS": 45,
+			"EQUALS": 46,
+			"MULT": 47,
+			"DOT": 48,
+			"BRKT": 49,
+			"MINUS": 50,
+			"UNDERSCORE": 51,
+			"$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",
+			28: "COMMA",
+			29: "NUMBER_WITH_DECIMAL",
+			30: "STR",
+			33: "ARROW_DELIMITER",
+			36: "NEWLINE",
+			37: "SEMI",
+			38: "EOF",
+			40: "MD_STR",
+			42: "AMP",
+			43: "NUM",
+			44: "ALPHA",
+			45: "PLUS",
+			46: "EQUALS",
+			47: "MULT",
+			48: "DOT",
+			49: "BRKT",
+			50: "MINUS",
+			51: "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],
+			[27, 2],
+			[27, 1],
+			[13, 1],
+			[13, 2],
+			[13, 1],
+			[31, 1],
+			[31, 3],
+			[32, 3],
+			[34, 3],
+			[34, 1],
+			[15, 1],
+			[15, 2],
+			[15, 1],
+			[35, 3],
+			[4, 1],
+			[4, 1],
+			[4, 1],
+			[11, 1],
+			[11, 1],
+			[11, 1],
+			[39, 1],
+			[39, 2],
+			[41, 1],
+			[41, 1],
+			[41, 1],
+			[41, 1],
+			[41, 1],
+			[41, 1],
+			[41, 1],
+			[41, 1],
+			[41, 1],
+			[41, 1]
+		],
+		performAction: /* @__PURE__ */ __name(function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+			var $0 = $$.length - 1;
+			switch (yystate) {
+				case 5:
+					yy.setOrientation($$[$0]);
+					break;
+				case 9:
+					yy.setDiagramTitle($$[$0].text.trim());
+					break;
+				case 12:
+					yy.setLineData({
+						text: "",
+						type: "text"
+					}, $$[$0]);
+					break;
+				case 13:
+					yy.setLineData($$[$0 - 1], $$[$0]);
+					break;
+				case 14:
+					yy.setBarData({
+						text: "",
+						type: "text"
+					}, $$[$0]);
+					break;
+				case 15:
+					yy.setBarData($$[$0 - 1], $$[$0]);
+					break;
+				case 16:
+					this.$ = $$[$0].trim();
+					yy.setAccTitle(this.$);
+					break;
+				case 17:
+				case 18:
+					this.$ = $$[$0].trim();
+					yy.setAccDescription(this.$);
+					break;
+				case 19:
+					this.$ = $$[$0 - 1];
+					break;
+				case 20:
+				case 30:
+					this.$ = [$$[$0 - 2], ...$$[$0]];
+					break;
+				case 21:
+				case 31:
+					this.$ = [$$[$0]];
+					break;
+				case 22:
+					this.$ = {
+						value: Number($$[$0 - 1]),
+						label: $$[$0]
+					};
+					break;
+				case 23:
+					this.$ = {
+						value: Number($$[$0]),
+						label: ""
+					};
+					break;
+				case 24:
+					yy.setXAxisTitle($$[$0]);
+					break;
+				case 25:
+					yy.setXAxisTitle($$[$0 - 1]);
+					break;
+				case 26:
+					yy.setXAxisTitle({
+						type: "text",
+						text: ""
+					});
+					break;
+				case 27:
+					yy.setXAxisBand($$[$0]);
+					break;
+				case 28:
+					yy.setXAxisRangeData(Number($$[$0 - 2]), Number($$[$0]));
+					break;
+				case 29:
+					this.$ = $$[$0 - 1];
+					break;
+				case 32:
+					yy.setYAxisTitle($$[$0]);
+					break;
+				case 33:
+					yy.setYAxisTitle($$[$0 - 1]);
+					break;
+				case 34:
+					yy.setYAxisTitle({
+						type: "text",
+						text: ""
+					});
+					break;
+				case 35:
+					yy.setYAxisRangeData(Number($$[$0 - 2]), Number($$[$0]));
+					break;
+				case 39:
+					this.$ = {
+						text: $$[$0],
+						type: "text"
+					};
+					break;
+				case 40:
+					this.$ = {
+						text: $$[$0],
+						type: "text"
+					};
+					break;
+				case 41:
+					this.$ = {
+						text: $$[$0],
+						type: "markdown"
+					};
+					break;
+				case 42:
+					this.$ = $$[$0];
+					break;
+				case 43: this.$ = $$[$0 - 1] + "" + $$[$0];
+			}
+		}, "anonymous"),
+		table: [
+			o($V0, $V1, {
+				3: 1,
+				4: 2,
+				7: 4,
+				5: $V2,
+				36: $V3,
+				37: $V4,
+				38: $V5
+			}),
+			{ 1: [3] },
+			o($V0, $V1, {
+				4: 2,
+				7: 4,
+				3: 8,
+				5: $V2,
+				36: $V3,
+				37: $V4,
+				38: $V5
+			}),
+			o($V0, $V1, {
+				4: 2,
+				7: 4,
+				6: 9,
+				3: 10,
+				5: $V2,
+				8: [1, 11],
+				36: $V3,
+				37: $V4,
+				38: $V5
+			}),
+			{
+				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]
+			},
+			o($V6, [2, 36]),
+			o($V6, [2, 37]),
+			o($V6, [2, 38]),
+			{ 1: [2, 1] },
+			o($V0, $V1, {
+				4: 2,
+				7: 4,
+				3: 21,
+				5: $V2,
+				36: $V3,
+				37: $V4,
+				38: $V5
+			}),
+			{ 1: [2, 3] },
+			o($V6, [2, 5]),
+			o($V0, [2, 7], {
+				4: 22,
+				36: $V3,
+				37: $V4,
+				38: $V5
+			}),
+			{
+				11: 23,
+				30: $V7,
+				39: 24,
+				40: $V8,
+				41: 27,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			},
+			{
+				11: 39,
+				13: 38,
+				24: $Vj,
+				29: $Vk,
+				30: $V7,
+				31: 40,
+				32: 41,
+				39: 24,
+				40: $V8,
+				41: 27,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			},
+			{
+				11: 45,
+				15: 44,
+				29: $Vl,
+				30: $V7,
+				35: 46,
+				39: 24,
+				40: $V8,
+				41: 27,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			},
+			{
+				11: 49,
+				17: 48,
+				24: $Vm,
+				30: $V7,
+				39: 24,
+				40: $V8,
+				41: 27,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			},
+			{
+				11: 52,
+				17: 51,
+				24: $Vm,
+				30: $V7,
+				39: 24,
+				40: $V8,
+				41: 27,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			},
+			{ 20: [1, 53] },
+			{ 22: [1, 54] },
+			o($Vn, [2, 18]),
+			{ 1: [2, 2] },
+			o($Vn, [2, 8]),
+			o($Vn, [2, 9]),
+			o($Vo, [2, 39], {
+				41: 55,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			}),
+			o($Vo, [2, 40]),
+			o($Vo, [2, 41]),
+			o($Vp, [2, 42]),
+			o($Vp, [2, 44]),
+			o($Vp, [2, 45]),
+			o($Vp, [2, 46]),
+			o($Vp, [2, 47]),
+			o($Vp, [2, 48]),
+			o($Vp, [2, 49]),
+			o($Vp, [2, 50]),
+			o($Vp, [2, 51]),
+			o($Vp, [2, 52]),
+			o($Vp, [2, 53]),
+			o($Vn, [2, 10]),
+			o($Vn, [2, 24], {
+				32: 41,
+				31: 56,
+				24: $Vj,
+				29: $Vk
+			}),
+			o($Vn, [2, 26]),
+			o($Vn, [2, 27]),
+			{ 33: [1, 57] },
+			{
+				11: 59,
+				30: $V7,
+				34: 58,
+				39: 24,
+				40: $V8,
+				41: 27,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			},
+			o($Vn, [2, 11]),
+			o($Vn, [2, 32], {
+				35: 60,
+				29: $Vl
+			}),
+			o($Vn, [2, 34]),
+			{ 33: [1, 61] },
+			o($Vn, [2, 12]),
+			{
+				17: 62,
+				24: $Vm
+			},
+			{
+				25: 63,
+				27: 64,
+				29: $Vq
+			},
+			o($Vn, [2, 14]),
+			{
+				17: 66,
+				24: $Vm
+			},
+			o($Vn, [2, 16]),
+			o($Vn, [2, 17]),
+			o($Vp, [2, 43]),
+			o($Vn, [2, 25]),
+			{ 29: [1, 67] },
+			{ 26: [1, 68] },
+			{
+				26: [2, 31],
+				28: [1, 69]
+			},
+			o($Vn, [2, 33]),
+			{ 29: [1, 70] },
+			o($Vn, [2, 13]),
+			{ 26: [1, 71] },
+			{
+				26: [2, 21],
+				28: [1, 72]
+			},
+			o($Vr, [2, 23], { 30: [1, 73] }),
+			o($Vn, [2, 15]),
+			o($Vn, [2, 28]),
+			o($Vn, [2, 29]),
+			{
+				11: 59,
+				30: $V7,
+				34: 74,
+				39: 24,
+				40: $V8,
+				41: 27,
+				42: $V9,
+				43: $Va,
+				44: $Vb,
+				45: $Vc,
+				46: $Vd,
+				47: $Ve,
+				48: $Vf,
+				49: $Vg,
+				50: $Vh,
+				51: $Vi
+			},
+			o($Vn, [2, 35]),
+			o($Vn, [2, 19]),
+			{
+				25: 75,
+				27: 64,
+				29: $Vq
+			},
+			o($Vr, [2, 22]),
+			{ 26: [2, 30] },
+			{ 26: [2, 20] }
+		],
+		defaultActions: {
+			8: [2, 1],
+			10: [2, 3],
+			21: [2, 2],
+			74: [2, 30],
+			75: [2, 20]
+		},
+		parseError: /* @__PURE__ */ __name(function parseError(str, hash) {
+			if (hash.recoverable) this.trace(str);
+			else {
+				var error = new Error(str);
+				error.hash = hash;
+				throw error;
+			}
+		}, "parseError"),
+		parse: /* @__PURE__ */ __name(function parse(input) {
+			var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+			var args = lstack.slice.call(arguments, 1);
+			var lexer2 = Object.create(this.lexer);
+			var sharedState = { yy: {} };
+			for (var k in this.yy) if (Object.prototype.hasOwnProperty.call(this.yy, k)) sharedState.yy[k] = this.yy[k];
+			lexer2.setInput(input, sharedState.yy);
+			sharedState.yy.lexer = lexer2;
+			sharedState.yy.parser = this;
+			if (typeof lexer2.yylloc == "undefined") lexer2.yylloc = {};
+			var yyloc = lexer2.yylloc;
+			lstack.push(yyloc);
+			var ranges = lexer2.options && lexer2.options.ranges;
+			if (typeof sharedState.yy.parseError === "function") this.parseError = sharedState.yy.parseError;
+			else this.parseError = Object.getPrototypeOf(this).parseError;
+			function popStack(n) {
+				stack.length = stack.length - 2 * n;
+				vstack.length = vstack.length - n;
+				lstack.length = lstack.length - n;
+			}
+			__name(popStack, "popStack");
+			function lex() {
+				var token = tstack.pop() || lexer2.lex() || EOF;
+				if (typeof token !== "number") {
+					if (token instanceof Array) {
+						tstack = token;
+						token = tstack.pop();
+					}
+					token = self.symbols_[token] || token;
+				}
+				return token;
+			}
+			__name(lex, "lex");
+			var symbol, preErrorSymbol, state, action, r, yyval = {}, p, len, newState, expected;
+			while (true) {
+				state = stack[stack.length - 1];
+				if (this.defaultActions[state]) action = this.defaultActions[state];
+				else {
+					if (symbol === null || typeof symbol == "undefined") symbol = lex();
+					action = table[state] && table[state][symbol];
+				}
+				if (typeof action === "undefined" || !action.length || !action[0]) {
+					var errStr = "";
+					expected = [];
+					for (p in table[state]) if (this.terminals_[p] && p > TERROR) expected.push("'" + this.terminals_[p] + "'");
+					if (lexer2.showPosition) errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer2.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
+					else errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
+					this.parseError(errStr, {
+						text: lexer2.match,
+						token: this.terminals_[symbol] || symbol,
+						line: lexer2.yylineno,
+						loc: yyloc,
+						expected
+					});
+				}
+				if (action[0] instanceof Array && action.length > 1) throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
+				switch (action[0]) {
+					case 1:
+						stack.push(symbol);
+						vstack.push(lexer2.yytext);
+						lstack.push(lexer2.yylloc);
+						stack.push(action[1]);
+						symbol = null;
+						if (!preErrorSymbol) {
+							yyleng = lexer2.yyleng;
+							yytext = lexer2.yytext;
+							yylineno = lexer2.yylineno;
+							yyloc = lexer2.yylloc;
+							if (recovering > 0) recovering--;
+						} else {
+							symbol = preErrorSymbol;
+							preErrorSymbol = null;
+						}
+						break;
+					case 2:
+						len = this.productions_[action[1]][1];
+						yyval.$ = vstack[vstack.length - len];
+						yyval._$ = {
+							first_line: lstack[lstack.length - (len || 1)].first_line,
+							last_line: lstack[lstack.length - 1].last_line,
+							first_column: lstack[lstack.length - (len || 1)].first_column,
+							last_column: lstack[lstack.length - 1].last_column
+						};
+						if (ranges) yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
+						r = this.performAction.apply(yyval, [
+							yytext,
+							yyleng,
+							yylineno,
+							sharedState.yy,
+							action[1],
+							vstack,
+							lstack
+						].concat(args));
+						if (typeof r !== "undefined") return r;
+						if (len) {
+							stack = stack.slice(0, -1 * len * 2);
+							vstack = vstack.slice(0, -1 * len);
+							lstack = lstack.slice(0, -1 * len);
+						}
+						stack.push(this.productions_[action[1]][0]);
+						vstack.push(yyval.$);
+						lstack.push(yyval._$);
+						newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+						stack.push(newState);
+						break;
+					case 3: return true;
+				}
+			}
+			return true;
+		}, "parse")
+	};
+	parser2.lexer = /* @__PURE__ */ (function() {
+		return {
+			EOF: 1,
+			parseError: /* @__PURE__ */ __name(function parseError(str, hash) {
+				if (this.yy.parser) this.yy.parser.parseError(str, hash);
+				else throw new Error(str);
+			}, "parseError"),
+			setInput: /* @__PURE__ */ __name(function(input, yy) {
+				this.yy = yy || this.yy || {};
+				this._input = input;
+				this._more = this._backtrack = this.done = false;
+				this.yylineno = this.yyleng = 0;
+				this.yytext = this.matched = this.match = "";
+				this.conditionStack = ["INITIAL"];
+				this.yylloc = {
+					first_line: 1,
+					first_column: 0,
+					last_line: 1,
+					last_column: 0
+				};
+				if (this.options.ranges) this.yylloc.range = [0, 0];
+				this.offset = 0;
+				return this;
+			}, "setInput"),
+			input: /* @__PURE__ */ __name(function() {
+				var ch = this._input[0];
+				this.yytext += ch;
+				this.yyleng++;
+				this.offset++;
+				this.match += ch;
+				this.matched += ch;
+				if (ch.match(/(?:\r\n?|\n).*/g)) {
+					this.yylineno++;
+					this.yylloc.last_line++;
+				} else this.yylloc.last_column++;
+				if (this.options.ranges) this.yylloc.range[1]++;
+				this._input = this._input.slice(1);
+				return ch;
+			}, "input"),
+			unput: /* @__PURE__ */ __name(function(ch) {
+				var len = ch.length;
+				var lines = ch.split(/(?:\r\n?|\n)/g);
+				this._input = ch + this._input;
+				this.yytext = this.yytext.substr(0, this.yytext.length - len);
+				this.offset -= len;
+				var oldLines = 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);
+				if (lines.length - 1) this.yylineno -= lines.length - 1;
+				var r = this.yylloc.range;
+				this.yylloc = {
+					first_line: this.yylloc.first_line,
+					last_line: this.yylineno + 1,
+					first_column: this.yylloc.first_column,
+					last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
+				};
+				if (this.options.ranges) this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+				this.yyleng = this.yytext.length;
+				return this;
+			}, "unput"),
+			more: /* @__PURE__ */ __name(function() {
+				this._more = true;
+				return this;
+			}, "more"),
+			reject: /* @__PURE__ */ __name(function() {
+				if (this.options.backtrack_lexer) this._backtrack = true;
+				else return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), {
+					text: "",
+					token: null,
+					line: this.yylineno
+				});
+				return this;
+			}, "reject"),
+			less: /* @__PURE__ */ __name(function(n) {
+				this.unput(this.match.slice(n));
+			}, "less"),
+			pastInput: /* @__PURE__ */ __name(function() {
+				var past = this.matched.substr(0, this.matched.length - this.match.length);
+				return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
+			}, "pastInput"),
+			upcomingInput: /* @__PURE__ */ __name(function() {
+				var next = this.match;
+				if (next.length < 20) next += this._input.substr(0, 20 - next.length);
+				return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
+			}, "upcomingInput"),
+			showPosition: /* @__PURE__ */ __name(function() {
+				var pre = this.pastInput();
+				var c = new Array(pre.length + 1).join("-");
+				return pre + this.upcomingInput() + "\n" + c + "^";
+			}, "showPosition"),
+			test_match: /* @__PURE__ */ __name(function(match, indexed_rule) {
+				var token, lines, backup;
+				if (this.options.backtrack_lexer) {
+					backup = {
+						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
+					};
+					if (this.options.ranges) backup.yylloc.range = this.yylloc.range.slice(0);
+				}
+				lines = match[0].match(/(?:\r\n?|\n).*/g);
+				if (lines) this.yylineno += lines.length;
+				this.yylloc = {
+					first_line: this.yylloc.last_line,
+					last_line: this.yylineno + 1,
+					first_column: this.yylloc.last_column,
+					last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
+				};
+				this.yytext += match[0];
+				this.match += match[0];
+				this.matches = match;
+				this.yyleng = this.yytext.length;
+				if (this.options.ranges) this.yylloc.range = [this.offset, this.offset += this.yyleng];
+				this._more = false;
+				this._backtrack = false;
+				this._input = this._input.slice(match[0].length);
+				this.matched += match[0];
+				token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
+				if (this.done && this._input) this.done = false;
+				if (token) return token;
+				else if (this._backtrack) {
+					for (var k in backup) this[k] = backup[k];
+					return false;
+				}
+				return false;
+			}, "test_match"),
+			next: /* @__PURE__ */ __name(function() {
+				if (this.done) return this.EOF;
+				if (!this._input) this.done = true;
+				var token, match, tempMatch, index;
+				if (!this._more) {
+					this.yytext = "";
+					this.match = "";
+				}
+				var rules = this._currentRules();
+				for (var i = 0; i < rules.length; i++) {
+					tempMatch = this._input.match(this.rules[rules[i]]);
+					if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+						match = tempMatch;
+						index = i;
+						if (this.options.backtrack_lexer) {
+							token = this.test_match(tempMatch, rules[i]);
+							if (token !== false) return token;
+							else if (this._backtrack) {
+								match = false;
+								continue;
+							} else return false;
+						} else if (!this.options.flex) break;
+					}
+				}
+				if (match) {
+					token = this.test_match(match, rules[index]);
+					if (token !== false) return token;
+					return false;
+				}
+				if (this._input === "") return this.EOF;
+				else return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
+					text: "",
+					token: null,
+					line: this.yylineno
+				});
+			}, "next"),
+			lex: /* @__PURE__ */ __name(function lex() {
+				var r = this.next();
+				if (r) return r;
+				else return this.lex();
+			}, "lex"),
+			begin: /* @__PURE__ */ __name(function begin(condition) {
+				this.conditionStack.push(condition);
+			}, "begin"),
+			popState: /* @__PURE__ */ __name(function popState() {
+				if (this.conditionStack.length - 1 > 0) return this.conditionStack.pop();
+				else return this.conditionStack[0];
+			}, "popState"),
+			_currentRules: /* @__PURE__ */ __name(function _currentRules() {
+				if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+				else return this.conditions["INITIAL"].rules;
+			}, "_currentRules"),
+			topState: /* @__PURE__ */ __name(function topState(n) {
+				n = this.conditionStack.length - 1 - Math.abs(n || 0);
+				if (n >= 0) return this.conditionStack[n];
+				else return "INITIAL";
+			}, "topState"),
+			pushState: /* @__PURE__ */ __name(function pushState(condition) {
+				this.begin(condition);
+			}, "pushState"),
+			stateStackSize: /* @__PURE__ */ __name(function stateStackSize() {
+				return this.conditionStack.length;
+			}, "stateStackSize"),
+			options: { "case-insensitive": true },
+			performAction: /* @__PURE__ */ __name(function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
+				switch ($avoiding_name_collisions) {
+					case 0: break;
+					case 1: break;
+					case 2:
+						this.popState();
+						return 36;
+					case 3:
+						this.popState();
+						return 36;
+					case 4: return 36;
+					case 5: break;
+					case 6: return 10;
+					case 7:
+						this.pushState("acc_title");
+						return 19;
+					case 8:
+						this.popState();
+						return "acc_title_value";
+					case 9:
+						this.pushState("acc_descr");
+						return 21;
+					case 10:
+						this.popState();
+						return "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 5;
+					case 16: return 8;
+					case 17:
+						this.pushState("axis_data");
+						return "X_AXIS";
+					case 18:
+						this.pushState("axis_data");
+						return "Y_AXIS";
+					case 19:
+						this.pushState("axis_band_data");
+						return 24;
+					case 20: return 33;
+					case 21:
+						this.pushState("data");
+						return 16;
+					case 22:
+						this.pushState("data");
+						return 18;
+					case 23:
+						this.pushState("data_inner");
+						return 24;
+					case 24: return 29;
+					case 25:
+						this.popState();
+						return 26;
+					case 26:
+						this.popState();
+						break;
+					case 27:
+						this.pushState("string");
+						break;
+					case 28:
+						this.popState();
+						break;
+					case 29: return "STR";
+					case 30: return 24;
+					case 31: return 26;
+					case 32: return 44;
+					case 33: return "COLON";
+					case 34: return 45;
+					case 35: return 28;
+					case 36: return 46;
+					case 37: return 47;
+					case 38: return 49;
+					case 39: return 51;
+					case 40: return 48;
+					case 41: return 42;
+					case 42: return 50;
+					case 43: return 43;
+					case 44: break;
+					case 45: return 37;
+					case 46: return 38;
+				}
+			}, "anonymous"),
+			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,
+				/^(?:xychart\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,
+						18,
+						21,
+						22,
+						24,
+						25,
+						26,
+						27,
+						30,
+						31,
+						32,
+						33,
+						34,
+						35,
+						36,
+						37,
+						38,
+						39,
+						40,
+						41,
+						42,
+						43,
+						44,
+						45,
+						46
+					],
+					"inclusive": true
+				},
+				"data": {
+					"rules": [
+						0,
+						1,
+						3,
+						4,
+						5,
+						6,
+						7,
+						9,
+						11,
+						14,
+						15,
+						16,
+						17,
+						18,
+						21,
+						22,
+						23,
+						26,
+						27,
+						30,
+						31,
+						32,
+						33,
+						34,
+						35,
+						36,
+						37,
+						38,
+						39,
+						40,
+						41,
+						42,
+						43,
+						44,
+						45,
+						46
+					],
+					"inclusive": true
+				},
+				"axis_band_data": {
+					"rules": [
+						0,
+						1,
+						4,
+						5,
+						6,
+						7,
+						9,
+						11,
+						14,
+						15,
+						16,
+						17,
+						18,
+						21,
+						22,
+						25,
+						26,
+						27,
+						30,
+						31,
+						32,
+						33,
+						34,
+						35,
+						36,
+						37,
+						38,
+						39,
+						40,
+						41,
+						42,
+						43,
+						44,
+						45,
+						46
+					],
+					"inclusive": true
+				},
+				"axis_data": {
+					"rules": [
+						0,
+						1,
+						2,
+						4,
+						5,
+						6,
+						7,
+						9,
+						11,
+						14,
+						15,
+						16,
+						17,
+						18,
+						19,
+						20,
+						21,
+						22,
+						24,
+						26,
+						27,
+						30,
+						31,
+						32,
+						33,
+						34,
+						35,
+						36,
+						37,
+						38,
+						39,
+						40,
+						41,
+						42,
+						43,
+						44,
+						45,
+						46
+					],
+					"inclusive": true
+				},
+				"acc_descr_multiline": {
+					"rules": [12, 13],
+					"inclusive": false
+				},
+				"acc_descr": {
+					"rules": [10],
+					"inclusive": false
+				},
+				"acc_title": {
+					"rules": [8],
+					"inclusive": false
+				},
+				"title": {
+					"rules": [],
+					"inclusive": false
+				},
+				"md_string": {
+					"rules": [],
+					"inclusive": false
+				},
+				"string": {
+					"rules": [28, 29],
+					"inclusive": false
+				},
+				"INITIAL": {
+					"rules": [
+						0,
+						1,
+						4,
+						5,
+						6,
+						7,
+						9,
+						11,
+						14,
+						15,
+						16,
+						17,
+						18,
+						21,
+						22,
+						26,
+						27,
+						30,
+						31,
+						32,
+						33,
+						34,
+						35,
+						36,
+						37,
+						38,
+						39,
+						40,
+						41,
+						42,
+						43,
+						44,
+						45,
+						46
+					],
+					"inclusive": true
+				}
+			}
+		};
+	})();
+	function Parser() {
+		this.yy = {};
+	}
+	__name(Parser, "Parser");
+	Parser.prototype = parser2;
+	parser2.Parser = Parser;
+	return new Parser();
+})();
+parser.parser = parser;
+var xychart_default = parser;
+function isBarPlot(data) {
+	return data.type === "bar";
+}
+__name(isBarPlot, "isBarPlot");
+function isBandAxisData(data) {
+	return data.type === "band";
+}
+__name(isBandAxisData, "isBandAxisData");
+function isLinearAxisData(data) {
+	return data.type === "linear";
+}
+__name(isLinearAxisData, "isLinearAxisData");
+var TextDimensionCalculatorWithFont = class {
+	constructor(parentGroup) {
+		this.parentGroup = parentGroup;
+	}
+	static {
+		__name(this, "TextDimensionCalculatorWithFont");
+	}
+	getMaxDimension(texts, fontSize) {
+		if (!this.parentGroup) return {
+			width: texts.reduce((acc, cur) => Math.max(cur.length, acc), 0) * fontSize,
+			height: fontSize
+		};
+		const dimension = {
+			width: 0,
+			height: 0
+		};
+		const elem = this.parentGroup.append("g").attr("visibility", "hidden").attr("font-size", fontSize);
+		for (const t of texts) {
+			const bbox = computeDimensionOfText(elem, 1, t);
+			const width = bbox ? bbox.width : t.length * fontSize;
+			const height = bbox ? bbox.height : fontSize;
+			dimension.width = Math.max(dimension.width, width);
+			dimension.height = Math.max(dimension.height, height);
+		}
+		elem.remove();
+		return dimension;
+	}
+};
+var BAR_WIDTH_TO_TICK_WIDTH_RATIO = .7;
+var MAX_OUTER_PADDING_PERCENT_FOR_WRT_LABEL = .2;
+var BaseAxis = class {
+	constructor(axisConfig, title, textDimensionCalculator, axisThemeConfig) {
+		this.axisConfig = axisConfig;
+		this.title = title;
+		this.textDimensionCalculator = textDimensionCalculator;
+		this.axisThemeConfig = axisThemeConfig;
+		this.boundingRect = {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		};
+		this.axisPosition = "left";
+		this.showTitle = false;
+		this.showLabel = false;
+		this.showTick = false;
+		this.showAxisLine = false;
+		this.outerPadding = 0;
+		this.titleTextHeight = 0;
+		this.labelTextHeight = 0;
+		this.normalizedLabelRotationInRad = 0;
+		this.range = [0, 10];
+		this.boundingRect = {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		};
+		this.axisPosition = "left";
+		this.normalizedLabelRotationInRad = this.axisConfig.labelRotation >= -90 && this.axisConfig.labelRotation <= 90 ? this.axisConfig.labelRotation * Math.PI / 180 : 0;
+	}
+	static {
+		__name(this, "BaseAxis");
+	}
+	setRange(range) {
+		this.range = range;
+		if (this.axisPosition === "left" || this.axisPosition === "right") this.boundingRect.height = range[1] - range[0];
+		else this.boundingRect.width = range[1] - range[0];
+		this.recalculateScale();
+	}
+	getRange() {
+		return [this.range[0] + this.outerPadding, this.range[1] - this.outerPadding];
+	}
+	setAxisPosition(axisPosition) {
+		this.axisPosition = axisPosition;
+		this.setRange(this.range);
+	}
+	getTickDistance() {
+		const range = this.getRange();
+		return Math.abs(range[0] - range[1]) / this.getTickValues().length;
+	}
+	getAxisOuterPadding() {
+		return this.outerPadding;
+	}
+	getLabelDimension() {
+		return this.textDimensionCalculator.getMaxDimension(this.getTickValues().map((tick) => tick.toString()), this.axisConfig.labelFontSize);
+	}
+	recalculateOuterPaddingToDrawBar() {
+		if (BAR_WIDTH_TO_TICK_WIDTH_RATIO * this.getTickDistance() > this.outerPadding * 2) this.outerPadding = Math.floor(BAR_WIDTH_TO_TICK_WIDTH_RATIO * this.getTickDistance() / 2);
+		this.recalculateScale();
+	}
+	calculateSpaceIfDrawnHorizontally(availableSpace) {
+		let availableHeight = availableSpace.height;
+		if (this.axisConfig.showAxisLine && availableHeight > this.axisConfig.axisLineWidth) {
+			availableHeight -= this.axisConfig.axisLineWidth;
+			this.showAxisLine = true;
+		}
+		if (this.axisConfig.showLabel) {
+			const spaceRequired = this.getLabelDimension();
+			const maxPadding = MAX_OUTER_PADDING_PERCENT_FOR_WRT_LABEL * availableSpace.width;
+			this.outerPadding = Math.min(spaceRequired.width / 2, maxPadding);
+			let heightRequired = spaceRequired.height;
+			if (this.axisPosition === "bottom" && this.normalizedLabelRotationInRad !== 0) heightRequired = Math.max(heightRequired, Math.abs(Math.sin(this.normalizedLabelRotationInRad) * spaceRequired.width) + Math.abs(Math.cos(this.normalizedLabelRotationInRad) * spaceRequired.height));
+			heightRequired += this.axisConfig.labelPadding * 2;
+			this.labelTextHeight = spaceRequired.height;
+			if (heightRequired <= availableHeight) {
+				availableHeight -= heightRequired;
+				this.showLabel = true;
+			}
+		}
+		if (this.axisConfig.showTick && availableHeight >= this.axisConfig.tickLength) {
+			this.showTick = true;
+			availableHeight -= this.axisConfig.tickLength;
+		}
+		if (this.axisConfig.showTitle && this.title) {
+			const spaceRequired = this.textDimensionCalculator.getMaxDimension([this.title], this.axisConfig.titleFontSize);
+			const heightRequired = spaceRequired.height + this.axisConfig.titlePadding * 2;
+			this.titleTextHeight = spaceRequired.height;
+			if (heightRequired <= availableHeight) {
+				availableHeight -= heightRequired;
+				this.showTitle = true;
+			}
+		}
+		this.boundingRect.width = availableSpace.width;
+		this.boundingRect.height = availableSpace.height - availableHeight;
+	}
+	calculateSpaceIfDrawnVertical(availableSpace) {
+		let availableWidth = availableSpace.width;
+		if (this.axisConfig.showAxisLine && availableWidth > this.axisConfig.axisLineWidth) {
+			availableWidth -= this.axisConfig.axisLineWidth;
+			this.showAxisLine = true;
+		}
+		if (this.axisConfig.showLabel) {
+			const spaceRequired = this.getLabelDimension();
+			const maxPadding = MAX_OUTER_PADDING_PERCENT_FOR_WRT_LABEL * availableSpace.height;
+			this.outerPadding = Math.min(spaceRequired.height / 2, maxPadding);
+			const widthRequired = spaceRequired.width + this.axisConfig.labelPadding * 2;
+			if (widthRequired <= availableWidth) {
+				availableWidth -= widthRequired;
+				this.showLabel = true;
+			}
+		}
+		if (this.axisConfig.showTick && availableWidth >= this.axisConfig.tickLength) {
+			this.showTick = true;
+			availableWidth -= this.axisConfig.tickLength;
+		}
+		if (this.axisConfig.showTitle && this.title) {
+			const spaceRequired = this.textDimensionCalculator.getMaxDimension([this.title], this.axisConfig.titleFontSize);
+			const widthRequired = spaceRequired.height + this.axisConfig.titlePadding * 2;
+			this.titleTextHeight = spaceRequired.height;
+			if (widthRequired <= availableWidth) {
+				availableWidth -= widthRequired;
+				this.showTitle = true;
+			}
+		}
+		this.boundingRect.width = availableSpace.width - availableWidth;
+		this.boundingRect.height = availableSpace.height;
+	}
+	calculateSpace(availableSpace) {
+		if (this.axisPosition === "left" || this.axisPosition === "right") this.calculateSpaceIfDrawnVertical(availableSpace);
+		else this.calculateSpaceIfDrawnHorizontally(availableSpace);
+		this.recalculateScale();
+		return {
+			width: this.boundingRect.width,
+			height: this.boundingRect.height
+		};
+	}
+	setBoundingBoxXY(point) {
+		this.boundingRect.x = point.x;
+		this.boundingRect.y = point.y;
+	}
+	calculateOffsetByRotation(reference) {
+		const rotation = this.normalizedLabelRotationInRad;
+		if (rotation === 0) return 0;
+		return Math.sin(rotation) * this.getLabelDimension()[reference] / 2;
+	}
+	getDrawableElementsForLeftAxis() {
+		const drawableElement = [];
+		if (this.showAxisLine) {
+			const x = this.boundingRect.x + this.boundingRect.width - this.axisConfig.axisLineWidth / 2;
+			drawableElement.push({
+				type: "path",
+				groupTexts: ["left-axis", "axisl-line"],
+				data: [{
+					path: `M ${x},${this.boundingRect.y} L ${x},${this.boundingRect.y + this.boundingRect.height} `,
+					strokeFill: this.axisThemeConfig.axisLineColor,
+					strokeWidth: this.axisConfig.axisLineWidth
+				}]
+			});
+		}
+		if (this.showLabel) drawableElement.push({
+			type: "text",
+			groupTexts: ["left-axis", "label"],
+			data: this.getTickValues().map((tick) => ({
+				text: tick.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(tick),
+				fill: this.axisThemeConfig.labelColor,
+				fontSize: this.axisConfig.labelFontSize,
+				rotation: 0,
+				verticalPos: "middle",
+				horizontalPos: "right"
+			}))
+		});
+		if (this.showTick) {
+			const x = this.boundingRect.x + this.boundingRect.width - (this.showAxisLine ? this.axisConfig.axisLineWidth : 0);
+			drawableElement.push({
+				type: "path",
+				groupTexts: ["left-axis", "ticks"],
+				data: this.getTickValues().map((tick) => ({
+					path: `M ${x},${this.getScaleValue(tick)} L ${x - this.axisConfig.tickLength},${this.getScaleValue(tick)}`,
+					strokeFill: this.axisThemeConfig.tickColor,
+					strokeWidth: this.axisConfig.tickWidth
+				}))
+			});
+		}
+		if (this.showTitle) drawableElement.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"
+			}]
+		});
+		return drawableElement;
+	}
+	getDrawableElementsForBottomAxis() {
+		const drawableElement = [];
+		if (this.showAxisLine) {
+			const y = this.boundingRect.y + this.axisConfig.axisLineWidth / 2;
+			drawableElement.push({
+				type: "path",
+				groupTexts: ["bottom-axis", "axis-line"],
+				data: [{
+					path: `M ${this.boundingRect.x},${y} L ${this.boundingRect.x + this.boundingRect.width},${y}`,
+					strokeFill: this.axisThemeConfig.axisLineColor,
+					strokeWidth: this.axisConfig.axisLineWidth
+				}]
+			});
+		}
+		if (this.showLabel) drawableElement.push({
+			type: "text",
+			groupTexts: ["bottom-axis", "label"],
+			data: this.getTickValues().map((tick) => ({
+				text: tick.toString(),
+				x: this.getScaleValue(tick) + this.calculateOffsetByRotation("height"),
+				y: this.boundingRect.y + this.axisConfig.labelPadding + (this.showTick ? this.axisConfig.tickLength : 0) + (this.showAxisLine ? this.axisConfig.axisLineWidth : 0) + Math.abs(this.calculateOffsetByRotation("width")),
+				fill: this.axisThemeConfig.labelColor,
+				fontSize: this.axisConfig.labelFontSize,
+				rotation: this.normalizedLabelRotationInRad * 180 / Math.PI,
+				verticalPos: "top",
+				horizontalPos: "center"
+			}))
+		});
+		if (this.showTick) {
+			const y = this.boundingRect.y + (this.showAxisLine ? this.axisConfig.axisLineWidth : 0);
+			drawableElement.push({
+				type: "path",
+				groupTexts: ["bottom-axis", "ticks"],
+				data: this.getTickValues().map((tick) => ({
+					path: `M ${this.getScaleValue(tick)},${y} L ${this.getScaleValue(tick)},${y + this.axisConfig.tickLength}`,
+					strokeFill: this.axisThemeConfig.tickColor,
+					strokeWidth: this.axisConfig.tickWidth
+				}))
+			});
+		}
+		if (this.showTitle) drawableElement.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"
+			}]
+		});
+		return drawableElement;
+	}
+	getDrawableElementsForTopAxis() {
+		const drawableElement = [];
+		if (this.showAxisLine) {
+			const y = this.boundingRect.y + this.boundingRect.height - this.axisConfig.axisLineWidth / 2;
+			drawableElement.push({
+				type: "path",
+				groupTexts: ["top-axis", "axis-line"],
+				data: [{
+					path: `M ${this.boundingRect.x},${y} L ${this.boundingRect.x + this.boundingRect.width},${y}`,
+					strokeFill: this.axisThemeConfig.axisLineColor,
+					strokeWidth: this.axisConfig.axisLineWidth
+				}]
+			});
+		}
+		if (this.showLabel) drawableElement.push({
+			type: "text",
+			groupTexts: ["top-axis", "label"],
+			data: this.getTickValues().map((tick) => ({
+				text: tick.toString(),
+				x: this.getScaleValue(tick),
+				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"
+			}))
+		});
+		if (this.showTick) {
+			const y = this.boundingRect.y;
+			drawableElement.push({
+				type: "path",
+				groupTexts: ["top-axis", "ticks"],
+				data: this.getTickValues().map((tick) => ({
+					path: `M ${this.getScaleValue(tick)},${y + this.boundingRect.height - (this.showAxisLine ? this.axisConfig.axisLineWidth : 0)} L ${this.getScaleValue(tick)},${y + this.boundingRect.height - this.axisConfig.tickLength - (this.showAxisLine ? this.axisConfig.axisLineWidth : 0)}`,
+					strokeFill: this.axisThemeConfig.tickColor,
+					strokeWidth: this.axisConfig.tickWidth
+				}))
+			});
+		}
+		if (this.showTitle) drawableElement.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"
+			}]
+		});
+		return drawableElement;
+	}
+	getDrawableElements() {
+		if (this.axisPosition === "left") return this.getDrawableElementsForLeftAxis();
+		if (this.axisPosition === "right") throw Error("Drawing of right axis is not implemented");
+		if (this.axisPosition === "bottom") return this.getDrawableElementsForBottomAxis();
+		if (this.axisPosition === "top") return this.getDrawableElementsForTopAxis();
+		return [];
+	}
+};
+var BandAxis = class extends BaseAxis {
+	static {
+		__name(this, "BandAxis");
+	}
+	constructor(axisConfig, axisThemeConfig, categories, title, textDimensionCalculator) {
+		super(axisConfig, title, textDimensionCalculator, axisThemeConfig);
+		this.categories = categories;
+		this.scale = band().domain(this.categories).range(this.getRange());
+	}
+	setRange(range) {
+		super.setRange(range);
+	}
+	recalculateScale() {
+		this.scale = band().domain(this.categories).range(this.getRange()).paddingInner(1).paddingOuter(0).align(.5);
+		log.trace("BandAxis axis final categories, range: ", this.categories, this.getRange());
+	}
+	getTickValues() {
+		return this.categories;
+	}
+	getScaleValue(value) {
+		return this.scale(value) ?? this.getRange()[0];
+	}
+};
+var LinearAxis = class extends BaseAxis {
+	static {
+		__name(this, "LinearAxis");
+	}
+	constructor(axisConfig, axisThemeConfig, domain, title, textDimensionCalculator) {
+		super(axisConfig, title, textDimensionCalculator, axisThemeConfig);
+		this.domain = domain;
+		this.scale = linear().domain(this.domain).range(this.getRange());
+	}
+	getTickValues() {
+		return this.scale.ticks();
+	}
+	recalculateScale() {
+		const domain = [...this.domain];
+		if (this.axisPosition === "left") domain.reverse();
+		this.scale = linear().domain(domain).range(this.getRange());
+	}
+	getScaleValue(value) {
+		return this.scale(value);
+	}
+};
+function getAxis(data, axisConfig, axisThemeConfig, tmpSVGGroup2) {
+	const textDimensionCalculator = new TextDimensionCalculatorWithFont(tmpSVGGroup2);
+	if (isBandAxisData(data)) return new BandAxis(axisConfig, axisThemeConfig, data.categories, data.title, textDimensionCalculator);
+	return new LinearAxis(axisConfig, axisThemeConfig, [data.min, data.max], data.title, textDimensionCalculator);
+}
+__name(getAxis, "getAxis");
+var ChartTitle = class {
+	constructor(textDimensionCalculator, chartConfig, chartData, chartThemeConfig) {
+		this.textDimensionCalculator = textDimensionCalculator;
+		this.chartConfig = chartConfig;
+		this.chartData = chartData;
+		this.chartThemeConfig = chartThemeConfig;
+		this.boundingRect = {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		};
+		this.showChartTitle = false;
+	}
+	static {
+		__name(this, "ChartTitle");
+	}
+	setBoundingBoxXY(point) {
+		this.boundingRect.x = point.x;
+		this.boundingRect.y = point.y;
+	}
+	calculateSpace(availableSpace) {
+		const titleDimension = this.textDimensionCalculator.getMaxDimension([this.chartData.title], this.chartConfig.titleFontSize);
+		const widthRequired = Math.max(titleDimension.width, availableSpace.width);
+		const heightRequired = titleDimension.height + 2 * this.chartConfig.titlePadding;
+		if (titleDimension.width <= widthRequired && titleDimension.height <= heightRequired && this.chartConfig.showTitle && this.chartData.title) {
+			this.boundingRect.width = widthRequired;
+			this.boundingRect.height = heightRequired;
+			this.showChartTitle = true;
+		}
+		return {
+			width: this.boundingRect.width,
+			height: this.boundingRect.height
+		};
+	}
+	getDrawableElements() {
+		const drawableElem = [];
+		if (this.showChartTitle) drawableElem.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
+			}]
+		});
+		return drawableElem;
+	}
+};
+function getChartTitleComponent(chartConfig, chartData, chartThemeConfig, tmpSVGGroup2) {
+	return new ChartTitle(new TextDimensionCalculatorWithFont(tmpSVGGroup2), chartConfig, chartData, chartThemeConfig);
+}
+__name(getChartTitleComponent, "getChartTitleComponent");
+var LEGEND_MARKER_TO_FONT_RATIO = .75;
+var LEGEND_ITEM_SPACING_TO_FONT_RATIO = .5;
+var LEGEND_MARKER_SPACING_TO_FONT_RATIO = .35;
+function getLegendLayout(fontSize) {
+	return {
+		fontSize,
+		markerSize: fontSize * LEGEND_MARKER_TO_FONT_RATIO,
+		markerSpacing: fontSize * LEGEND_MARKER_SPACING_TO_FONT_RATIO,
+		itemSpacing: fontSize * LEGEND_ITEM_SPACING_TO_FONT_RATIO
+	};
+}
+__name(getLegendLayout, "getLegendLayout");
+var ChartLegend = class {
+	constructor(textDimensionCalculator, chartConfig, chartData, chartThemeConfig) {
+		this.textDimensionCalculator = textDimensionCalculator;
+		this.chartConfig = chartConfig;
+		this.chartData = chartData;
+		this.chartThemeConfig = chartThemeConfig;
+		this.boundingRect = {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		};
+		this.visiblePlots = [];
+	}
+	static {
+		__name(this, "ChartLegend");
+	}
+	setBoundingBoxXY(point) {
+		this.boundingRect.x = point.x;
+		this.boundingRect.y = point.y;
+	}
+	calculateSpace(availableSpace) {
+		this.visiblePlots = this.chartConfig.showLegend ? this.chartData.plots.filter((plot) => plot.title) : [];
+		if (this.visiblePlots.length === 0) {
+			this.boundingRect.width = 0;
+			this.boundingRect.height = 0;
+			return {
+				width: 0,
+				height: 0
+			};
+		}
+		const { fontSize, markerSize, markerSpacing, itemSpacing } = getLegendLayout(this.chartConfig.legendFontSize);
+		const textDimension = this.textDimensionCalculator.getMaxDimension(this.visiblePlots.map((plot) => plot.title), fontSize);
+		const widthRequired = this.chartConfig.legendPadding * 2 + markerSize + markerSpacing + textDimension.width;
+		const heightRequired = this.chartConfig.legendPadding * 2 + this.visiblePlots.length * fontSize + (this.visiblePlots.length - 1) * itemSpacing;
+		if (widthRequired <= availableSpace.width && heightRequired <= availableSpace.height) {
+			this.boundingRect.width = widthRequired;
+			this.boundingRect.height = heightRequired;
+		} else {
+			this.visiblePlots = [];
+			this.boundingRect.width = 0;
+			this.boundingRect.height = 0;
+		}
+		return {
+			width: this.boundingRect.width,
+			height: this.boundingRect.height
+		};
+	}
+	getDrawableElements() {
+		if (this.visiblePlots.length === 0) return [];
+		const { fontSize, markerSize, markerSpacing, itemSpacing } = getLegendLayout(this.chartConfig.legendFontSize);
+		const rowHeight = fontSize + itemSpacing;
+		const startX = this.boundingRect.x + this.chartConfig.legendPadding;
+		const startY = this.boundingRect.y + this.chartConfig.legendPadding;
+		const barMarkers = [];
+		const lineMarkers = [];
+		for (const [index, plot] of this.visiblePlots.entries()) if (isBarPlot(plot)) barMarkers.push({
+			x: startX,
+			y: startY + index * rowHeight,
+			width: markerSize,
+			height: markerSize,
+			fill: plot.fill,
+			strokeFill: plot.fill,
+			strokeWidth: 0
+		});
+		else {
+			const markerY = startY + index * rowHeight + markerSize / 2;
+			lineMarkers.push({
+				path: `M ${startX},${markerY} L ${startX + markerSize},${markerY}`,
+				strokeFill: plot.strokeFill,
+				strokeWidth: plot.strokeWidth
+			});
+		}
+		return [
+			{
+				groupTexts: ["legend", "markers"],
+				type: "rect",
+				data: barMarkers
+			},
+			{
+				groupTexts: ["legend", "markers"],
+				type: "path",
+				data: lineMarkers
+			},
+			{
+				groupTexts: ["legend", "label"],
+				type: "text",
+				data: this.visiblePlots.map((plot, index) => ({
+					text: plot.title,
+					x: startX + markerSize + markerSpacing,
+					y: startY + index * rowHeight + markerSize / 2,
+					fill: this.chartThemeConfig.legendTextColor,
+					fontSize,
+					rotation: 0,
+					verticalPos: "middle",
+					horizontalPos: "left"
+				}))
+			}
+		];
+	}
+};
+function getChartLegendComponent(chartConfig, chartData, chartThemeConfig, tmpSVGGroup2) {
+	return new ChartLegend(new TextDimensionCalculatorWithFont(tmpSVGGroup2), chartConfig, chartData, chartThemeConfig);
+}
+__name(getChartLegendComponent, "getChartLegendComponent");
+var LinePlot = class {
+	constructor(plotData, xAxis, yAxis, orientation, plotIndex2) {
+		this.plotData = plotData;
+		this.xAxis = xAxis;
+		this.yAxis = yAxis;
+		this.orientation = orientation;
+		this.plotIndex = plotIndex2;
+	}
+	static {
+		__name(this, "LinePlot");
+	}
+	getDrawableElement() {
+		const finalData = this.plotData.data.map((d) => [this.xAxis.getScaleValue(d[0]), this.yAxis.getScaleValue(d[1])]);
+		let path;
+		if (this.orientation === "horizontal") path = line_default().y((d) => d[0]).x((d) => d[1])(finalData);
+		else path = line_default().x((d) => d[0]).y((d) => d[1])(finalData);
+		if (!path) return [];
+		const elements = [{
+			groupTexts: ["plot", `line-plot-${this.plotIndex}`],
+			type: "path",
+			data: [{
+				path,
+				strokeFill: this.plotData.strokeFill,
+				strokeWidth: this.plotData.strokeWidth
+			}]
+		}];
+		if (this.plotData.pointLabels && this.plotData.pointLabels.length > 0) {
+			const labelOffset = 10;
+			const fontSize = 12;
+			const textData = [];
+			for (const [i, [px, py]] of finalData.entries()) {
+				const label = this.plotData.pointLabels[i];
+				if (!label) continue;
+				if (this.orientation === "horizontal") textData.push({
+					x: py + labelOffset,
+					y: px,
+					text: label,
+					fill: this.plotData.strokeFill,
+					verticalPos: "middle",
+					horizontalPos: "left",
+					fontSize,
+					rotation: 0
+				});
+				else textData.push({
+					x: px,
+					y: py - labelOffset,
+					text: label,
+					fill: this.plotData.strokeFill,
+					verticalPos: "middle",
+					horizontalPos: "center",
+					fontSize,
+					rotation: 0
+				});
+			}
+			if (textData.length > 0) elements.push({
+				groupTexts: [
+					"plot",
+					`line-plot-${this.plotIndex}`,
+					"labels"
+				],
+				type: "text",
+				data: textData
+			});
+		}
+		return elements;
+	}
+};
+var BarPlot = class {
+	constructor(barData, boundingRect, xAxis, yAxis, orientation, plotIndex2) {
+		this.barData = barData;
+		this.boundingRect = boundingRect;
+		this.xAxis = xAxis;
+		this.yAxis = yAxis;
+		this.orientation = orientation;
+		this.plotIndex = plotIndex2;
+	}
+	static {
+		__name(this, "BarPlot");
+	}
+	getDrawableElement() {
+		const finalData = this.barData.data.map((d) => [this.xAxis.getScaleValue(d[0]), this.yAxis.getScaleValue(d[1])]);
+		const barWidth = Math.min(this.xAxis.getAxisOuterPadding() * 2, this.xAxis.getTickDistance()) * .95;
+		const barWidthHalf = barWidth / 2;
+		if (this.orientation === "horizontal") return [{
+			groupTexts: ["plot", `bar-plot-${this.plotIndex}`],
+			type: "rect",
+			data: finalData.map((data) => ({
+				x: this.boundingRect.x,
+				y: data[0] - barWidthHalf,
+				height: barWidth,
+				width: data[1] - this.boundingRect.x,
+				fill: this.barData.fill,
+				strokeWidth: 0,
+				strokeFill: this.barData.fill
+			}))
+		}];
+		return [{
+			groupTexts: ["plot", `bar-plot-${this.plotIndex}`],
+			type: "rect",
+			data: finalData.map((data) => ({
+				x: data[0] - barWidthHalf,
+				y: data[1],
+				width: barWidth,
+				height: this.boundingRect.y + this.boundingRect.height - data[1],
+				fill: this.barData.fill,
+				strokeWidth: 0,
+				strokeFill: this.barData.fill
+			}))
+		}];
+	}
+};
+var BasePlot = class {
+	constructor(chartConfig, chartData, chartThemeConfig) {
+		this.chartConfig = chartConfig;
+		this.chartData = chartData;
+		this.chartThemeConfig = chartThemeConfig;
+		this.boundingRect = {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		};
+	}
+	static {
+		__name(this, "BasePlot");
+	}
+	setAxes(xAxis, yAxis) {
+		this.xAxis = xAxis;
+		this.yAxis = yAxis;
+	}
+	setBoundingBoxXY(point) {
+		this.boundingRect.x = point.x;
+		this.boundingRect.y = point.y;
+	}
+	calculateSpace(availableSpace) {
+		this.boundingRect.width = availableSpace.width;
+		this.boundingRect.height = availableSpace.height;
+		return {
+			width: this.boundingRect.width,
+			height: this.boundingRect.height
+		};
+	}
+	getDrawableElements() {
+		if (!(this.xAxis && this.yAxis)) throw Error("Axes must be passed to render Plots");
+		const drawableElem = [];
+		for (const [i, plot] of this.chartData.plots.entries()) switch (plot.type) {
+			case "line":
+				{
+					const linePlot = new LinePlot(plot, this.xAxis, this.yAxis, this.chartConfig.chartOrientation, i);
+					drawableElem.push(...linePlot.getDrawableElement());
+				}
+				break;
+			case "bar": {
+				const barPlot = new BarPlot(plot, this.boundingRect, this.xAxis, this.yAxis, this.chartConfig.chartOrientation, i);
+				drawableElem.push(...barPlot.getDrawableElement());
+			}
+		}
+		return drawableElem;
+	}
+};
+function getPlotComponent(chartConfig, chartData, chartThemeConfig) {
+	return new BasePlot(chartConfig, chartData, chartThemeConfig);
+}
+__name(getPlotComponent, "getPlotComponent");
+var Orchestrator = class {
+	constructor(chartConfig, chartData, chartThemeConfig, tmpSVGGroup2) {
+		this.chartConfig = chartConfig;
+		this.chartData = chartData;
+		this.componentStore = {
+			title: getChartTitleComponent(chartConfig, chartData, chartThemeConfig, tmpSVGGroup2),
+			plot: getPlotComponent(chartConfig, chartData, chartThemeConfig),
+			legend: getChartLegendComponent(chartConfig, chartData, chartThemeConfig, tmpSVGGroup2),
+			xAxis: getAxis(chartData.xAxis, chartConfig.xAxis, {
+				titleColor: chartThemeConfig.xAxisTitleColor,
+				labelColor: chartThemeConfig.xAxisLabelColor,
+				tickColor: chartThemeConfig.xAxisTickColor,
+				axisLineColor: chartThemeConfig.xAxisLineColor
+			}, tmpSVGGroup2),
+			yAxis: getAxis(chartData.yAxis, chartConfig.yAxis, {
+				titleColor: chartThemeConfig.yAxisTitleColor,
+				labelColor: chartThemeConfig.yAxisLabelColor,
+				tickColor: chartThemeConfig.yAxisTickColor,
+				axisLineColor: chartThemeConfig.yAxisLineColor
+			}, tmpSVGGroup2)
+		};
+	}
+	static {
+		__name(this, "Orchestrator");
+	}
+	calculateVerticalSpace() {
+		let availableWidth = this.chartConfig.width;
+		let availableHeight = this.chartConfig.height;
+		let plotX = 0;
+		let plotY = 0;
+		let legendSpace = {
+			width: 0,
+			height: 0
+		};
+		let chartWidth = Math.floor(availableWidth * this.chartConfig.plotReservedSpacePercent / 100);
+		let chartHeight = Math.floor(availableHeight * this.chartConfig.plotReservedSpacePercent / 100);
+		let spaceUsed = this.componentStore.plot.calculateSpace({
+			width: chartWidth,
+			height: chartHeight
+		});
+		availableWidth -= spaceUsed.width;
+		availableHeight -= spaceUsed.height;
+		spaceUsed = this.componentStore.title.calculateSpace({
+			width: this.chartConfig.width,
+			height: availableHeight
+		});
+		plotY = spaceUsed.height;
+		availableHeight -= spaceUsed.height;
+		this.componentStore.xAxis.setAxisPosition("bottom");
+		spaceUsed = this.componentStore.xAxis.calculateSpace({
+			width: availableWidth,
+			height: availableHeight
+		});
+		availableHeight -= spaceUsed.height;
+		this.componentStore.yAxis.setAxisPosition("left");
+		spaceUsed = this.componentStore.yAxis.calculateSpace({
+			width: availableWidth,
+			height: availableHeight
+		});
+		plotX = spaceUsed.width;
+		availableWidth -= spaceUsed.width;
+		legendSpace = this.componentStore.legend.calculateSpace({
+			width: availableWidth,
+			height: chartHeight
+		});
+		availableWidth -= legendSpace.width;
+		if (availableWidth > 0) {
+			chartWidth += availableWidth;
+			availableWidth = 0;
+		}
+		if (availableHeight > 0) {
+			chartHeight += availableHeight;
+			availableHeight = 0;
+		}
+		this.componentStore.plot.calculateSpace({
+			width: chartWidth,
+			height: chartHeight
+		});
+		this.componentStore.plot.setBoundingBoxXY({
+			x: plotX,
+			y: plotY
+		});
+		this.componentStore.legend.setBoundingBoxXY({
+			x: plotX + chartWidth,
+			y: plotY + Math.max((chartHeight - legendSpace.height) / 2, 0)
+		});
+		this.componentStore.xAxis.setRange([plotX, plotX + chartWidth]);
+		this.componentStore.xAxis.setBoundingBoxXY({
+			x: plotX,
+			y: plotY + chartHeight
+		});
+		this.componentStore.yAxis.setRange([plotY, plotY + chartHeight]);
+		this.componentStore.yAxis.setBoundingBoxXY({
+			x: 0,
+			y: plotY
+		});
+		if (this.chartData.plots.some((p) => isBarPlot(p))) this.componentStore.xAxis.recalculateOuterPaddingToDrawBar();
+	}
+	calculateHorizontalSpace() {
+		let availableWidth = this.chartConfig.width;
+		let availableHeight = this.chartConfig.height;
+		let titleYEnd = 0;
+		let plotX = 0;
+		let plotY = 0;
+		let legendSpace = {
+			width: 0,
+			height: 0
+		};
+		let chartWidth = Math.floor(availableWidth * this.chartConfig.plotReservedSpacePercent / 100);
+		let chartHeight = Math.floor(availableHeight * this.chartConfig.plotReservedSpacePercent / 100);
+		let spaceUsed = this.componentStore.plot.calculateSpace({
+			width: chartWidth,
+			height: chartHeight
+		});
+		availableWidth -= spaceUsed.width;
+		availableHeight -= spaceUsed.height;
+		spaceUsed = this.componentStore.title.calculateSpace({
+			width: this.chartConfig.width,
+			height: availableHeight
+		});
+		titleYEnd = spaceUsed.height;
+		availableHeight -= spaceUsed.height;
+		this.componentStore.xAxis.setAxisPosition("left");
+		spaceUsed = this.componentStore.xAxis.calculateSpace({
+			width: availableWidth,
+			height: availableHeight
+		});
+		availableWidth -= spaceUsed.width;
+		plotX = spaceUsed.width;
+		this.componentStore.yAxis.setAxisPosition("top");
+		spaceUsed = this.componentStore.yAxis.calculateSpace({
+			width: availableWidth,
+			height: availableHeight
+		});
+		availableHeight -= spaceUsed.height;
+		plotY = titleYEnd + spaceUsed.height;
+		legendSpace = this.componentStore.legend.calculateSpace({
+			width: availableWidth,
+			height: chartHeight
+		});
+		availableWidth -= legendSpace.width;
+		if (availableWidth > 0) {
+			chartWidth += availableWidth;
+			availableWidth = 0;
+		}
+		if (availableHeight > 0) {
+			chartHeight += availableHeight;
+			availableHeight = 0;
+		}
+		this.componentStore.plot.calculateSpace({
+			width: chartWidth,
+			height: chartHeight
+		});
+		this.componentStore.plot.setBoundingBoxXY({
+			x: plotX,
+			y: plotY
+		});
+		this.componentStore.legend.setBoundingBoxXY({
+			x: plotX + chartWidth,
+			y: plotY + Math.max((chartHeight - legendSpace.height) / 2, 0)
+		});
+		this.componentStore.yAxis.setRange([plotX, plotX + chartWidth]);
+		this.componentStore.yAxis.setBoundingBoxXY({
+			x: plotX,
+			y: titleYEnd
+		});
+		this.componentStore.xAxis.setRange([plotY, plotY + chartHeight]);
+		this.componentStore.xAxis.setBoundingBoxXY({
+			x: 0,
+			y: plotY
+		});
+		if (this.chartData.plots.some((p) => isBarPlot(p))) this.componentStore.xAxis.recalculateOuterPaddingToDrawBar();
+	}
+	calculateSpace() {
+		if (this.chartConfig.chartOrientation === "horizontal") this.calculateHorizontalSpace();
+		else this.calculateVerticalSpace();
+	}
+	getDrawableElement() {
+		this.calculateSpace();
+		const drawableElem = [];
+		this.componentStore.plot.setAxes(this.componentStore.xAxis, this.componentStore.yAxis);
+		for (const component of Object.values(this.componentStore)) drawableElem.push(...component.getDrawableElements());
+		return drawableElem;
+	}
+};
+var XYChartBuilder = class {
+	static {
+		__name(this, "XYChartBuilder");
+	}
+	static build(config, chartData, chartThemeConfig, tmpSVGGroup2) {
+		return new Orchestrator(config, chartData, chartThemeConfig, tmpSVGGroup2).getDrawableElement();
+	}
+};
+var plotIndex = 0;
+var tmpSVGGroup;
+var xyChartConfig = getChartDefaultConfig();
+var xyChartThemeConfig = getChartDefaultThemeConfig();
+var xyChartData = getChartDefaultData();
+var plotColorPalette = xyChartThemeConfig.plotColorPalette.split(",").map((color) => color.trim());
+var hasSetXAxis = false;
+var hasSetYAxis = false;
+function getChartDefaultThemeConfig() {
+	const defaultThemeVariables = getThemeVariables3();
+	const config = getConfig();
+	return cleanAndMerge(defaultThemeVariables.xyChart, config.themeVariables.xyChart);
+}
+__name(getChartDefaultThemeConfig, "getChartDefaultThemeConfig");
+function getChartDefaultConfig() {
+	const config = getConfig();
+	return cleanAndMerge(defaultConfig_default.xyChart, config.xyChart);
+}
+__name(getChartDefaultConfig, "getChartDefaultConfig");
+function getChartDefaultData() {
+	return {
+		yAxis: {
+			type: "linear",
+			title: "",
+			min: Infinity,
+			max: -Infinity
+		},
+		xAxis: {
+			type: "band",
+			title: "",
+			categories: []
+		},
+		title: "",
+		plots: []
+	};
+}
+__name(getChartDefaultData, "getChartDefaultData");
+function textSanitizer(text) {
+	const config = getConfig();
+	return sanitizeText(text.trim(), config);
+}
+__name(textSanitizer, "textSanitizer");
+function setTmpSVGG(SVGG) {
+	tmpSVGGroup = SVGG;
+}
+__name(setTmpSVGG, "setTmpSVGG");
+function setOrientation(orientation) {
+	if (orientation === "horizontal") xyChartConfig.chartOrientation = "horizontal";
+	else xyChartConfig.chartOrientation = "vertical";
+}
+__name(setOrientation, "setOrientation");
+function setXAxisTitle(title) {
+	xyChartData.xAxis.title = textSanitizer(title.text);
+}
+__name(setXAxisTitle, "setXAxisTitle");
+function setXAxisRangeData(min, max) {
+	xyChartData.xAxis = {
+		type: "linear",
+		title: xyChartData.xAxis.title,
+		min,
+		max
+	};
+	hasSetXAxis = true;
+}
+__name(setXAxisRangeData, "setXAxisRangeData");
+function setXAxisBand(categories) {
+	xyChartData.xAxis = {
+		type: "band",
+		title: xyChartData.xAxis.title,
+		categories: categories.map((c) => textSanitizer(c.text))
+	};
+	hasSetXAxis = true;
+}
+__name(setXAxisBand, "setXAxisBand");
+function setYAxisTitle(title) {
+	xyChartData.yAxis.title = textSanitizer(title.text);
+}
+__name(setYAxisTitle, "setYAxisTitle");
+function setYAxisRangeData(min, max) {
+	xyChartData.yAxis = {
+		type: "linear",
+		title: xyChartData.yAxis.title,
+		min,
+		max
+	};
+	hasSetYAxis = true;
+}
+__name(setYAxisRangeData, "setYAxisRangeData");
+function setYAxisRangeFromPlotData(data) {
+	const minValue = Math.min(...data);
+	const maxValue = Math.max(...data);
+	const prevMinValue = isLinearAxisData(xyChartData.yAxis) ? xyChartData.yAxis.min : Infinity;
+	const prevMaxValue = isLinearAxisData(xyChartData.yAxis) ? xyChartData.yAxis.max : -Infinity;
+	xyChartData.yAxis = {
+		type: "linear",
+		title: xyChartData.yAxis.title,
+		min: Math.min(prevMinValue, minValue),
+		max: Math.max(prevMaxValue, maxValue)
+	};
+}
+__name(setYAxisRangeFromPlotData, "setYAxisRangeFromPlotData");
+function transformDataWithoutCategory(data) {
+	let retData = [];
+	if (data.length === 0) return retData;
+	if (!hasSetXAxis) {
+		const prevMinValue = isLinearAxisData(xyChartData.xAxis) ? xyChartData.xAxis.min : Infinity;
+		const prevMaxValue = isLinearAxisData(xyChartData.xAxis) ? xyChartData.xAxis.max : -Infinity;
+		setXAxisRangeData(Math.min(prevMinValue, 1), Math.max(prevMaxValue, data.length));
+	}
+	if (isBandAxisData(xyChartData.xAxis) && data.length > xyChartData.xAxis.categories.length) data = data.slice(0, xyChartData.xAxis.categories.length);
+	if (!hasSetYAxis) setYAxisRangeFromPlotData(data);
+	if (isBandAxisData(xyChartData.xAxis)) retData = xyChartData.xAxis.categories.map((c, i) => [c, data[i]]);
+	if (isLinearAxisData(xyChartData.xAxis)) {
+		const min = xyChartData.xAxis.min;
+		const max = xyChartData.xAxis.max;
+		if (data.length === 1) retData = [[`${min}`, data[0]]];
+		else {
+			const step = (max - min) / (data.length - 1);
+			retData = data.map((datum, index) => [`${min + index * step}`, datum]);
+		}
+	}
+	return retData;
+}
+__name(transformDataWithoutCategory, "transformDataWithoutCategory");
+function getPlotColorFromPalette(plotIndex2) {
+	return plotColorPalette[plotIndex2 === 0 ? 0 : plotIndex2 % plotColorPalette.length];
+}
+__name(getPlotColorFromPalette, "getPlotColorFromPalette");
+function setLineData(title, data) {
+	const values = data.map((d) => d.value);
+	const labels = data.map((d) => d.label ? textSanitizer(d.label) : "");
+	const plotData = transformDataWithoutCategory(values);
+	const hasAnyLabel = labels.some((l) => l !== "");
+	xyChartData.plots.push({
+		type: "line",
+		title: textSanitizer(title.text),
+		strokeFill: getPlotColorFromPalette(plotIndex),
+		strokeWidth: 2,
+		data: plotData,
+		...hasAnyLabel ? { pointLabels: labels } : {}
+	});
+	plotIndex++;
+}
+__name(setLineData, "setLineData");
+function setBarData(title, data) {
+	const plotData = transformDataWithoutCategory(data.map((d) => d.value));
+	xyChartData.plots.push({
+		type: "bar",
+		title: textSanitizer(title.text),
+		fill: getPlotColorFromPalette(plotIndex),
+		data: plotData
+	});
+	plotIndex++;
+}
+__name(setBarData, "setBarData");
+function getDrawableElem() {
+	if (xyChartData.plots.length === 0) throw Error("No Plot to render, please provide a plot with some data");
+	xyChartData.title = getDiagramTitle();
+	return XYChartBuilder.build(xyChartConfig, xyChartData, xyChartThemeConfig, tmpSVGGroup);
+}
+__name(getDrawableElem, "getDrawableElem");
+function getChartThemeConfig() {
+	return xyChartThemeConfig;
+}
+__name(getChartThemeConfig, "getChartThemeConfig");
+function getChartConfig() {
+	return xyChartConfig;
+}
+__name(getChartConfig, "getChartConfig");
+function getXYChartData() {
+	return xyChartData;
+}
+__name(getXYChartData, "getXYChartData");
+var diagram = {
+	parser: xychart_default,
+	db: {
+		getDrawableElem,
+		clear: /* @__PURE__ */ __name(function() {
+			clear();
+			plotIndex = 0;
+			xyChartConfig = getChartDefaultConfig();
+			xyChartData = getChartDefaultData();
+			xyChartThemeConfig = getChartDefaultThemeConfig();
+			plotColorPalette = xyChartThemeConfig.plotColorPalette.split(",").map((color) => color.trim());
+			hasSetXAxis = false;
+			hasSetYAxis = false;
+		}, "clear"),
+		setAccTitle,
+		getAccTitle,
+		setDiagramTitle,
+		getDiagramTitle,
+		getAccDescription,
+		setAccDescription,
+		setOrientation,
+		setXAxisTitle,
+		setXAxisRangeData,
+		setXAxisBand,
+		setYAxisTitle,
+		setYAxisRangeData,
+		setLineData,
+		setBarData,
+		setTmpSVGG,
+		getChartThemeConfig,
+		getChartConfig,
+		getXYChartData
+	},
+	renderer: { draw: /* @__PURE__ */ __name((txt, id, _version, diagObj) => {
+		const db = diagObj.db;
+		const themeConfig = db.getChartThemeConfig();
+		const chartConfig = db.getChartConfig();
+		const labelData = db.getXYChartData().plots[0].data.map((data) => data[1]);
+		function getDominantBaseLine(horizontalPos) {
+			return horizontalPos === "top" ? "text-before-edge" : "middle";
+		}
+		__name(getDominantBaseLine, "getDominantBaseLine");
+		function getTextAnchor(verticalPos) {
+			return verticalPos === "left" ? "start" : verticalPos === "right" ? "end" : "middle";
+		}
+		__name(getTextAnchor, "getTextAnchor");
+		function getTextTransformation(data) {
+			return `translate(${data.x}, ${data.y}) rotate(${data.rotation || 0})`;
+		}
+		__name(getTextTransformation, "getTextTransformation");
+		log.debug("Rendering xychart chart\n" + txt);
+		const svg = selectSvgElement(id);
+		const group = svg.append("g").attr("class", "main");
+		const background = group.append("rect").attr("width", chartConfig.width).attr("height", chartConfig.height).attr("class", "background");
+		configureSvgSize(svg, chartConfig.height, chartConfig.width, true);
+		svg.attr("viewBox", `0 0 ${chartConfig.width} ${chartConfig.height}`);
+		background.attr("fill", themeConfig.backgroundColor);
+		db.setTmpSVGG(svg.append("g").attr("class", "mermaid-tmp-group"));
+		const shapes = db.getDrawableElem();
+		const groups = {};
+		function getGroup(gList) {
+			let elem = group;
+			let prefix = "";
+			for (const [i] of gList.entries()) {
+				let parent = group;
+				if (i > 0 && groups[prefix]) parent = groups[prefix];
+				prefix += gList[i];
+				elem = groups[prefix];
+				if (!elem) elem = groups[prefix] = parent.append("g").attr("class", gList[i]);
+			}
+			return elem;
+		}
+		__name(getGroup, "getGroup");
+		for (const shape of shapes) {
+			if (shape.data.length === 0) continue;
+			const shapeGroup = getGroup(shape.groupTexts);
+			switch (shape.type) {
+				case "rect":
+					shapeGroup.selectAll("rect").data(shape.data).enter().append("rect").attr("x", (data) => data.x).attr("y", (data) => data.y).attr("width", (data) => data.width).attr("height", (data) => data.height).attr("fill", (data) => data.fill).attr("stroke", (data) => data.strokeFill).attr("stroke-width", (data) => data.strokeWidth);
+					if (chartConfig.showDataLabel) {
+						const showDataLabelOutsideBar = chartConfig.showDataLabelOutsideBar;
+						if (chartConfig.chartOrientation === "horizontal") {
+							let fitsHorizontally2 = function(item, fontSize) {
+								const { data, label } = item;
+								return fontSize * label.length * charWidthFactor <= data.width - rightMargin;
+							};
+							__name(fitsHorizontally2, "fitsHorizontally");
+							const charWidthFactor = .7;
+							const rightMargin = 10;
+							const validItems = shape.data.map((d, i) => ({
+								data: d,
+								label: labelData[i].toString()
+							})).filter((item) => item.data.width > 0 && item.data.height > 0);
+							const candidateFontSizes = validItems.map((item) => {
+								const { data } = item;
+								let fontSize = data.height * .7;
+								while (!fitsHorizontally2(item, fontSize) && fontSize > 0) fontSize -= 1;
+								return fontSize;
+							});
+							const uniformFontSize = Math.floor(Math.min(...candidateFontSizes));
+							const determineLabelXPosition = /* @__PURE__ */ __name((item) => {
+								if (showDataLabelOutsideBar) return item.data.x + item.data.width + rightMargin;
+								else return item.data.x + item.data.width - rightMargin;
+							}, "determineLabelXPosition");
+							shapeGroup.selectAll("text").data(validItems).enter().append("text").attr("x", determineLabelXPosition).attr("y", (item) => item.data.y + item.data.height / 2).attr("text-anchor", showDataLabelOutsideBar ? "start" : "end").attr("dominant-baseline", "middle").attr("fill", themeConfig.dataLabelColor).attr("font-size", `${uniformFontSize}px`).text((item) => item.label);
+						} else {
+							let fitsInBar2 = function(item, fontSize, yOffset2) {
+								const { data, label } = item;
+								const textWidth = fontSize * label.length * .7;
+								const centerX = data.x + data.width / 2;
+								const leftEdge = centerX - textWidth / 2;
+								const rightEdge = centerX + textWidth / 2;
+								const horizontalFits = leftEdge >= data.x && rightEdge <= data.x + data.width;
+								const verticalFits = data.y + yOffset2 + fontSize <= data.y + data.height;
+								return horizontalFits && verticalFits;
+							};
+							__name(fitsInBar2, "fitsInBar");
+							const yOffset = 10;
+							const validItems = shape.data.map((d, i) => ({
+								data: d,
+								label: labelData[i].toString()
+							})).filter((item) => item.data.width > 0 && item.data.height > 0);
+							const candidateFontSizes = validItems.map((item) => {
+								const { data, label } = item;
+								let fontSize = data.width / (label.length * .7);
+								while (!fitsInBar2(item, fontSize, yOffset) && fontSize > 0) fontSize -= 1;
+								return fontSize;
+							});
+							const uniformFontSize = Math.floor(Math.min(...candidateFontSizes));
+							const determineLabelYPosition = /* @__PURE__ */ __name((item) => {
+								if (showDataLabelOutsideBar) return item.data.y - yOffset;
+								else return item.data.y + yOffset;
+							}, "determineLabelYPosition");
+							shapeGroup.selectAll("text").data(validItems).enter().append("text").attr("x", (item) => item.data.x + item.data.width / 2).attr("y", determineLabelYPosition).attr("text-anchor", "middle").attr("dominant-baseline", showDataLabelOutsideBar ? "auto" : "hanging").attr("fill", themeConfig.dataLabelColor).attr("font-size", `${uniformFontSize}px`).text((item) => item.label);
+						}
+					}
+					break;
+				case "text":
+					shapeGroup.selectAll("text").data(shape.data).enter().append("text").attr("x", 0).attr("y", 0).attr("fill", (data) => data.fill).attr("font-size", (data) => data.fontSize).attr("dominant-baseline", (data) => getDominantBaseLine(data.verticalPos)).attr("text-anchor", (data) => getTextAnchor(data.horizontalPos)).attr("transform", (data) => getTextTransformation(data)).text((data) => data.text);
+					break;
+				case "path": shapeGroup.selectAll("path").data(shape.data).enter().append("path").attr("d", (data) => data.path).attr("fill", (data) => data.fill ? data.fill : "none").attr("stroke", (data) => data.strokeFill).attr("stroke-width", (data) => data.strokeWidth);
+			}
+		}
+	}, "draw") }
+};
+
+//#endregion
+export { diagram };