@webskill/sdk 0.21.0 → 0.22.0

package/dist/gitGraphDiagram-X574FWY7-DKuxJymB.js

@@ -0,0 +1,1153 @@
+import { n as parse } from "./mermaid-parser.core-pYR5siSx.js";
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { m as log, p as select_default } from "./src-NkhI3UMl.js";
+import { H as setAccDescription, U as setAccTitle, X as setupGraphViewbox2, a as clear, b as getConfig, f as defaultConfig_default, q as setDiagramTitle, s as common_default, v as getAccDescription, w as getDiagramTitle, x as getConfig2, y as getAccTitle } from "./chunk-O7XYJQB3-B6K0KOSL.js";
+import { g as utils_default, i as cleanAndMerge, m as random } from "./chunk-ZIGJFQKS-DqEFBuHR.js";
+import { t as populateCommonDb } from "./chunk-JWPE2WC7-D1rC79GS.js";
+import { t as ImperativeState } from "./chunk-2Q5K7J3B-Ck03gkFR.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/gitGraphDiagram-X574FWY7.mjs
+var commitType = {
+	NORMAL: 0,
+	REVERSE: 1,
+	HIGHLIGHT: 2,
+	MERGE: 3,
+	CHERRY_PICK: 4
+};
+var DEFAULT_GITGRAPH_CONFIG = defaultConfig_default.gitGraph;
+var getConfig3 = /* @__PURE__ */ __name(() => {
+	return cleanAndMerge({
+		...DEFAULT_GITGRAPH_CONFIG,
+		...getConfig().gitGraph
+	});
+}, "getConfig");
+var state = new ImperativeState(() => {
+	const config = getConfig3();
+	const mainBranchName = config.mainBranchName;
+	const mainBranchOrder = config.mainBranchOrder;
+	return {
+		mainBranchName,
+		commits: /* @__PURE__ */ new Map(),
+		head: null,
+		branchConfig: /* @__PURE__ */ new Map([[mainBranchName, {
+			name: mainBranchName,
+			order: mainBranchOrder
+		}]]),
+		branches: /* @__PURE__ */ new Map([[mainBranchName, null]]),
+		currBranch: mainBranchName,
+		direction: "LR",
+		seq: 0,
+		options: {}
+	};
+});
+function getID() {
+	return random({ length: 7 });
+}
+__name(getID, "getID");
+function uniqBy(list, fn) {
+	const recordMap = /* @__PURE__ */ Object.create(null);
+	return list.reduce((out, item) => {
+		const key = fn(item);
+		if (!recordMap[key]) {
+			recordMap[key] = true;
+			out.push(item);
+		}
+		return out;
+	}, []);
+}
+__name(uniqBy, "uniqBy");
+var setDirection = /* @__PURE__ */ __name(function(dir2) {
+	state.records.direction = dir2;
+}, "setDirection");
+var setOptions = /* @__PURE__ */ __name(function(rawOptString) {
+	log.debug("options str", rawOptString);
+	rawOptString = rawOptString?.trim();
+	rawOptString = rawOptString || "{}";
+	try {
+		state.records.options = JSON.parse(rawOptString);
+	} catch (e) {
+		log.error("error while parsing gitGraph options", e.message);
+	}
+}, "setOptions");
+var getOptions = /* @__PURE__ */ __name(function() {
+	return state.records.options;
+}, "getOptions");
+var commit = /* @__PURE__ */ __name(function(commitDB) {
+	let msg = commitDB.msg;
+	let id = commitDB.id;
+	const type = commitDB.type;
+	let tags = commitDB.tags;
+	log.info("commit", msg, id, type, tags);
+	log.debug("Entering commit:", msg, id, type, tags);
+	const config = getConfig3();
+	id = common_default.sanitizeText(id, config);
+	msg = common_default.sanitizeText(msg, config);
+	tags = tags?.map((tag) => common_default.sanitizeText(tag, config));
+	const newCommit = {
+		id: id ? id : state.records.seq + "-" + getID(),
+		message: msg,
+		seq: state.records.seq++,
+		type: type ?? commitType.NORMAL,
+		tags: tags ?? [],
+		parents: state.records.head == null ? [] : [state.records.head.id],
+		branch: state.records.currBranch
+	};
+	state.records.head = newCommit;
+	log.info("main branch", config.mainBranchName);
+	if (state.records.commits.has(newCommit.id)) log.warn(`Commit ID ${newCommit.id} already exists`);
+	state.records.commits.set(newCommit.id, newCommit);
+	state.records.branches.set(state.records.currBranch, newCommit.id);
+	log.debug("in pushCommit " + newCommit.id);
+}, "commit");
+var branch = /* @__PURE__ */ __name(function(branchDB) {
+	let name = branchDB.name;
+	const order = branchDB.order;
+	name = common_default.sanitizeText(name, getConfig3());
+	if (state.records.branches.has(name)) throw new Error(`Trying to create an existing branch. (Help: Either use a new name if you want create a new branch or try using "checkout ${name}")`);
+	state.records.branches.set(name, state.records.head != null ? state.records.head.id : null);
+	state.records.branchConfig.set(name, {
+		name,
+		order
+	});
+	checkout(name);
+	log.debug("in createBranch");
+}, "branch");
+var merge = /* @__PURE__ */ __name((mergeDB) => {
+	let otherBranch = mergeDB.branch;
+	let customId = mergeDB.id;
+	const overrideType = mergeDB.type;
+	const customTags = mergeDB.tags;
+	const config = getConfig3();
+	otherBranch = common_default.sanitizeText(otherBranch, config);
+	if (customId) customId = common_default.sanitizeText(customId, config);
+	const currentBranchCheck = state.records.branches.get(state.records.currBranch);
+	const otherBranchCheck = state.records.branches.get(otherBranch);
+	const currentCommit = currentBranchCheck ? state.records.commits.get(currentBranchCheck) : void 0;
+	const otherCommit = otherBranchCheck ? state.records.commits.get(otherBranchCheck) : void 0;
+	if (currentCommit && otherCommit && currentCommit.branch === otherBranch) throw new Error(`Cannot merge branch '${otherBranch}' into itself.`);
+	if (state.records.currBranch === otherBranch) {
+		const error = /* @__PURE__ */ new Error("Incorrect usage of \"merge\". Cannot merge a branch to itself");
+		error.hash = {
+			text: `merge ${otherBranch}`,
+			token: `merge ${otherBranch}`,
+			expected: ["branch abc"]
+		};
+		throw error;
+	}
+	if (currentCommit === void 0 || !currentCommit) {
+		const error = /* @__PURE__ */ new Error(`Incorrect usage of "merge". Current branch (${state.records.currBranch})has no commits`);
+		error.hash = {
+			text: `merge ${otherBranch}`,
+			token: `merge ${otherBranch}`,
+			expected: ["commit"]
+		};
+		throw error;
+	}
+	if (!state.records.branches.has(otherBranch)) {
+		const error = /* @__PURE__ */ new Error("Incorrect usage of \"merge\". Branch to be merged (" + otherBranch + ") does not exist");
+		error.hash = {
+			text: `merge ${otherBranch}`,
+			token: `merge ${otherBranch}`,
+			expected: [`branch ${otherBranch}`]
+		};
+		throw error;
+	}
+	if (otherCommit === void 0 || !otherCommit) {
+		const error = /* @__PURE__ */ new Error("Incorrect usage of \"merge\". Branch to be merged (" + otherBranch + ") has no commits");
+		error.hash = {
+			text: `merge ${otherBranch}`,
+			token: `merge ${otherBranch}`,
+			expected: ["\"commit\""]
+		};
+		throw error;
+	}
+	if (currentCommit === otherCommit) {
+		const error = /* @__PURE__ */ new Error("Incorrect usage of \"merge\". Both branches have same head");
+		error.hash = {
+			text: `merge ${otherBranch}`,
+			token: `merge ${otherBranch}`,
+			expected: ["branch abc"]
+		};
+		throw error;
+	}
+	if (customId && state.records.commits.has(customId)) {
+		const error = /* @__PURE__ */ new Error("Incorrect usage of \"merge\". Commit with id:" + customId + " already exists, use different custom id");
+		error.hash = {
+			text: `merge ${otherBranch} ${customId} ${overrideType} ${customTags?.join(" ")}`,
+			token: `merge ${otherBranch} ${customId} ${overrideType} ${customTags?.join(" ")}`,
+			expected: [`merge ${otherBranch} ${customId}_UNIQUE ${overrideType} ${customTags?.join(" ")}`]
+		};
+		throw error;
+	}
+	const verifiedBranch = otherBranchCheck ? otherBranchCheck : "";
+	const commit2 = {
+		id: customId || `${state.records.seq}-${getID()}`,
+		message: `merged branch ${otherBranch} into ${state.records.currBranch}`,
+		seq: state.records.seq++,
+		parents: state.records.head == null ? [] : [state.records.head.id, verifiedBranch],
+		branch: state.records.currBranch,
+		type: commitType.MERGE,
+		customType: overrideType,
+		customId: customId ? true : false,
+		tags: customTags ?? []
+	};
+	state.records.head = commit2;
+	state.records.commits.set(commit2.id, commit2);
+	state.records.branches.set(state.records.currBranch, commit2.id);
+	log.debug(state.records.branches);
+	log.debug("in mergeBranch");
+}, "merge");
+var cherryPick = /* @__PURE__ */ __name(function(cherryPickDB) {
+	let sourceId = cherryPickDB.id;
+	let targetId = cherryPickDB.targetId;
+	let tags = cherryPickDB.tags;
+	let parentCommitId = cherryPickDB.parent;
+	log.debug("Entering cherryPick:", sourceId, targetId, tags);
+	const config = getConfig3();
+	sourceId = common_default.sanitizeText(sourceId, config);
+	targetId = common_default.sanitizeText(targetId, config);
+	tags = tags?.map((tag) => common_default.sanitizeText(tag, config));
+	parentCommitId = common_default.sanitizeText(parentCommitId, config);
+	if (!sourceId || !state.records.commits.has(sourceId)) {
+		const error = /* @__PURE__ */ new Error("Incorrect usage of \"cherryPick\". Source commit id should exist and provided");
+		error.hash = {
+			text: `cherryPick ${sourceId} ${targetId}`,
+			token: `cherryPick ${sourceId} ${targetId}`,
+			expected: ["cherry-pick abc"]
+		};
+		throw error;
+	}
+	const sourceCommit = state.records.commits.get(sourceId);
+	if (sourceCommit === void 0 || !sourceCommit) throw new Error("Incorrect usage of \"cherryPick\". Source commit id should exist and provided");
+	if (parentCommitId && !(Array.isArray(sourceCommit.parents) && sourceCommit.parents.includes(parentCommitId))) throw /* @__PURE__ */ new Error("Invalid operation: The specified parent commit is not an immediate parent of the cherry-picked commit.");
+	const sourceCommitBranch = sourceCommit.branch;
+	if (sourceCommit.type === commitType.MERGE && !parentCommitId) throw /* @__PURE__ */ new Error("Incorrect usage of cherry-pick: If the source commit is a merge commit, an immediate parent commit must be specified.");
+	if (!targetId || !state.records.commits.has(targetId)) {
+		if (sourceCommitBranch === state.records.currBranch) {
+			const error = /* @__PURE__ */ new Error("Incorrect usage of \"cherryPick\". Source commit is already on current branch");
+			error.hash = {
+				text: `cherryPick ${sourceId} ${targetId}`,
+				token: `cherryPick ${sourceId} ${targetId}`,
+				expected: ["cherry-pick abc"]
+			};
+			throw error;
+		}
+		const currentCommitId = state.records.branches.get(state.records.currBranch);
+		if (currentCommitId === void 0 || !currentCommitId) {
+			const error = /* @__PURE__ */ new Error(`Incorrect usage of "cherry-pick". Current branch (${state.records.currBranch})has no commits`);
+			error.hash = {
+				text: `cherryPick ${sourceId} ${targetId}`,
+				token: `cherryPick ${sourceId} ${targetId}`,
+				expected: ["cherry-pick abc"]
+			};
+			throw error;
+		}
+		const currentCommit = state.records.commits.get(currentCommitId);
+		if (currentCommit === void 0 || !currentCommit) {
+			const error = /* @__PURE__ */ new Error(`Incorrect usage of "cherry-pick". Current branch (${state.records.currBranch})has no commits`);
+			error.hash = {
+				text: `cherryPick ${sourceId} ${targetId}`,
+				token: `cherryPick ${sourceId} ${targetId}`,
+				expected: ["cherry-pick abc"]
+			};
+			throw error;
+		}
+		const commit2 = {
+			id: state.records.seq + "-" + getID(),
+			message: `cherry-picked ${sourceCommit?.message} into ${state.records.currBranch}`,
+			seq: state.records.seq++,
+			parents: state.records.head == null ? [] : [state.records.head.id, sourceCommit.id],
+			branch: state.records.currBranch,
+			type: commitType.CHERRY_PICK,
+			tags: tags ? tags.filter(Boolean) : [`cherry-pick:${sourceCommit.id}${sourceCommit.type === commitType.MERGE ? `|parent:${parentCommitId}` : ""}`]
+		};
+		state.records.head = commit2;
+		state.records.commits.set(commit2.id, commit2);
+		state.records.branches.set(state.records.currBranch, commit2.id);
+		log.debug(state.records.branches);
+		log.debug("in cherryPick");
+	}
+}, "cherryPick");
+var checkout = /* @__PURE__ */ __name(function(branch2) {
+	branch2 = common_default.sanitizeText(branch2, getConfig3());
+	if (!state.records.branches.has(branch2)) {
+		const error = /* @__PURE__ */ new Error(`Trying to checkout branch which is not yet created. (Help try using "branch ${branch2}")`);
+		error.hash = {
+			text: `checkout ${branch2}`,
+			token: `checkout ${branch2}`,
+			expected: [`branch ${branch2}`]
+		};
+		throw error;
+	} else {
+		state.records.currBranch = branch2;
+		const id = state.records.branches.get(state.records.currBranch);
+		if (id === void 0 || !id) state.records.head = null;
+		else state.records.head = state.records.commits.get(id) ?? null;
+	}
+}, "checkout");
+function upsert(arr, key, newVal) {
+	const index = arr.indexOf(key);
+	if (index === -1) arr.push(newVal);
+	else arr.splice(index, 1, newVal);
+}
+__name(upsert, "upsert");
+function prettyPrintCommitHistory(commitArr) {
+	const commit2 = commitArr.reduce((out, commit3) => {
+		if (out.seq > commit3.seq) return out;
+		return commit3;
+	}, commitArr[0]);
+	let line = "";
+	commitArr.forEach(function(c) {
+		if (c === commit2) line += "	*";
+		else line += "	|";
+	});
+	const label = [
+		line,
+		commit2.id,
+		commit2.seq
+	];
+	for (const branch2 in state.records.branches) if (state.records.branches.get(branch2) === commit2.id) label.push(branch2);
+	log.debug(label.join(" "));
+	if (commit2.parents && commit2.parents.length == 2 && commit2.parents[0] && commit2.parents[1]) {
+		const newCommit = state.records.commits.get(commit2.parents[0]);
+		upsert(commitArr, commit2, newCommit);
+		if (commit2.parents[1]) commitArr.push(state.records.commits.get(commit2.parents[1]));
+	} else if (commit2.parents.length == 0) return;
+	else if (commit2.parents[0]) {
+		const newCommit = state.records.commits.get(commit2.parents[0]);
+		upsert(commitArr, commit2, newCommit);
+	}
+	commitArr = uniqBy(commitArr, (c) => c.id);
+	prettyPrintCommitHistory(commitArr);
+}
+__name(prettyPrintCommitHistory, "prettyPrintCommitHistory");
+var prettyPrint = /* @__PURE__ */ __name(function() {
+	log.debug(state.records.commits);
+	const node = getCommitsArray()[0];
+	prettyPrintCommitHistory([node]);
+}, "prettyPrint");
+var clear2 = /* @__PURE__ */ __name(function() {
+	state.reset();
+	clear();
+}, "clear");
+var getBranchesAsObjArray = /* @__PURE__ */ __name(function() {
+	return [...state.records.branchConfig.values()].map((branchConfig, i) => {
+		if (branchConfig.order !== null && branchConfig.order !== void 0) return branchConfig;
+		return {
+			...branchConfig,
+			order: parseFloat(`0.${i}`)
+		};
+	}).sort((a, b) => (a.order ?? 0) - (b.order ?? 0)).map(({ name }) => ({ name }));
+}, "getBranchesAsObjArray");
+var getBranches = /* @__PURE__ */ __name(function() {
+	return state.records.branches;
+}, "getBranches");
+var getCommits = /* @__PURE__ */ __name(function() {
+	return state.records.commits;
+}, "getCommits");
+var getCommitsArray = /* @__PURE__ */ __name(function() {
+	const commitArr = [...state.records.commits.values()];
+	commitArr.forEach(function(o) {
+		log.debug(o.id);
+	});
+	commitArr.sort((a, b) => a.seq - b.seq);
+	return commitArr;
+}, "getCommitsArray");
+var db = {
+	commitType,
+	getConfig: getConfig3,
+	setDirection,
+	setOptions,
+	getOptions,
+	commit,
+	branch,
+	merge,
+	cherryPick,
+	checkout,
+	prettyPrint,
+	clear: clear2,
+	getBranchesAsObjArray,
+	getBranches,
+	getCommits,
+	getCommitsArray,
+	getCurrentBranch: /* @__PURE__ */ __name(function() {
+		return state.records.currBranch;
+	}, "getCurrentBranch"),
+	getDirection: /* @__PURE__ */ __name(function() {
+		return state.records.direction;
+	}, "getDirection"),
+	getHead: /* @__PURE__ */ __name(function() {
+		return state.records.head;
+	}, "getHead"),
+	setAccTitle,
+	getAccTitle,
+	getAccDescription,
+	setAccDescription,
+	setDiagramTitle,
+	getDiagramTitle
+};
+var populate = /* @__PURE__ */ __name((ast, db2) => {
+	populateCommonDb(ast, db2);
+	if (ast.dir) db2.setDirection(ast.dir);
+	for (const statement of ast.statements) parseStatement(statement, db2);
+}, "populate");
+var parseStatement = /* @__PURE__ */ __name((statement, db2) => {
+	const parser2 = {
+		Commit: /* @__PURE__ */ __name((stmt) => db2.commit(parseCommit(stmt)), "Commit"),
+		Branch: /* @__PURE__ */ __name((stmt) => db2.branch(parseBranch(stmt)), "Branch"),
+		Merge: /* @__PURE__ */ __name((stmt) => db2.merge(parseMerge(stmt)), "Merge"),
+		Checkout: /* @__PURE__ */ __name((stmt) => db2.checkout(parseCheckout(stmt)), "Checkout"),
+		CherryPicking: /* @__PURE__ */ __name((stmt) => db2.cherryPick(parseCherryPicking(stmt)), "CherryPicking")
+	}[statement.$type];
+	if (parser2) parser2(statement);
+	else log.error(`Unknown statement type: ${statement.$type}`);
+}, "parseStatement");
+var parseCommit = /* @__PURE__ */ __name((commit2) => {
+	return {
+		id: commit2.id,
+		msg: commit2.message ?? "",
+		type: commit2.type !== void 0 ? commitType[commit2.type] : commitType.NORMAL,
+		tags: commit2.tags ?? void 0
+	};
+}, "parseCommit");
+var parseBranch = /* @__PURE__ */ __name((branch2) => {
+	return {
+		name: branch2.name,
+		order: branch2.order ?? 0
+	};
+}, "parseBranch");
+var parseMerge = /* @__PURE__ */ __name((merge2) => {
+	return {
+		branch: merge2.branch,
+		id: merge2.id ?? "",
+		type: merge2.type !== void 0 ? commitType[merge2.type] : void 0,
+		tags: merge2.tags ?? void 0
+	};
+}, "parseMerge");
+var parseCheckout = /* @__PURE__ */ __name((checkout2) => {
+	return checkout2.branch;
+}, "parseCheckout");
+var parseCherryPicking = /* @__PURE__ */ __name((cherryPicking) => {
+	return {
+		id: cherryPicking.id,
+		targetId: "",
+		tags: cherryPicking.tags?.length === 0 ? void 0 : cherryPicking.tags,
+		parent: cherryPicking.parent
+	};
+}, "parseCherryPicking");
+var parser = { parse: /* @__PURE__ */ __name(async (input) => {
+	const ast = await parse("gitGraph", input);
+	log.debug(ast);
+	populate(ast, db);
+}, "parse") };
+var LAYOUT_OFFSET = 10;
+var COMMIT_STEP = 40;
+var PX = 4;
+var PY = 2;
+var THEME_COLOR_LIMIT = 8;
+var REDUX_GEOMETRY_THEMES = /* @__PURE__ */ new Set([
+	"redux",
+	"redux-dark",
+	"redux-color",
+	"redux-dark-color"
+]);
+var REDUX_BRANCH_LABEL_PADDING_Y = 12;
+var COLOR_THEMES = /* @__PURE__ */ new Set(["redux-color", "redux-dark-color"]);
+var DARK_THEMES = /* @__PURE__ */ new Set([
+	"dark",
+	"redux-dark",
+	"redux-dark-color",
+	"neo-dark"
+]);
+var calcColorIndex = /* @__PURE__ */ __name((rawIndex, limit, avoidDefaultColor = false) => {
+	if (avoidDefaultColor && rawIndex > 0) return (rawIndex - 1) % (limit - 1) + 1;
+	return rawIndex % limit;
+}, "calcColorIndex");
+var branchPos = /* @__PURE__ */ new Map();
+var commitPos = /* @__PURE__ */ new Map();
+var defaultPos = 30;
+var allCommitsDict = /* @__PURE__ */ new Map();
+var lanes = [];
+var maxPos = 0;
+var dir = "LR";
+var clear3 = /* @__PURE__ */ __name(() => {
+	branchPos.clear();
+	commitPos.clear();
+	allCommitsDict.clear();
+	maxPos = 0;
+	lanes = [];
+	dir = "LR";
+}, "clear");
+var drawText = /* @__PURE__ */ __name((txt) => {
+	const svgLabel = document.createElementNS("http://www.w3.org/2000/svg", "text");
+	(typeof txt === "string" ? txt.split(/\\n|\n|<br\s*\/?>/gi) : txt).forEach((row) => {
+		const tspan = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+		tspan.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
+		tspan.setAttribute("dy", "1em");
+		tspan.setAttribute("x", "0");
+		tspan.setAttribute("class", "row");
+		tspan.textContent = row.trim();
+		svgLabel.appendChild(tspan);
+	});
+	return svgLabel;
+}, "drawText");
+var findClosestParent = /* @__PURE__ */ __name((parents) => {
+	let closestParent;
+	let comparisonFunc;
+	let targetPosition;
+	if (dir === "BT") {
+		comparisonFunc = /* @__PURE__ */ __name((a, b) => a <= b, "comparisonFunc");
+		targetPosition = Infinity;
+	} else {
+		comparisonFunc = /* @__PURE__ */ __name((a, b) => a >= b, "comparisonFunc");
+		targetPosition = 0;
+	}
+	parents.forEach((parent) => {
+		const parentPosition = dir === "TB" || dir == "BT" ? commitPos.get(parent)?.y : commitPos.get(parent)?.x;
+		if (parentPosition !== void 0 && comparisonFunc(parentPosition, targetPosition)) {
+			closestParent = parent;
+			targetPosition = parentPosition;
+		}
+	});
+	return closestParent;
+}, "findClosestParent");
+var findClosestParentBT = /* @__PURE__ */ __name((parents) => {
+	let closestParent = "";
+	let maxPosition = Infinity;
+	parents.forEach((parent) => {
+		const parentPosition = commitPos.get(parent).y;
+		if (parentPosition <= maxPosition) {
+			closestParent = parent;
+			maxPosition = parentPosition;
+		}
+	});
+	return closestParent || void 0;
+}, "findClosestParentBT");
+var setParallelBTPos = /* @__PURE__ */ __name((sortedKeys, commits, defaultPos2) => {
+	let curPos = defaultPos2;
+	let maxPosition = defaultPos2;
+	const roots = [];
+	sortedKeys.forEach((key) => {
+		const commit2 = commits.get(key);
+		if (!commit2) throw new Error(`Commit not found for key ${key}`);
+		if (commit2.parents.length) {
+			curPos = calculateCommitPosition(commit2);
+			maxPosition = Math.max(curPos, maxPosition);
+		} else roots.push(commit2);
+		setCommitPosition(commit2, curPos);
+	});
+	curPos = maxPosition;
+	roots.forEach((commit2) => {
+		setRootPosition(commit2, curPos, defaultPos2);
+	});
+	sortedKeys.forEach((key) => {
+		const commit2 = commits.get(key);
+		if (commit2?.parents.length) {
+			const closestParent = findClosestParentBT(commit2.parents);
+			curPos = commitPos.get(closestParent).y - COMMIT_STEP;
+			if (curPos <= maxPosition) maxPosition = curPos;
+			const x = branchPos.get(commit2.branch).pos;
+			const y = curPos - LAYOUT_OFFSET;
+			commitPos.set(commit2.id, {
+				x,
+				y
+			});
+		}
+	});
+}, "setParallelBTPos");
+var findClosestParentPos = /* @__PURE__ */ __name((commit2) => {
+	const closestParent = findClosestParent(commit2.parents.filter((p) => p !== null));
+	if (!closestParent) throw new Error(`Closest parent not found for commit ${commit2.id}`);
+	const closestParentPos = commitPos.get(closestParent)?.y;
+	if (closestParentPos === void 0) throw new Error(`Closest parent position not found for commit ${commit2.id}`);
+	return closestParentPos;
+}, "findClosestParentPos");
+var calculateCommitPosition = /* @__PURE__ */ __name((commit2) => {
+	return findClosestParentPos(commit2) + COMMIT_STEP;
+}, "calculateCommitPosition");
+var setCommitPosition = /* @__PURE__ */ __name((commit2, curPos) => {
+	const branch2 = branchPos.get(commit2.branch);
+	if (!branch2) throw new Error(`Branch not found for commit ${commit2.id}`);
+	const x = branch2.pos;
+	const y = curPos + LAYOUT_OFFSET;
+	commitPos.set(commit2.id, {
+		x,
+		y
+	});
+	return {
+		x,
+		y
+	};
+}, "setCommitPosition");
+var setRootPosition = /* @__PURE__ */ __name((commit2, curPos, defaultPos2) => {
+	const branch2 = branchPos.get(commit2.branch);
+	if (!branch2) throw new Error(`Branch not found for commit ${commit2.id}`);
+	const y = curPos + defaultPos2;
+	const x = branch2.pos;
+	commitPos.set(commit2.id, {
+		x,
+		y
+	});
+}, "setRootPosition");
+var drawCommitBullet = /* @__PURE__ */ __name((gBullets, commit2, commitPosition, typeClass, branchIndex, commitSymbolType) => {
+	const { theme } = getConfig2();
+	const useReduxGeometry = REDUX_GEOMETRY_THEMES.has(theme ?? "");
+	const useColorTheme = COLOR_THEMES.has(theme ?? "");
+	const isDark = DARK_THEMES.has(theme ?? "");
+	if (commitSymbolType === commitType.HIGHLIGHT) {
+		gBullets.append("rect").attr("x", commitPosition.x - 10 + (useReduxGeometry ? 3 : 0)).attr("y", commitPosition.y - 10 + (useReduxGeometry ? 3 : 0)).attr("width", useReduxGeometry ? 14 : 20).attr("height", useReduxGeometry ? 14 : 20).attr("class", `commit ${commit2.id} commit-highlight${calcColorIndex(branchIndex, THEME_COLOR_LIMIT, useColorTheme)} ${typeClass}-outer`);
+		gBullets.append("rect").attr("x", commitPosition.x - 6 + (useReduxGeometry ? 2 : 0)).attr("y", commitPosition.y - 6 + (useReduxGeometry ? 2 : 0)).attr("width", useReduxGeometry ? 8 : 12).attr("height", useReduxGeometry ? 8 : 12).attr("class", `commit ${commit2.id} commit${calcColorIndex(branchIndex, THEME_COLOR_LIMIT, useColorTheme)} ${typeClass}-inner`);
+	} else if (commitSymbolType === commitType.CHERRY_PICK) {
+		gBullets.append("circle").attr("cx", commitPosition.x).attr("cy", commitPosition.y).attr("r", useReduxGeometry ? 7 : 10).attr("class", `commit ${commit2.id} ${typeClass}`);
+		gBullets.append("circle").attr("cx", commitPosition.x - 3).attr("cy", commitPosition.y + 2).attr("r", useReduxGeometry ? 2.5 : 2.75).attr("fill", isDark ? "#000000" : "#fff").attr("class", `commit ${commit2.id} ${typeClass}`);
+		gBullets.append("circle").attr("cx", commitPosition.x + 3).attr("cy", commitPosition.y + 2).attr("r", useReduxGeometry ? 2.5 : 2.75).attr("fill", isDark ? "#000000" : "#fff").attr("class", `commit ${commit2.id} ${typeClass}`);
+		gBullets.append("line").attr("x1", commitPosition.x + 3).attr("y1", commitPosition.y + 1).attr("x2", commitPosition.x).attr("y2", commitPosition.y - 5).attr("stroke", isDark ? "#000000" : "#fff").attr("class", `commit ${commit2.id} ${typeClass}`);
+		gBullets.append("line").attr("x1", commitPosition.x - 3).attr("y1", commitPosition.y + 1).attr("x2", commitPosition.x).attr("y2", commitPosition.y - 5).attr("stroke", isDark ? "#000000" : "#fff").attr("class", `commit ${commit2.id} ${typeClass}`);
+	} else {
+		const circle = gBullets.append("circle");
+		circle.attr("cx", commitPosition.x);
+		circle.attr("cy", commitPosition.y);
+		circle.attr("r", useReduxGeometry ? 7 : 10);
+		circle.attr("class", `commit ${commit2.id} commit${calcColorIndex(branchIndex, THEME_COLOR_LIMIT, useColorTheme)}`);
+		if (commitSymbolType === commitType.MERGE) {
+			const circle2 = gBullets.append("circle");
+			circle2.attr("cx", commitPosition.x);
+			circle2.attr("cy", commitPosition.y);
+			circle2.attr("r", useReduxGeometry ? 5 : 6);
+			circle2.attr("class", `commit ${typeClass} ${commit2.id} commit${calcColorIndex(branchIndex, THEME_COLOR_LIMIT, useColorTheme)}`);
+		}
+		if (commitSymbolType === commitType.REVERSE) {
+			const cross = gBullets.append("path");
+			const constValue = useReduxGeometry ? 4 : 5;
+			cross.attr("d", `M ${commitPosition.x - constValue},${commitPosition.y - constValue}L${commitPosition.x + constValue},${commitPosition.y + constValue}M${commitPosition.x - constValue},${commitPosition.y + constValue}L${commitPosition.x + constValue},${commitPosition.y - constValue}`).attr("class", `commit ${typeClass} ${commit2.id} commit${calcColorIndex(branchIndex, THEME_COLOR_LIMIT, useColorTheme)}`);
+		}
+	}
+}, "drawCommitBullet");
+var drawCommitLabel = /* @__PURE__ */ __name((gLabels, commit2, commitPosition, pos, gitGraphConfig) => {
+	if (commit2.type !== commitType.CHERRY_PICK && (commit2.customId && commit2.type === commitType.MERGE || commit2.type !== commitType.MERGE) && gitGraphConfig.showCommitLabel) {
+		const wrapper = gLabels.append("g");
+		const labelBkg = wrapper.insert("rect").attr("class", "commit-label-bkg");
+		const text = wrapper.append("text").attr("x", pos).attr("y", commitPosition.y + 25).attr("class", "commit-label").text(commit2.id);
+		const bbox = text.node()?.getBBox();
+		if (bbox) {
+			labelBkg.attr("x", commitPosition.posWithOffset - bbox.width / 2 - PY).attr("y", commitPosition.y + 13.5).attr("width", bbox.width + 2 * PY).attr("height", bbox.height + 2 * PY);
+			if (dir === "TB" || dir === "BT") {
+				labelBkg.attr("x", commitPosition.x - (bbox.width + 4 * PX + 5)).attr("y", commitPosition.y - 12);
+				text.attr("x", commitPosition.x - (bbox.width + 4 * PX)).attr("y", commitPosition.y + bbox.height - 12);
+			} else text.attr("x", commitPosition.posWithOffset - bbox.width / 2);
+			if (gitGraphConfig.rotateCommitLabel) if (dir === "TB" || dir === "BT") {
+				text.attr("transform", "rotate(-45, " + commitPosition.x + ", " + commitPosition.y + ")");
+				labelBkg.attr("transform", "rotate(-45, " + commitPosition.x + ", " + commitPosition.y + ")");
+			} else {
+				const r_x = -7.5 - (bbox.width + 10) / 25 * 9.5;
+				const r_y = 10 + bbox.width / 25 * 8.5;
+				wrapper.attr("transform", "translate(" + r_x + ", " + r_y + ") rotate(-45, " + pos + ", " + commitPosition.y + ")");
+			}
+		}
+	}
+}, "drawCommitLabel");
+var drawCommitTags = /* @__PURE__ */ __name((gLabels, commit2, commitPosition, pos) => {
+	if (commit2.tags.length > 0) {
+		let yOffset = 0;
+		let maxTagBboxWidth = 0;
+		let maxTagBboxHeight = 0;
+		const tagElements = [];
+		for (const tagValue of commit2.tags.reverse()) {
+			const rect = gLabels.insert("polygon");
+			const hole = gLabels.append("circle");
+			const tag = gLabels.append("text").attr("y", commitPosition.y - 16 - yOffset).attr("class", "tag-label").text(tagValue);
+			const tagBbox = tag.node()?.getBBox();
+			if (!tagBbox) throw new Error("Tag bbox not found");
+			maxTagBboxWidth = Math.max(maxTagBboxWidth, tagBbox.width);
+			maxTagBboxHeight = Math.max(maxTagBboxHeight, tagBbox.height);
+			tag.attr("x", commitPosition.posWithOffset - tagBbox.width / 2);
+			tagElements.push({
+				tag,
+				hole,
+				rect,
+				yOffset
+			});
+			yOffset += 20;
+		}
+		for (const { tag, hole, rect, yOffset: yOffset2 } of tagElements) {
+			const h2 = maxTagBboxHeight / 2;
+			const ly = commitPosition.y - 19.2 - yOffset2;
+			rect.attr("class", "tag-label-bkg").attr("points", `
+      ${pos - maxTagBboxWidth / 2 - PX / 2},${ly + PY}  
+      ${pos - maxTagBboxWidth / 2 - PX / 2},${ly - PY}
+      ${commitPosition.posWithOffset - maxTagBboxWidth / 2 - PX},${ly - h2 - PY}
+      ${commitPosition.posWithOffset + maxTagBboxWidth / 2 + PX},${ly - h2 - PY}
+      ${commitPosition.posWithOffset + maxTagBboxWidth / 2 + PX},${ly + h2 + PY}
+      ${commitPosition.posWithOffset - maxTagBboxWidth / 2 - PX},${ly + h2 + PY}`);
+			hole.attr("cy", ly).attr("cx", pos - maxTagBboxWidth / 2 + PX / 2).attr("r", 1.5).attr("class", "tag-hole");
+			if (dir === "TB" || dir === "BT") {
+				const yOrigin = pos + yOffset2;
+				rect.attr("class", "tag-label-bkg").attr("points", `
+        ${commitPosition.x},${yOrigin + 2}
+        ${commitPosition.x},${yOrigin - 2}
+        ${commitPosition.x + LAYOUT_OFFSET},${yOrigin - h2 - 2}
+        ${commitPosition.x + LAYOUT_OFFSET + maxTagBboxWidth + 4},${yOrigin - h2 - 2}
+        ${commitPosition.x + LAYOUT_OFFSET + maxTagBboxWidth + 4},${yOrigin + h2 + 2}
+        ${commitPosition.x + LAYOUT_OFFSET},${yOrigin + h2 + 2}`).attr("transform", "translate(12,12) rotate(45, " + commitPosition.x + "," + pos + ")");
+				hole.attr("cx", commitPosition.x + PX / 2).attr("cy", yOrigin).attr("transform", "translate(12,12) rotate(45, " + commitPosition.x + "," + pos + ")");
+				tag.attr("x", commitPosition.x + 5).attr("y", yOrigin + 3).attr("transform", "translate(14,14) rotate(45, " + commitPosition.x + "," + pos + ")");
+			}
+		}
+	}
+}, "drawCommitTags");
+var getCommitClassType = /* @__PURE__ */ __name((commit2) => {
+	switch (commit2.customType ?? commit2.type) {
+		case commitType.NORMAL: return "commit-normal";
+		case commitType.REVERSE: return "commit-reverse";
+		case commitType.HIGHLIGHT: return "commit-highlight";
+		case commitType.MERGE: return "commit-merge";
+		case commitType.CHERRY_PICK: return "commit-cherry-pick";
+		default: return "commit-normal";
+	}
+}, "getCommitClassType");
+var calculatePosition = /* @__PURE__ */ __name((commit2, dir2, pos, commitPos2) => {
+	const defaultCommitPosition = {
+		x: 0,
+		y: 0
+	};
+	if (commit2.parents.length > 0) {
+		const closestParent = findClosestParent(commit2.parents);
+		if (closestParent) {
+			const parentPosition = commitPos2.get(closestParent) ?? defaultCommitPosition;
+			if (dir2 === "TB") return parentPosition.y + COMMIT_STEP;
+			else if (dir2 === "BT") return (commitPos2.get(commit2.id) ?? defaultCommitPosition).y - COMMIT_STEP;
+			else return parentPosition.x + COMMIT_STEP;
+		}
+	} else if (dir2 === "TB") return defaultPos;
+	else if (dir2 === "BT") return (commitPos2.get(commit2.id) ?? defaultCommitPosition).y - COMMIT_STEP;
+	else return 0;
+	return 0;
+}, "calculatePosition");
+var getCommitPosition = /* @__PURE__ */ __name((commit2, pos, isParallelCommits) => {
+	const posWithOffset = dir === "BT" && isParallelCommits ? pos : pos + LAYOUT_OFFSET;
+	const branchY = branchPos.get(commit2.branch)?.pos;
+	const x = dir === "TB" || dir === "BT" ? branchPos.get(commit2.branch)?.pos : posWithOffset;
+	if (x === void 0 || branchY === void 0) throw new Error(`Position were undefined for commit ${commit2.id}`);
+	const useReduxGeometry = REDUX_GEOMETRY_THEMES.has(getConfig2().theme ?? "");
+	return {
+		x,
+		y: dir === "TB" || dir === "BT" ? posWithOffset : branchY + (useReduxGeometry ? REDUX_BRANCH_LABEL_PADDING_Y / 2 + 1 : -2),
+		posWithOffset
+	};
+}, "getCommitPosition");
+var drawCommits = /* @__PURE__ */ __name((svg, commits, modifyGraph, gitGraphConfig) => {
+	const gBullets = svg.append("g").attr("class", "commit-bullets");
+	const gLabels = svg.append("g").attr("class", "commit-labels");
+	let pos = dir === "TB" || dir === "BT" ? defaultPos : 0;
+	const keys = [...commits.keys()];
+	const isParallelCommits = gitGraphConfig.parallelCommits ?? false;
+	const sortKeys = /* @__PURE__ */ __name((a, b) => {
+		const seqA = commits.get(a)?.seq;
+		const seqB = commits.get(b)?.seq;
+		return seqA !== void 0 && seqB !== void 0 ? seqA - seqB : 0;
+	}, "sortKeys");
+	let sortedKeys = keys.sort(sortKeys);
+	if (dir === "BT") {
+		if (isParallelCommits) setParallelBTPos(sortedKeys, commits, pos);
+		sortedKeys = sortedKeys.reverse();
+	}
+	sortedKeys.forEach((key) => {
+		const commit2 = commits.get(key);
+		if (!commit2) throw new Error(`Commit not found for key ${key}`);
+		if (isParallelCommits) pos = calculatePosition(commit2, dir, pos, commitPos);
+		const commitPosition = getCommitPosition(commit2, pos, isParallelCommits);
+		if (modifyGraph) {
+			const typeClass = getCommitClassType(commit2);
+			const commitSymbolType = commit2.customType ?? commit2.type;
+			const branchIndex = branchPos.get(commit2.branch)?.index ?? 0;
+			drawCommitBullet(gBullets, commit2, commitPosition, typeClass, branchIndex, commitSymbolType);
+			drawCommitLabel(gLabels, commit2, commitPosition, pos, gitGraphConfig);
+			drawCommitTags(gLabels, commit2, commitPosition, pos);
+		}
+		if (dir === "TB" || dir === "BT") commitPos.set(commit2.id, {
+			x: commitPosition.x,
+			y: commitPosition.posWithOffset
+		});
+		else commitPos.set(commit2.id, {
+			x: commitPosition.posWithOffset,
+			y: commitPosition.y
+		});
+		pos = dir === "BT" && isParallelCommits ? pos + COMMIT_STEP : pos + COMMIT_STEP + LAYOUT_OFFSET;
+		if (pos > maxPos) maxPos = pos;
+	});
+}, "drawCommits");
+var shouldRerouteArrow = /* @__PURE__ */ __name((commitA, commitB, p1, p2, allCommits) => {
+	const branchToGetCurve = (dir === "TB" || dir === "BT" ? p1.x < p2.x : p1.y < p2.y) ? commitB.branch : commitA.branch;
+	const isOnBranchToGetCurve = /* @__PURE__ */ __name((x) => x.branch === branchToGetCurve, "isOnBranchToGetCurve");
+	const isBetweenCommits = /* @__PURE__ */ __name((x) => x.seq > commitA.seq && x.seq < commitB.seq, "isBetweenCommits");
+	return [...allCommits.values()].some((commitX) => {
+		return isBetweenCommits(commitX) && isOnBranchToGetCurve(commitX);
+	});
+}, "shouldRerouteArrow");
+var findLane = /* @__PURE__ */ __name((y1, y2, depth = 0) => {
+	const candidate = y1 + Math.abs(y1 - y2) / 2;
+	if (depth > 5) return candidate;
+	if (lanes.every((lane) => Math.abs(lane - candidate) >= 10)) {
+		lanes.push(candidate);
+		return candidate;
+	}
+	return findLane(y1, y2 - Math.abs(y1 - y2) / 5, depth + 1);
+}, "findLane");
+var drawArrow = /* @__PURE__ */ __name((svg, commitA, commitB, allCommits) => {
+	const { theme: arrowTheme } = getConfig2();
+	const useColorTheme = COLOR_THEMES.has(arrowTheme ?? "");
+	const p1 = commitPos.get(commitA.id);
+	const p2 = commitPos.get(commitB.id);
+	if (p1 === void 0 || p2 === void 0) throw new Error(`Commit positions not found for commits ${commitA.id} and ${commitB.id}`);
+	const arrowNeedsRerouting = shouldRerouteArrow(commitA, commitB, p1, p2, allCommits);
+	let arc = "";
+	let arc2 = "";
+	let radius = 0;
+	let offset = 0;
+	let colorClassNum = branchPos.get(commitB.branch)?.index;
+	if (commitB.type === commitType.MERGE && commitA.id !== commitB.parents[0]) colorClassNum = branchPos.get(commitA.branch)?.index;
+	let lineDef;
+	if (arrowNeedsRerouting) {
+		arc = "A 10 10, 0, 0, 0,";
+		arc2 = "A 10 10, 0, 0, 1,";
+		radius = 10;
+		offset = 10;
+		const lineY = p1.y < p2.y ? findLane(p1.y, p2.y) : findLane(p2.y, p1.y);
+		const lineX = p1.x < p2.x ? findLane(p1.x, p2.x) : findLane(p2.x, p1.x);
+		if (dir === "TB") if (p1.x < p2.x) lineDef = `M ${p1.x} ${p1.y} L ${lineX - radius} ${p1.y} ${arc2} ${lineX} ${p1.y + offset} L ${lineX} ${p2.y - radius} ${arc} ${lineX + offset} ${p2.y} L ${p2.x} ${p2.y}`;
+		else {
+			colorClassNum = branchPos.get(commitA.branch)?.index;
+			lineDef = `M ${p1.x} ${p1.y} L ${lineX + radius} ${p1.y} ${arc} ${lineX} ${p1.y + offset} L ${lineX} ${p2.y - radius} ${arc2} ${lineX - offset} ${p2.y} L ${p2.x} ${p2.y}`;
+		}
+		else if (dir === "BT") if (p1.x < p2.x) lineDef = `M ${p1.x} ${p1.y} L ${lineX - radius} ${p1.y} ${arc} ${lineX} ${p1.y - offset} L ${lineX} ${p2.y + radius} ${arc2} ${lineX + offset} ${p2.y} L ${p2.x} ${p2.y}`;
+		else {
+			colorClassNum = branchPos.get(commitA.branch)?.index;
+			lineDef = `M ${p1.x} ${p1.y} L ${lineX + radius} ${p1.y} ${arc2} ${lineX} ${p1.y - offset} L ${lineX} ${p2.y + radius} ${arc} ${lineX - offset} ${p2.y} L ${p2.x} ${p2.y}`;
+		}
+		else if (p1.y < p2.y) lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${lineY - radius} ${arc} ${p1.x + offset} ${lineY} L ${p2.x - radius} ${lineY} ${arc2} ${p2.x} ${lineY + offset} L ${p2.x} ${p2.y}`;
+		else {
+			colorClassNum = branchPos.get(commitA.branch)?.index;
+			lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${lineY + radius} ${arc2} ${p1.x + offset} ${lineY} L ${p2.x - radius} ${lineY} ${arc} ${p2.x} ${lineY - offset} L ${p2.x} ${p2.y}`;
+		}
+	} else {
+		arc = "A 20 20, 0, 0, 0,";
+		arc2 = "A 20 20, 0, 0, 1,";
+		radius = 20;
+		offset = 20;
+		if (dir === "TB") {
+			if (p1.x < p2.x) if (commitB.type === commitType.MERGE && commitA.id !== commitB.parents[0]) lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${p2.y - radius} ${arc} ${p1.x + offset} ${p2.y} L ${p2.x} ${p2.y}`;
+			else lineDef = `M ${p1.x} ${p1.y} L ${p2.x - radius} ${p1.y} ${arc2} ${p2.x} ${p1.y + offset} L ${p2.x} ${p2.y}`;
+			if (p1.x > p2.x) {
+				arc = "A 20 20, 0, 0, 0,";
+				arc2 = "A 20 20, 0, 0, 1,";
+				radius = 20;
+				offset = 20;
+				if (commitB.type === commitType.MERGE && commitA.id !== commitB.parents[0]) lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${p2.y - radius} ${arc2} ${p1.x - offset} ${p2.y} L ${p2.x} ${p2.y}`;
+				else lineDef = `M ${p1.x} ${p1.y} L ${p2.x + radius} ${p1.y} ${arc} ${p2.x} ${p1.y + offset} L ${p2.x} ${p2.y}`;
+			}
+			if (p1.x === p2.x) lineDef = `M ${p1.x} ${p1.y} L ${p2.x} ${p2.y}`;
+		} else if (dir === "BT") {
+			if (p1.x < p2.x) if (commitB.type === commitType.MERGE && commitA.id !== commitB.parents[0]) lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${p2.y + radius} ${arc2} ${p1.x + offset} ${p2.y} L ${p2.x} ${p2.y}`;
+			else lineDef = `M ${p1.x} ${p1.y} L ${p2.x - radius} ${p1.y} ${arc} ${p2.x} ${p1.y - offset} L ${p2.x} ${p2.y}`;
+			if (p1.x > p2.x) {
+				arc = "A 20 20, 0, 0, 0,";
+				arc2 = "A 20 20, 0, 0, 1,";
+				radius = 20;
+				offset = 20;
+				if (commitB.type === commitType.MERGE && commitA.id !== commitB.parents[0]) lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${p2.y + radius} ${arc} ${p1.x - offset} ${p2.y} L ${p2.x} ${p2.y}`;
+				else lineDef = `M ${p1.x} ${p1.y} L ${p2.x + radius} ${p1.y} ${arc2} ${p2.x} ${p1.y - offset} L ${p2.x} ${p2.y}`;
+			}
+			if (p1.x === p2.x) lineDef = `M ${p1.x} ${p1.y} L ${p2.x} ${p2.y}`;
+		} else {
+			if (p1.y < p2.y) if (commitB.type === commitType.MERGE && commitA.id !== commitB.parents[0]) lineDef = `M ${p1.x} ${p1.y} L ${p2.x - radius} ${p1.y} ${arc2} ${p2.x} ${p1.y + offset} L ${p2.x} ${p2.y}`;
+			else lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${p2.y - radius} ${arc} ${p1.x + offset} ${p2.y} L ${p2.x} ${p2.y}`;
+			if (p1.y > p2.y) if (commitB.type === commitType.MERGE && commitA.id !== commitB.parents[0]) lineDef = `M ${p1.x} ${p1.y} L ${p2.x - radius} ${p1.y} ${arc} ${p2.x} ${p1.y - offset} L ${p2.x} ${p2.y}`;
+			else lineDef = `M ${p1.x} ${p1.y} L ${p1.x} ${p2.y + radius} ${arc2} ${p1.x + offset} ${p2.y} L ${p2.x} ${p2.y}`;
+			if (p1.y === p2.y) lineDef = `M ${p1.x} ${p1.y} L ${p2.x} ${p2.y}`;
+		}
+	}
+	if (lineDef === void 0) throw new Error("Line definition not found");
+	svg.append("path").attr("d", lineDef).attr("class", "arrow arrow" + calcColorIndex(colorClassNum, THEME_COLOR_LIMIT, useColorTheme));
+}, "drawArrow");
+var drawArrows = /* @__PURE__ */ __name((svg, commits) => {
+	const gArrows = svg.append("g").attr("class", "commit-arrows");
+	[...commits.keys()].forEach((key) => {
+		const commit2 = commits.get(key);
+		if (commit2.parents && commit2.parents.length > 0) commit2.parents.forEach((parent) => {
+			drawArrow(gArrows, commits.get(parent), commit2, commits);
+		});
+	});
+}, "drawArrows");
+var drawBranches = /* @__PURE__ */ __name((svg, branches, gitGraphConfig, id) => {
+	const { look, theme, themeVariables } = getConfig2();
+	const { dropShadow, THEME_COLOR_LIMIT: themeColorLimit } = themeVariables;
+	const useReduxGeometry = REDUX_GEOMETRY_THEMES.has(theme ?? "");
+	const useColorTheme = COLOR_THEMES.has(theme ?? "");
+	const g = svg.append("g");
+	branches.forEach((branch2, index) => {
+		const adjustIndexForTheme = calcColorIndex(index, useReduxGeometry ? themeColorLimit : THEME_COLOR_LIMIT, useColorTheme);
+		const pos = branchPos.get(branch2.name)?.pos;
+		if (pos === void 0) throw new Error(`Position not found for branch ${branch2.name}`);
+		const spineY = dir === "TB" || dir === "BT" ? pos : useReduxGeometry ? pos + REDUX_BRANCH_LABEL_PADDING_Y / 2 + 1 : pos - 2;
+		const line = g.append("line");
+		line.attr("x1", 0);
+		line.attr("y1", spineY);
+		line.attr("x2", maxPos);
+		line.attr("y2", spineY);
+		line.attr("class", "branch branch" + adjustIndexForTheme);
+		if (dir === "TB") {
+			line.attr("y1", defaultPos);
+			line.attr("x1", pos);
+			line.attr("y2", maxPos);
+			line.attr("x2", pos);
+		} else if (dir === "BT") {
+			line.attr("y1", maxPos);
+			line.attr("x1", pos);
+			line.attr("y2", defaultPos);
+			line.attr("x2", pos);
+		}
+		lanes.push(spineY);
+		const name = branch2.name;
+		const labelElement = drawText(name);
+		const bkg = g.insert("rect");
+		const label = g.insert("g").attr("class", "branchLabel").insert("g").attr("class", "label branch-label" + adjustIndexForTheme);
+		label.node().appendChild(labelElement);
+		const bbox = labelElement.getBBox();
+		const borderRadius = useReduxGeometry ? 0 : 4;
+		const labelPaddingX = useReduxGeometry ? 16 : 0;
+		const labelPaddingY = useReduxGeometry ? REDUX_BRANCH_LABEL_PADDING_Y : 0;
+		if (look === "neo") bkg.attr("data-look", `neo`);
+		bkg.attr("class", "branchLabelBkg label" + adjustIndexForTheme).attr("style", look === "neo" ? `filter:${useReduxGeometry ? `url(#${id}-drop-shadow)` : dropShadow}` : "").attr("rx", borderRadius).attr("ry", borderRadius).attr("x", -bbox.width - 4 - (gitGraphConfig.rotateCommitLabel === true ? 30 : 0)).attr("y", -bbox.height / 2 + 10).attr("width", bbox.width + 18 + labelPaddingX).attr("height", bbox.height + 4 + labelPaddingY);
+		label.attr("transform", "translate(" + (-bbox.width - 14 - (gitGraphConfig.rotateCommitLabel === true ? 30 : 0) + labelPaddingX / 2) + ", " + (spineY - bbox.height / 2 - 2) + ")");
+		if (dir === "TB") {
+			bkg.attr("x", pos - bbox.width / 2 - 10).attr("y", 0);
+			label.attr("transform", "translate(" + (pos - bbox.width / 2 - 5) + ", 0)");
+			if (useReduxGeometry) {
+				bkg.attr("transform", `translate(${-labelPaddingX / 2 - 3}, ${-labelPaddingY - 10})`);
+				label.attr("transform", "translate(" + (pos - bbox.width / 2 - 5) + ", " + (-labelPaddingY * 2 + 7) + ")");
+			}
+		} else if (dir === "BT") {
+			bkg.attr("x", pos - bbox.width / 2 - 10).attr("y", maxPos);
+			label.attr("transform", "translate(" + (pos - bbox.width / 2 - 5) + ", " + maxPos + ")");
+			if (useReduxGeometry) {
+				bkg.attr("transform", `translate(${-labelPaddingX / 2 - 3}, ${labelPaddingY + 10})`);
+				label.attr("transform", "translate(" + (pos - bbox.width / 2 - 5) + ", " + (maxPos + labelPaddingY * 2 + 4) + ")");
+			}
+		} else bkg.attr("transform", "translate(-19, " + (spineY - 12 - labelPaddingY / 2) + ")");
+	});
+}, "drawBranches");
+var setBranchPosition = /* @__PURE__ */ __name(function(name, pos, index, bbox, rotateCommitLabel) {
+	branchPos.set(name, {
+		pos,
+		index
+	});
+	pos += 50 + (rotateCommitLabel ? 40 : 0) + (dir === "TB" || dir === "BT" ? bbox.width / 2 : 0);
+	return pos;
+}, "setBranchPosition");
+var gitGraphRenderer_default = { draw: /* @__PURE__ */ __name(function(txt, id, ver, diagObj) {
+	clear3();
+	log.debug("in gitgraph renderer", txt + "\n", "id:", id, ver);
+	const db2 = diagObj.db;
+	if (!db2.getConfig) {
+		log.error("getConfig method is not available on db");
+		return;
+	}
+	const gitGraphConfig = db2.getConfig();
+	const rotateCommitLabel = gitGraphConfig.rotateCommitLabel ?? false;
+	allCommitsDict = db2.getCommits();
+	const branches = db2.getBranchesAsObjArray();
+	dir = db2.getDirection();
+	const diagram2 = select_default(`[id="${id}"]`);
+	const { look, theme, themeVariables } = getConfig2();
+	const { useGradient, gradientStart, gradientStop, filterColor } = themeVariables;
+	if (useGradient) {
+		const gradient = diagram2.append("defs").append("linearGradient").attr("id", id + "-gradient").attr("gradientUnits", "objectBoundingBox").attr("x1", "0%").attr("y1", "0%").attr("x2", "100%").attr("y2", "0%");
+		gradient.append("stop").attr("offset", "0%").attr("stop-color", gradientStart).attr("stop-opacity", 1);
+		gradient.append("stop").attr("offset", "100%").attr("stop-color", gradientStop).attr("stop-opacity", 1);
+	}
+	if (look === "neo" && REDUX_GEOMETRY_THEMES.has(theme ?? "")) diagram2.append("defs").append("filter").attr("id", id + "-drop-shadow").attr("height", "130%").attr("width", "130%").append("feDropShadow").attr("dx", "4").attr("dy", "4").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", filterColor);
+	let pos = 0;
+	branches.forEach((branch2, index) => {
+		const labelElement = drawText(branch2.name);
+		const g = diagram2.append("g");
+		const branchLabel = g.insert("g").attr("class", "branchLabel");
+		const label = branchLabel.insert("g").attr("class", "label branch-label");
+		label.node()?.appendChild(labelElement);
+		const bbox = labelElement.getBBox();
+		pos = setBranchPosition(branch2.name, pos, index, bbox, rotateCommitLabel);
+		label.remove();
+		branchLabel.remove();
+		g.remove();
+	});
+	drawCommits(diagram2, allCommitsDict, false, gitGraphConfig);
+	if (gitGraphConfig.showBranches) drawBranches(diagram2, branches, gitGraphConfig, id);
+	drawArrows(diagram2, allCommitsDict);
+	drawCommits(diagram2, allCommitsDict, true, gitGraphConfig);
+	utils_default.insertTitle(diagram2, "gitTitleText", gitGraphConfig.titleTopMargin ?? 0, db2.getDiagramTitle());
+	setupGraphViewbox2(void 0, diagram2, gitGraphConfig.diagramPadding, gitGraphConfig.useMaxWidth);
+}, "draw") };
+var GIT_NAMED_COLOR_COUNT = 8;
+var REDUX_GEOMETRY_THEMES2 = /* @__PURE__ */ new Set([
+	"redux",
+	"redux-dark",
+	"redux-color",
+	"redux-dark-color"
+]);
+var COLOR_THEMES2 = /* @__PURE__ */ new Set(["redux-color", "redux-dark-color"]);
+var NEO_THEMES = /* @__PURE__ */ new Set(["neo", "neo-dark"]);
+var DARK_THEMES2 = /* @__PURE__ */ new Set([
+	"dark",
+	"redux-dark",
+	"redux-dark-color",
+	"neo-dark"
+]);
+var NEO_COLOR_GEN_THEMES = /* @__PURE__ */ new Set([
+	"redux",
+	"redux-dark",
+	"redux-color",
+	"redux-dark-color",
+	"neo",
+	"neo-dark"
+]);
+var genGitGraphGradient = /* @__PURE__ */ __name((options) => {
+	const { svgId } = options;
+	let sections = "";
+	if (options.useGradient && svgId) for (let i = 0; i < options.THEME_COLOR_LIMIT; i++) sections += `
+      .label${i}  { fill: ${options.mainBkg}; stroke: url(${svgId}-gradient); stroke-width: ${options.strokeWidth};}
+             `;
+	return sections;
+}, "genGitGraphGradient");
+var genColor = /* @__PURE__ */ __name((options) => {
+	const { theme, themeVariables } = getConfig();
+	const { borderColorArray } = themeVariables;
+	const useReduxGeometry = REDUX_GEOMETRY_THEMES2.has(theme);
+	if (NEO_THEMES.has(theme)) {
+		let sections = "";
+		for (let i = 0; i < options.THEME_COLOR_LIMIT; i++) if (i === 0) sections += `
+        .branch-label${i} { fill: ${options.nodeBorder};}
+        .commit${i} { stroke: ${options.nodeBorder};   }
+        .commit-highlight${i} { stroke: ${options.nodeBorder}; fill: ${options.nodeBorder}; }
+        .arrow${i} { stroke: ${options.nodeBorder}; }
+        .commit-bullets { fill: ${options.nodeBorder}; }
+        .commit-cherry-pick${i} { stroke: ${options.nodeBorder}; }
+        ${genGitGraphGradient(options)}`;
+		else {
+			const ci = i % GIT_NAMED_COLOR_COUNT;
+			sections += `
+        .branch-label${i} { fill: ${options["gitBranchLabel" + ci]}; }
+        .commit${i} { stroke: ${options["git" + ci]}; fill: ${options["git" + ci]}; }
+        .commit-highlight${i} { stroke: ${options["gitInv" + ci]}; fill: ${options["gitInv" + ci]}; }
+        .arrow${i} { stroke: ${options["git" + ci]}; }
+        `;
+		}
+		return sections;
+	} else if (!COLOR_THEMES2.has(theme)) {
+		let sections = "";
+		for (let i = 0; i < options.THEME_COLOR_LIMIT; i++) sections += `
+        .branch-label${i} { fill: ${options.nodeBorder}; ${useReduxGeometry ? `font-weight:${options.noteFontWeight}` : ""} }
+        .commit${i} { stroke: ${options.nodeBorder};   }
+        .commit-highlight${i} { stroke: ${options.nodeBorder}; fill: ${options.nodeBorder}; }
+        .label${i}  { fill: ${options.mainBkg}; stroke: ${options.nodeBorder}; stroke-width: ${options.strokeWidth}; ${useReduxGeometry ? `font-weight:${options.noteFontWeight}` : ""}}
+        .arrow${i} { stroke: ${options.nodeBorder}; }
+        .commit-bullets { fill: ${options.nodeBorder}; }
+        .commit-cherry-pick${i} { stroke: ${options.nodeBorder}; }
+        `;
+		return sections;
+	} else {
+		let sections = "";
+		for (let i = 0; i < options.THEME_COLOR_LIMIT; i++) if (i === 0) sections += `
+        .branch-label${i} { fill: ${options.nodeBorder}; ${useReduxGeometry ? `font-weight:${options.noteFontWeight}` : ""} }
+        .commit${i} { stroke: ${options.nodeBorder}; }
+        .commit-highlight${i} { stroke: ${options.nodeBorder}; fill: ${options.mainBkg}; }
+        .label${i}  { fill: ${options.mainBkg}; stroke: ${options.nodeBorder}; stroke-width: ${options.strokeWidth}; ${useReduxGeometry ? `font-weight:${options.noteFontWeight}` : ""} }
+        .arrow${i} { stroke: ${options.nodeBorder}; }
+        .commit-bullets { fill: ${options.nodeBorder}; }
+        `;
+		else {
+			const colorIndex = i % borderColorArray.length;
+			sections += `
+        .branch-label${i} { fill: ${options.nodeBorder}; ${useReduxGeometry ? `font-weight:${options.noteFontWeight}` : ""} }
+        .commit${i} { stroke: ${borderColorArray[colorIndex]}; fill: ${borderColorArray[colorIndex]}; }
+        .commit-highlight${i} { stroke: ${borderColorArray[colorIndex]}; fill: ${borderColorArray[colorIndex]}; }
+        .label${i}  { fill: ${DARK_THEMES2.has(theme) ? options.mainBkg : borderColorArray[colorIndex]}; stroke: ${borderColorArray[colorIndex]};  stroke-width: ${options.strokeWidth}; }
+        .arrow${i} { stroke: ${borderColorArray[colorIndex]}; }
+        `;
+		}
+		return sections;
+	}
+}, "genColor");
+var normalTheme = /* @__PURE__ */ __name((options) => {
+	return `${Array.from({ length: options.THEME_COLOR_LIMIT }, (_, i) => i).map((i) => {
+		const ci = i % GIT_NAMED_COLOR_COUNT;
+		return `
+        .branch-label${i} { fill: ${options["gitBranchLabel" + ci]}; }
+        .commit${i} { stroke: ${options["git" + ci]}; fill: ${options["git" + ci]}; }
+        .commit-highlight${i} { stroke: ${options["gitInv" + ci]}; fill: ${options["gitInv" + ci]}; }
+        .label${i}  { fill: ${options["git" + ci]}; }
+        .arrow${i} { stroke: ${options["git" + ci]}; }
+        `;
+	}).join("\n")}`;
+}, "normalTheme");
+var diagram = {
+	parser,
+	db,
+	renderer: gitGraphRenderer_default,
+	styles: /* @__PURE__ */ __name((options) => {
+		const { theme } = getConfig();
+		const useNeoColorGen = NEO_COLOR_GEN_THEMES.has(theme);
+		return `
+  .commit-id,
+  .commit-msg,
+  .branch-label {
+    fill: lightgrey;
+    color: lightgrey;
+    font-family: 'trebuchet ms', verdana, arial, sans-serif;
+    font-family: var(--mermaid-font-family);
+  }
+  
+  ${useNeoColorGen ? genColor(options) : normalTheme(options)}
+
+  .branch {
+    stroke-width: ${options.strokeWidth};
+    stroke: ${options.commitLineColor ?? options.lineColor};
+    stroke-dasharray:  ${useNeoColorGen ? "4 2" : "2"};
+  }
+  .commit-label { font-size: ${options.commitLabelFontSize}; fill: ${useNeoColorGen ? options.nodeBorder : options.commitLabelColor}; ${useNeoColorGen ? `font-weight:${options.noteFontWeight};` : ""}}
+  .commit-label-bkg { font-size: ${options.commitLabelFontSize}; fill: ${useNeoColorGen ? "transparent" : options.commitLabelBackground}; opacity: ${useNeoColorGen ? "" : .5};  }
+  .tag-label { font-size: ${options.tagLabelFontSize}; fill: ${options.tagLabelColor};}
+  .tag-label-bkg { fill: ${useNeoColorGen ? options.mainBkg : options.tagLabelBackground}; stroke: ${useNeoColorGen ? options.nodeBorder : options.tagLabelBorder}; ${useNeoColorGen ? `filter:${options.dropShadow}` : ""}  }
+  .tag-hole { fill: ${options.textColor}; }
+
+  .commit-merge {
+    stroke: ${useNeoColorGen ? options.mainBkg : options.primaryColor};
+    fill: ${useNeoColorGen ? options.mainBkg : options.primaryColor};
+  }
+  .commit-reverse {
+    stroke: ${useNeoColorGen ? options.mainBkg : options.primaryColor};
+    fill: ${useNeoColorGen ? options.mainBkg : options.primaryColor};
+    stroke-width: ${useNeoColorGen ? options.strokeWidth : 3};
+  }
+  .commit-highlight-outer {
+  }
+  .commit-highlight-inner {
+    stroke: ${useNeoColorGen ? options.mainBkg : options.primaryColor};
+    fill: ${useNeoColorGen ? options.mainBkg : options.primaryColor};
+  }
+
+  .arrow {
+    /* Intentional: neo themes keep the bold 8px arrow (like classic themes); only redux-geometry themes use the thinner options.strokeWidth. */
+    stroke-width: ${REDUX_GEOMETRY_THEMES2.has(theme) ? options.strokeWidth : 8};
+    stroke-linecap: round;
+    fill: none
+  }
+  .gitTitleText {
+    text-anchor: middle;
+    font-size: 18px;
+    fill: ${options.textColor};
+  }
+`;
+	}, "getStyles")
+};
+
+//#endregion
+export { diagram };