@umami/shiso 1.12.0 → 1.13.0

package/dist/chunks/ordinal.js

@@ -0,0 +1,84 @@
+import { t as initRange } from "./init.js";
+
+//#region ../../node_modules/.pnpm/internmap@2.0.3/node_modules/internmap/src/index.js
+var InternMap = class extends Map {
+	constructor(entries, key = keyof) {
+		super();
+		Object.defineProperties(this, {
+			_intern: { value: /* @__PURE__ */ new Map() },
+			_key: { value: key }
+		});
+		if (entries != null) for (const [key, value] of entries) this.set(key, value);
+	}
+	get(key) {
+		return super.get(intern_get(this, key));
+	}
+	has(key) {
+		return super.has(intern_get(this, key));
+	}
+	set(key, value) {
+		return super.set(intern_set(this, key), value);
+	}
+	delete(key) {
+		return super.delete(intern_delete(this, key));
+	}
+};
+function intern_get({ _intern, _key }, value) {
+	const key = _key(value);
+	return _intern.has(key) ? _intern.get(key) : value;
+}
+function intern_set({ _intern, _key }, value) {
+	const key = _key(value);
+	if (_intern.has(key)) return _intern.get(key);
+	_intern.set(key, value);
+	return value;
+}
+function intern_delete({ _intern, _key }, value) {
+	const key = _key(value);
+	if (_intern.has(key)) {
+		value = _intern.get(key);
+		_intern.delete(key);
+	}
+	return value;
+}
+function keyof(value) {
+	return value !== null && typeof value === "object" ? value.valueOf() : value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/ordinal.js
+const implicit = Symbol("implicit");
+function ordinal() {
+	var index = new InternMap(), domain = [], range = [], unknown = implicit;
+	function scale(d) {
+		let i = index.get(d);
+		if (i === void 0) {
+			if (unknown !== implicit) return unknown;
+			index.set(d, i = domain.push(d) - 1);
+		}
+		return range[i % range.length];
+	}
+	scale.domain = function(_) {
+		if (!arguments.length) return domain.slice();
+		domain = [], index = new InternMap();
+		for (const value of _) {
+			if (index.has(value)) continue;
+			index.set(value, domain.push(value) - 1);
+		}
+		return scale;
+	};
+	scale.range = function(_) {
+		return arguments.length ? (range = Array.from(_), scale) : range.slice();
+	};
+	scale.unknown = function(_) {
+		return arguments.length ? (unknown = _, scale) : unknown;
+	};
+	scale.copy = function() {
+		return ordinal(domain, range).unknown(unknown);
+	};
+	initRange.apply(scale, arguments);
+	return scale;
+}
+
+//#endregion
+export { ordinal as t };

package/dist/chunks/packet-AYTQ26CC.js

@@ -0,0 +1,4 @@
+import "./chunk-FOHPRMQF.js";
+import { S as createPacketServices, x as PacketModule } from "./mermaid-parser.core.js";
+
+export { createPacketServices };

package/dist/chunks/path.js

@@ -0,0 +1,106 @@
+//#region ../../node_modules/.pnpm/d3-path@3.1.0/node_modules/d3-path/src/path.js
+const pi = Math.PI;
+const tau = 2 * pi;
+const epsilon = 1e-6;
+const tauEpsilon = tau - epsilon;
+function append(strings) {
+	this._ += strings[0];
+	for (let i = 1, n = strings.length; i < n; ++i) this._ += arguments[i] + strings[i];
+}
+function appendRound(digits) {
+	let d = Math.floor(digits);
+	if (!(d >= 0)) throw new Error(`invalid digits: ${digits}`);
+	if (d > 15) return append;
+	const k = 10 ** d;
+	return function(strings) {
+		this._ += strings[0];
+		for (let i = 1, n = strings.length; i < n; ++i) this._ += Math.round(arguments[i] * k) / k + strings[i];
+	};
+}
+var Path = class {
+	constructor(digits) {
+		this._x0 = this._y0 = this._x1 = this._y1 = null;
+		this._ = "";
+		this._append = digits == null ? append : appendRound(digits);
+	}
+	moveTo(x, y) {
+		this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}`;
+	}
+	closePath() {
+		if (this._x1 !== null) {
+			this._x1 = this._x0, this._y1 = this._y0;
+			this._append`Z`;
+		}
+	}
+	lineTo(x, y) {
+		this._append`L${this._x1 = +x},${this._y1 = +y}`;
+	}
+	quadraticCurveTo(x1, y1, x, y) {
+		this._append`Q${+x1},${+y1},${this._x1 = +x},${this._y1 = +y}`;
+	}
+	bezierCurveTo(x1, y1, x2, y2, x, y) {
+		this._append`C${+x1},${+y1},${+x2},${+y2},${this._x1 = +x},${this._y1 = +y}`;
+	}
+	arcTo(x1, y1, x2, y2, r) {
+		x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
+		if (r < 0) throw new Error(`negative radius: ${r}`);
+		let x0 = this._x1, y0 = this._y1, x21 = x2 - x1, y21 = y2 - y1, x01 = x0 - x1, y01 = y0 - y1, l01_2 = x01 * x01 + y01 * y01;
+		if (this._x1 === null) this._append`M${this._x1 = x1},${this._y1 = y1}`;
+		else if (!(l01_2 > epsilon));
+		else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) this._append`L${this._x1 = x1},${this._y1 = y1}`;
+		else {
+			let x20 = x2 - x0, y20 = y2 - y0, l21_2 = x21 * x21 + y21 * y21, l20_2 = x20 * x20 + y20 * y20, l21 = Math.sqrt(l21_2), l01 = Math.sqrt(l01_2), l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), t01 = l / l01, t21 = l / l21;
+			if (Math.abs(t01 - 1) > epsilon) this._append`L${x1 + t01 * x01},${y1 + t01 * y01}`;
+			this._append`A${r},${r},0,0,${+(y01 * x20 > x01 * y20)},${this._x1 = x1 + t21 * x21},${this._y1 = y1 + t21 * y21}`;
+		}
+	}
+	arc(x, y, r, a0, a1, ccw) {
+		x = +x, y = +y, r = +r, ccw = !!ccw;
+		if (r < 0) throw new Error(`negative radius: ${r}`);
+		let dx = r * Math.cos(a0), dy = r * Math.sin(a0), x0 = x + dx, y0 = y + dy, cw = 1 ^ ccw, da = ccw ? a0 - a1 : a1 - a0;
+		if (this._x1 === null) this._append`M${x0},${y0}`;
+		else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) this._append`L${x0},${y0}`;
+		if (!r) return;
+		if (da < 0) da = da % tau + tau;
+		if (da > tauEpsilon) this._append`A${r},${r},0,1,${cw},${x - dx},${y - dy}A${r},${r},0,1,${cw},${this._x1 = x0},${this._y1 = y0}`;
+		else if (da > epsilon) this._append`A${r},${r},0,${+(da >= pi)},${cw},${this._x1 = x + r * Math.cos(a1)},${this._y1 = y + r * Math.sin(a1)}`;
+	}
+	rect(x, y, w, h) {
+		this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}h${w = +w}v${+h}h${-w}Z`;
+	}
+	toString() {
+		return this._;
+	}
+};
+function path() {
+	return new Path();
+}
+path.prototype = Path.prototype;
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/constant.js
+function constant_default(x) {
+	return function constant() {
+		return x;
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/path.js
+function withPath(shape) {
+	let digits = 3;
+	shape.digits = function(_) {
+		if (!arguments.length) return digits;
+		if (_ == null) digits = null;
+		else {
+			const d = Math.floor(_);
+			if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`);
+			digits = d;
+		}
+		return shape;
+	};
+	return () => new Path(digits);
+}
+
+//#endregion
+export { constant_default as n, withPath as t };

package/dist/chunks/pegDiagram-XKGWAZYB.js

@@ -0,0 +1,115 @@
+import { t as MermaidParseError, u as createRailroadPegServices } from "./mermaid-parser.core.js";
+import { n as __name } from "./chunk-Y2CYZVJY.js";
+import { m as log } from "./src.js";
+import "./chunk-DU6HZSFF.js";
+import { n as getStyles, r as renderer, t as db } from "./chunk-SVP7TREG.js";
+import { t as populateCommonDb } from "./chunk-JWPE2WC7.js";
+import "./mermaid.core.js";
+
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/pegDiagram-XKGWAZYB.mjs
+var langiumParser = createRailroadPegServices().RailroadPeg.parser.LangiumParser;
+var transformOrderedChoice = /* @__PURE__ */ __name((choice) => {
+	const alternatives = choice.alternatives.map(transformSequence);
+	if (alternatives.length === 1) return alternatives[0];
+	return {
+		type: "choice",
+		alternatives
+	};
+}, "transformOrderedChoice");
+var transformSequence = /* @__PURE__ */ __name((sequence) => {
+	const elements = sequence.elements.map(transformPrefix);
+	if (elements.length === 1) return elements[0];
+	return {
+		type: "sequence",
+		elements
+	};
+}, "transformSequence");
+var transformPrefix = /* @__PURE__ */ __name((prefix) => {
+	const inner = transformSuffix(prefix.suffix);
+	if (!prefix.operator) return inner;
+	return {
+		type: "special",
+		text: prefix.operator === "&" ? `&${nodeToLabel(inner)}` : `!${nodeToLabel(inner)}`
+	};
+}, "transformPrefix");
+var nodeToLabel = /* @__PURE__ */ __name((node) => {
+	switch (node.type) {
+		case "terminal": return `"${node.value}"`;
+		case "nonterminal": return node.name;
+		case "special": return node.text;
+		default: return "(...)";
+	}
+}, "nodeToLabel");
+var transformSuffix = /* @__PURE__ */ __name((suffix) => {
+	const inner = transformPrimary(suffix.primary);
+	if (!suffix.operator) return inner;
+	switch (suffix.operator) {
+		case "?": return {
+			type: "optional",
+			element: inner
+		};
+		case "*": return {
+			type: "repetition",
+			element: inner,
+			min: 0,
+			max: Infinity
+		};
+		case "+": return {
+			type: "repetition",
+			element: inner,
+			min: 1,
+			max: Infinity
+		};
+		default: throw new Error(`Unsupported PEG suffix operator: ${suffix.operator}`);
+	}
+}, "transformSuffix");
+var transformPrimary = /* @__PURE__ */ __name((primary) => {
+	switch (primary.$type) {
+		case "PegLiteral": return {
+			type: "terminal",
+			value: primary.value
+		};
+		case "PegIdentifier": return {
+			type: "nonterminal",
+			name: primary.name
+		};
+		case "PegGroup": return transformOrderedChoice(primary.element);
+		case "PegAny": return {
+			type: "special",
+			text: primary.dot
+		};
+		default: throw new Error(`Unsupported PEG primary node: ${primary.$type}`);
+	}
+}, "transformPrimary");
+var transformRule = /* @__PURE__ */ __name((rule) => {
+	return {
+		name: rule.name,
+		definition: transformOrderedChoice(rule.definition)
+	};
+}, "transformRule");
+var populateDb = /* @__PURE__ */ __name((ast) => {
+	populateCommonDb(ast, db);
+	if (ast.title) db.setTitle(ast.title);
+	ast.rules.map((rule) => db.addRule(transformRule(rule)));
+}, "populateDb");
+var diagram = {
+	parser: {
+		parse: /* @__PURE__ */ __name((input) => {
+			db.clear();
+			log.debug("[PEG Parser] Starting Langium parse");
+			const result = langiumParser.parse(input);
+			if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) throw new MermaidParseError(result);
+			const ast = result.value;
+			log.debug("[PEG Parser] Parsed rules:", ast.rules.length);
+			populateDb(ast);
+			log.debug("[PEG Parser] Parse complete");
+		}, "parse"),
+		parser: { yy: db }
+	},
+	db,
+	renderer,
+	styles: getStyles
+};
+
+//#endregion
+export { diagram };

package/dist/chunks/pie-WAS4IAKB.js

@@ -0,0 +1,4 @@
+import "./chunk-FOHPRMQF.js";
+import { b as createPieServices, y as PieModule } from "./mermaid-parser.core.js";
+
+export { createPieServices };

package/dist/chunks/pieDiagram-E7YTZNPT.js

@@ -0,0 +1,297 @@
+import { n as parse } from "./mermaid-parser.core.js";
+import { n as __name } from "./chunk-Y2CYZVJY.js";
+import { m as log } from "./src.js";
+import { H as setAccDescription, K as setDiagramTitle, U as setAccTitle, a as clear, c as configureSvgSize, f as defaultConfig_default, v as getAccDescription, w as getDiagramTitle, x as getConfig2, y as getAccTitle } from "./chunk-DU6HZSFF.js";
+import { t as ordinal } from "./ordinal.js";
+import { n as constant_default } from "./path.js";
+import { m as tau } from "./dist.js";
+import { t as arc_default } from "./arc.js";
+import { t as array_default } from "./array.js";
+import { i as cleanAndMerge, p as parseFontSize } from "./chunk-75Z2AOVW.js";
+import { t as populateCommonDb } from "./chunk-JWPE2WC7.js";
+import { f as selectSvgElement } from "./mermaid.core.js";
+
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/descending.js
+function descending_default(a, b) {
+	return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/identity.js
+function identity_default(d) {
+	return d;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/pie.js
+function pie_default() {
+	var value = identity_default, sortValues = descending_default, sort = null, startAngle = constant_default(0), endAngle = constant_default(tau), padAngle = constant_default(0);
+	function pie(data) {
+		var i, n = (data = array_default(data)).length, j, k, sum = 0, index = new Array(n), arcs = new Array(n), a0 = +startAngle.apply(this, arguments), da = Math.min(tau, Math.max(-tau, endAngle.apply(this, arguments) - a0)), a1, p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), pa = p * (da < 0 ? -1 : 1), v;
+		for (i = 0; i < n; ++i) if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) sum += v;
+		if (sortValues != null) index.sort(function(i, j) {
+			return sortValues(arcs[i], arcs[j]);
+		});
+		else if (sort != null) index.sort(function(i, j) {
+			return sort(data[i], data[j]);
+		});
+		for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {
+			data: data[j],
+			index: i,
+			value: v,
+			startAngle: a0,
+			endAngle: a1,
+			padAngle: p
+		};
+		return arcs;
+	}
+	pie.value = function(_) {
+		return arguments.length ? (value = typeof _ === "function" ? _ : constant_default(+_), pie) : value;
+	};
+	pie.sortValues = function(_) {
+		return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;
+	};
+	pie.sort = function(_) {
+		return arguments.length ? (sort = _, sortValues = null, pie) : sort;
+	};
+	pie.startAngle = function(_) {
+		return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant_default(+_), pie) : startAngle;
+	};
+	pie.endAngle = function(_) {
+		return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant_default(+_), pie) : endAngle;
+	};
+	pie.padAngle = function(_) {
+		return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant_default(+_), pie) : padAngle;
+	};
+	return pie;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/pieDiagram-E7YTZNPT.mjs
+var DEFAULT_PIE_CONFIG = defaultConfig_default.pie;
+var DEFAULT_PIE_DB = {
+	sections: /* @__PURE__ */ new Map(),
+	showData: false,
+	config: DEFAULT_PIE_CONFIG
+};
+var sections = DEFAULT_PIE_DB.sections;
+var showData = DEFAULT_PIE_DB.showData;
+var config = structuredClone(DEFAULT_PIE_CONFIG);
+var db = {
+	getConfig: /* @__PURE__ */ __name(() => structuredClone(config), "getConfig"),
+	clear: /* @__PURE__ */ __name(() => {
+		sections = /* @__PURE__ */ new Map();
+		showData = DEFAULT_PIE_DB.showData;
+		clear();
+	}, "clear"),
+	setDiagramTitle,
+	getDiagramTitle,
+	setAccTitle,
+	getAccTitle,
+	setAccDescription,
+	getAccDescription,
+	addSection: /* @__PURE__ */ __name(({ label, value }) => {
+		if (value < 0) throw new Error(`"${label}" has invalid value: ${value}. Negative values are not allowed in pie charts. All slice values must be >= 0.`);
+		if (!sections.has(label)) {
+			sections.set(label, value);
+			log.debug(`added new section: ${label}, with value: ${value}`);
+		}
+	}, "addSection"),
+	getSections: /* @__PURE__ */ __name(() => sections, "getSections"),
+	setShowData: /* @__PURE__ */ __name((toggle) => {
+		showData = toggle;
+	}, "setShowData"),
+	getShowData: /* @__PURE__ */ __name(() => showData, "getShowData")
+};
+var populateDb = /* @__PURE__ */ __name((ast, db2) => {
+	populateCommonDb(ast, db2);
+	db2.setShowData(ast.showData);
+	ast.sections.map(db2.addSection);
+}, "populateDb");
+var parser = { parse: /* @__PURE__ */ __name(async (input) => {
+	const ast = await parse("pie", input);
+	log.debug(ast);
+	populateDb(ast, db);
+}, "parse") };
+var pieStyles_default = /* @__PURE__ */ __name((options) => `
+  .pieCircle{
+    stroke: ${options.pieStrokeColor};
+    stroke-width : ${options.pieStrokeWidth};
+    opacity : ${options.pieOpacity};
+  }
+  .pieCircle.highlighted{
+    scale: 1.05;
+    opacity: 1;
+  }
+  .pieCircle.highlightedOnHover:hover{
+    transition-duration: 250ms;
+    scale: 1.05;
+    opacity: 1;
+  }
+  .pieOuterCircle{
+    stroke: ${options.pieOuterStrokeColor};
+    stroke-width: ${options.pieOuterStrokeWidth};
+    fill: none;
+  }
+  .pieTitleText {
+    text-anchor: middle;
+    font-size: ${options.pieTitleTextSize};
+    fill: ${options.pieTitleTextColor};
+    font-family: ${options.fontFamily};
+  }
+  .slice {
+    font-family: ${options.fontFamily};
+    fill: ${options.pieSectionTextColor};
+    font-size:${options.pieSectionTextSize};
+    // fill: white;
+  }
+  .legend text {
+    fill: ${options.pieLegendTextColor};
+    font-family: ${options.fontFamily};
+    font-size: ${options.pieLegendTextSize};
+  }
+`, "getStyles");
+var createPieArcs = /* @__PURE__ */ __name((sections2) => {
+	const sum = [...sections2.values()].reduce((acc, val) => acc + val, 0);
+	const pieData = [...sections2.entries()].map(([label, value]) => ({
+		label,
+		value
+	})).filter((d) => d.value / sum * 100 >= 1);
+	return pie_default().value((d) => d.value).sort(null)(pieData);
+}, "createPieArcs");
+var diagram = {
+	parser,
+	db,
+	renderer: { draw: /* @__PURE__ */ __name((text, id, _version, diagObj) => {
+		log.debug("rendering pie chart\n" + text);
+		const db2 = diagObj.db;
+		const globalConfig = getConfig2();
+		const pieConfig = cleanAndMerge(db2.getConfig(), globalConfig.pie);
+		const MARGIN = 40;
+		const LEGEND_RECT_SIZE = 18;
+		const LEGEND_SPACING = 4;
+		const height = 450;
+		const pieWidth = height;
+		const svg = selectSvgElement(id);
+		const group = svg.append("g");
+		group.attr("transform", "translate(225,225)");
+		const { themeVariables } = globalConfig;
+		let [outerStrokeWidth] = parseFontSize(themeVariables.pieOuterStrokeWidth);
+		outerStrokeWidth ??= 2;
+		const legendPosition = pieConfig.legendPosition;
+		const textPosition = pieConfig.textPosition;
+		const innerHole = pieConfig.donutHole > 0 && pieConfig.donutHole <= .9 ? pieConfig.donutHole : 0;
+		const radius = Math.min(pieWidth, height) / 2 - MARGIN;
+		const arcGenerator = arc_default().innerRadius(innerHole * radius).outerRadius(radius);
+		const labelArcGenerator = arc_default().innerRadius(radius * textPosition).outerRadius(radius * textPosition);
+		const pie = group.append("g");
+		pie.append("circle").attr("cx", 0).attr("cy", 0).attr("r", radius + outerStrokeWidth / 2).attr("class", "pieOuterCircle");
+		const sections2 = db2.getSections();
+		const arcs = createPieArcs(sections2);
+		const myGeneratedColors = [
+			themeVariables.pie1,
+			themeVariables.pie2,
+			themeVariables.pie3,
+			themeVariables.pie4,
+			themeVariables.pie5,
+			themeVariables.pie6,
+			themeVariables.pie7,
+			themeVariables.pie8,
+			themeVariables.pie9,
+			themeVariables.pie10,
+			themeVariables.pie11,
+			themeVariables.pie12
+		];
+		let sum = 0;
+		sections2.forEach((section) => {
+			sum += section;
+		});
+		const filteredArcs = arcs.filter((datum) => (datum.data.value / sum * 100).toFixed(0) !== "0");
+		const color = ordinal(myGeneratedColors).domain([...sections2.keys()]);
+		pie.selectAll("mySlices").data(filteredArcs).enter().append("path").attr("d", arcGenerator).attr("fill", (datum) => {
+			return color(datum.data.label);
+		}).attr("class", (datum) => {
+			let className = "pieCircle";
+			if (pieConfig.highlightSlice === "hover") className += " highlightedOnHover";
+			else if (pieConfig.highlightSlice === datum.data.label) className += " highlighted";
+			return className;
+		});
+		pie.selectAll("mySlices").data(filteredArcs).enter().append("text").text((datum) => {
+			return (datum.data.value / sum * 100).toFixed(0) + "%";
+		}).attr("transform", (datum) => {
+			return "translate(" + labelArcGenerator.centroid(datum) + ")";
+		}).style("text-anchor", "middle").attr("class", "slice");
+		const titleText = group.append("text").text(db2.getDiagramTitle()).attr("x", 0).attr("y", -400 / 2).attr("class", "pieTitleText");
+		const allSectionData = [...sections2.entries()].map(([label, value]) => ({
+			label,
+			value
+		}));
+		const legend = group.selectAll(".legend").data(allSectionData).enter().append("g").attr("class", "legend");
+		legend.append("rect").attr("width", LEGEND_RECT_SIZE).attr("height", LEGEND_RECT_SIZE).style("fill", (d) => color(d.label)).style("stroke", (d) => color(d.label));
+		legend.append("text").attr("x", 22).attr("y", 14).text((d) => {
+			if (db2.getShowData()) return `${d.label} [${d.value}]`;
+			return d.label;
+		});
+		const longestTextWidth = Math.max(...legend.selectAll("text").nodes().map((node) => node?.getBoundingClientRect().width ?? 0));
+		let chartAndLegendHeight = height;
+		let chartAndLegendWidth = 490;
+		const legendHeight = 22;
+		const totalLegendHeight = allSectionData.length * legendHeight;
+		switch (legendPosition) {
+			case "center":
+				legend.attr("transform", (_datum, index) => {
+					const offset = legendHeight * allSectionData.length / 2;
+					const horizontal = -longestTextWidth / 2 - 22;
+					const vertical = index * legendHeight - offset;
+					return "translate(" + horizontal + "," + vertical + ")";
+				});
+				break;
+			case "top":
+				chartAndLegendHeight += totalLegendHeight;
+				legend.attr("transform", (_datum, index) => {
+					const offset = radius;
+					return `translate(${-longestTextWidth / 2 - 22}, ${index * legendHeight - offset})`;
+				});
+				pie.attr("transform", () => {
+					return `translate(0, ${totalLegendHeight + legendHeight})`;
+				});
+				break;
+			case "bottom":
+				chartAndLegendHeight += totalLegendHeight;
+				legend.attr("transform", (_datum, index) => {
+					const offset = -207;
+					const horizontal = -longestTextWidth / 2 - 22;
+					const vertical = index * legendHeight - offset;
+					return "translate(" + horizontal + "," + vertical + ")";
+				});
+				break;
+			case "left":
+				chartAndLegendWidth += 22 + longestTextWidth;
+				legend.attr("transform", (_datum, index) => {
+					const offset = legendHeight * allSectionData.length / 2;
+					return "translate(-207," + (index * legendHeight - offset) + ")";
+				});
+				pie.attr("transform", () => {
+					return `translate(${longestTextWidth + LEGEND_RECT_SIZE + LEGEND_SPACING}, 0)`;
+				});
+				break;
+			default:
+				chartAndLegendWidth += 22 + longestTextWidth;
+				legend.attr("transform", (_datum, index) => {
+					const offset = legendHeight * allSectionData.length / 2;
+					return "translate(216," + (index * legendHeight - offset) + ")";
+				});
+		}
+		const titleWidth = titleText.node()?.getBoundingClientRect().width ?? 0;
+		const titleLeft = pieWidth / 2 - titleWidth / 2;
+		const titleRight = pieWidth / 2 + titleWidth / 2;
+		const viewBoxX = Math.min(0, titleLeft);
+		const totalWidth = Math.max(chartAndLegendWidth, titleRight) - viewBoxX;
+		svg.attr("viewBox", `${viewBoxX} 0 ${totalWidth} ${chartAndLegendHeight}`);
+		configureSvgSize(svg, chartAndLegendHeight, totalWidth, pieConfig.useMaxWidth);
+	}, "draw") },
+	styles: pieStyles_default
+};
+
+//#endregion
+export { diagram };