@umami/shiso 1.11.0 → 1.13.0

package/dist/chunks/mermaid.core.js

@@ -0,0 +1,4898 @@
+import { n as __name } from "./chunk-Y2CYZVJY.js";
+import { h as setLogLevel, m as log, p as select_default } from "./src.js";
+import { $ as purify, C as getDiagramLoader, E as getSiteConfig, I as reset, L as sanitizeCss, N as registerDiagram, P as registerLazyLoadedDiagrams, Q as updateSiteConfig, S as getDiagram, T as getEffectiveHtmlLabels, V as saveConfigFromInitialize, W as setConfig, X as styles_default, Z as themes_default, _ as frontMatterRegex, b as getConfig, c as configureSvgSize, g as evaluate, l as cssStyleSheetToString, m as detectors, n as addDirective, p as detectType, q as setSiteConfig, r as assignWithDepth_default, s as common_default, t as UnknownDiagramError, u as defaultConfig, x as getConfig2 } from "./chunk-DU6HZSFF.js";
+import { S as isBuffer, a as decodeEntities, d as interpolateToCurve, f as isDetailedError, g as utils_default, h as removeDirectives, i as cleanAndMerge, o as encodeEntities, v as isTypedArray, x as isArrayLike, y as isArguments } from "./chunk-75Z2AOVW.js";
+import { r as registerIconPacks } from "./chunk-PWAF6VOD.js";
+import { i as dedent } from "./chunk-GMAD6QVW.js";
+import "./chunk-P2QGCYS3.js";
+import { a as labelHelper } from "./chunk-4HAMMTFA.js";
+import { i as positionNode, n as getSubGraphTitleMargins, r as insertNode, t as clear } from "./chunk-GVQU2GXP.js";
+import { a as insertEdgeLabel, c as positionEdgeLabel, i as insertEdge, l as terminalLabels, n as edgeLabels, r as hasEdgeLabel, s as markers_default, t as clear$1 } from "./chunk-OSK3NFVY.js";
+import { t as Graph } from "./graphlib.js";
+import { n as insertCluster, t as clear$2 } from "./chunk-L3NEJ4N5.js";
+
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/chunk-CLGD4ZFX.mjs
+var selectSvgElement = /* @__PURE__ */ __name((id) => {
+	const { securityLevel } = getConfig2();
+	let root = select_default("body");
+	if (securityLevel === "sandbox") {
+		const doc = select_default(`#i${id}`).node()?.contentDocument ?? document;
+		root = select_default(doc.body);
+	}
+	return root.select(`#${id}`);
+}, "selectSvgElement");
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/_internal/isPrototype.mjs
+function isPrototype(value) {
+	const constructor = value?.constructor;
+	return value === (typeof constructor === "function" ? constructor.prototype : Object.prototype);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/predicate/isEmpty.mjs
+/**
+* Checks if a given value is empty.
+*
+* - If the given value is a string, checks if it is an empty string.
+* - If the given value is an array, `Map`, or `Set`, checks if its size is 0.
+* - If the given value is an [array-like object](../predicate/isArrayLike.md), checks if its length is 0.
+* - If the given value is an object, checks if it is an empty object with no properties.
+* - Primitive values (booleans, numbers, or bigints) are considered empty.
+*
+* @param [value] - The value to check.
+* @returns `true` if the value is empty, `false` otherwise.
+*
+* @example
+* isEmpty(); // true
+* isEmpty(null); // true
+* isEmpty(""); // true
+* isEmpty([]); // true
+* isEmpty({}); // true
+* isEmpty(new Map()); // true
+* isEmpty(new Set()); // true
+* isEmpty("hello"); // false
+* isEmpty([1, 2, 3]); // false
+* isEmpty({ a: 1 }); // false
+* isEmpty(new Map([["key", "value"]])); // false
+* isEmpty(new Set([1, 2, 3])); // false
+*/
+function isEmpty(value) {
+	if (value == null) return true;
+	if (isArrayLike(value)) {
+		if (typeof value.splice !== "function" && typeof value !== "string" && !isBuffer(value) && !isTypedArray(value) && !isArguments(value)) return false;
+		return value.length === 0;
+	}
+	if (typeof value === "object" || typeof value === "function") {
+		if (value instanceof Map || value instanceof Set) return value.size === 0;
+		const keys = Object.keys(value);
+		if (isPrototype(value)) return keys.filter((x) => x !== "constructor").length === 0;
+		return keys.length === 0;
+	}
+	return true;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/chunk-TLUHSLCS.mjs
+var internalHelpers = {
+	common: common_default,
+	getConfig,
+	insertCluster,
+	insertEdge,
+	insertEdgeLabel,
+	insertMarkers: markers_default,
+	insertNode,
+	interpolateToCurve,
+	labelHelper,
+	log,
+	positionEdgeLabel
+};
+var layoutAlgorithms = {};
+var registerLayoutLoaders = /* @__PURE__ */ __name((loaders) => {
+	for (const loader of loaders) layoutAlgorithms[loader.name] = loader;
+}, "registerLayoutLoaders");
+(/* @__PURE__ */ __name(() => {
+	registerLayoutLoaders([
+		{
+			name: "dagre",
+			loader: /* @__PURE__ */ __name(async () => await import("./dagre-GXQ25YYZ.js"), "loader")
+		},
+		{
+			name: "swimlane",
+			loader: /* @__PURE__ */ __name(async () => await import("./swimlanes-42K2YHIH.js"), "loader")
+		},
+		...[{
+			name: "cose-bilkent",
+			loader: /* @__PURE__ */ __name(async () => await import("./cose-bilkent-JH36ORCC.js"), "loader")
+		}]
+	]);
+}, "registerDefaultLayoutLoaders"))();
+var render$1 = /* @__PURE__ */ __name(async (data4Layout, svg) => {
+	if (!(data4Layout.layoutAlgorithm in layoutAlgorithms)) throw new Error(`Unknown layout algorithm: ${data4Layout.layoutAlgorithm}`);
+	if (data4Layout.diagramId) for (const node of data4Layout.nodes) {
+		const originalDomId = node.domId || node.id;
+		node.domId = `${data4Layout.diagramId}-${originalDomId}`;
+	}
+	const layoutDefinition = layoutAlgorithms[data4Layout.layoutAlgorithm];
+	const layoutRenderer = await layoutDefinition.loader();
+	const { theme, themeVariables } = data4Layout.config;
+	const { useGradient, gradientStart, gradientStop } = themeVariables;
+	const svgId = svg.attr("id");
+	svg.append("defs").append("filter").attr("id", `${svgId}-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", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
+	svg.append("defs").append("filter").attr("id", `${svgId}-drop-shadow-small`).attr("height", "150%").attr("width", "150%").append("feDropShadow").attr("dx", "2").attr("dy", "2").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
+	if (useGradient) {
+		const gradient = svg.append("linearGradient").attr("id", svg.attr("id") + "-gradient").attr("gradientUnits", "objectBoundingBox").attr("x1", "0%").attr("y1", "0%").attr("x2", "100%").attr("y2", "0%");
+		gradient.append("svg:stop").attr("offset", "0%").attr("stop-color", gradientStart).attr("stop-opacity", 1);
+		gradient.append("svg:stop").attr("offset", "100%").attr("stop-color", gradientStop).attr("stop-opacity", 1);
+	}
+	return layoutRenderer.render(data4Layout, svg, internalHelpers, { algorithm: layoutDefinition.algorithm });
+}, "render");
+var getRegisteredLayoutAlgorithm = /* @__PURE__ */ __name((algorithm = "", { fallback = "dagre" } = {}) => {
+	if (algorithm in layoutAlgorithms) return algorithm;
+	if (fallback in layoutAlgorithms) {
+		log.warn(`Layout algorithm ${algorithm} is not registered. Using ${fallback} as fallback.`);
+		return fallback;
+	}
+	throw new Error(`Both layout algorithms ${algorithm} and ${fallback} are not registered.`);
+}, "getRegisteredLayoutAlgorithm");
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/chunk-2E4U76K2.mjs
+function createLayoutElementGroups(element, { edgePathsClass = "edges edgePaths" } = {}) {
+	const rootGroups = element.insert("g").attr("class", "root");
+	return {
+		clusters: rootGroups.insert("g").attr("class", "clusters"),
+		edgePaths: rootGroups.insert("g").attr("class", edgePathsClass),
+		edgeLabels: rootGroups.insert("g").attr("class", "edgeLabels"),
+		nodes: rootGroups.insert("g").attr("class", "nodes"),
+		rootGroups
+	};
+}
+__name(createLayoutElementGroups, "createLayoutElementGroups");
+async function measureGroupLabel(nodesGroup, node) {
+	if (node.label) {
+		const { shapeSvg, bbox } = await labelHelper(nodesGroup, node);
+		node.labelBBox = {
+			width: bbox.width,
+			height: bbox.height
+		};
+		shapeSvg.remove();
+	} else node.labelBBox = {
+		width: 0,
+		height: 0
+	};
+}
+__name(measureGroupLabel, "measureGroupLabel");
+async function insertMeasuredNode(nodesGroup, node, renderOptions) {
+	const childNodeEl = await insertNode(nodesGroup, node, renderOptions);
+	const boundingBox = childNodeEl.node()?.getBBox() ?? {
+		width: 0,
+		height: 0
+	};
+	node.width = boundingBox.width;
+	node.height = boundingBox.height;
+	return childNodeEl;
+}
+__name(insertMeasuredNode, "insertMeasuredNode");
+async function createGraphWithElements(element, data4Layout) {
+	const graph = new Graph({
+		multigraph: true,
+		compound: true
+	});
+	const edgesToProcess = [...data4Layout.edges];
+	const config = getConfig2();
+	const groups = createLayoutElementGroups(element);
+	const { edgeLabels: edgeLabels2, nodes: nodesGroup } = groups;
+	const nodeElements = /* @__PURE__ */ new Map();
+	const hasDom = element.node() != null;
+	await Promise.all(data4Layout.nodes.map(async (node) => {
+		if (node.isGroup) {
+			if (hasDom) await measureGroupLabel(nodesGroup, node);
+			graph.setNode(node.id, { ...node });
+		} else {
+			if (hasDom) {
+				const childNodeEl = await insertMeasuredNode(nodesGroup, node, {
+					config,
+					dir: node.dir
+				});
+				nodeElements.set(node.id, childNodeEl);
+			}
+			graph.setNode(node.id, { ...node });
+		}
+	}));
+	for (const edge of edgesToProcess) {
+		if (hasDom && hasEdgeLabel(edge)) await insertEdgeLabel(edgeLabels2, edge);
+		graph.setEdge(edge.start, edge.end, { ...edge }, edge.id);
+		if (!data4Layout.edges.some((existingEdge) => existingEdge.id === edge.id)) data4Layout.edges.push(edge);
+	}
+	if (globalThis.mermaidCaptureSizes) {
+		const { captureNodeSizes } = await import("./sizeCapture-INFHLROL.js");
+		captureNodeSizes(element, data4Layout);
+	}
+	return {
+		graph,
+		groups,
+		nodeElements
+	};
+}
+__name(createGraphWithElements, "createGraphWithElements");
+var clusterDb = /* @__PURE__ */ new Map();
+var descendants = /* @__PURE__ */ new Map();
+var parents = /* @__PURE__ */ new Map();
+var clear4 = /* @__PURE__ */ __name(() => {
+	descendants.clear();
+	parents.clear();
+	clusterDb.clear();
+}, "clear");
+var isDescendant = /* @__PURE__ */ __name((id, ancestorId) => {
+	const ancestorDescendants = descendants.get(ancestorId) || [];
+	log.trace("In isDescendant", ancestorId, " ", id, " = ", ancestorDescendants.includes(id));
+	return ancestorDescendants.includes(id);
+}, "isDescendant");
+var edgeInCluster = /* @__PURE__ */ __name((edge, clusterId) => {
+	const clusterDescendants = descendants.get(clusterId) || [];
+	log.info("Descendants of ", clusterId, " is ", clusterDescendants);
+	log.info("Edge is ", edge);
+	if (edge.v === clusterId || edge.w === clusterId) return false;
+	if (!clusterDescendants) {
+		log.debug("Tilt, ", clusterId, ",not in descendants");
+		return false;
+	}
+	return clusterDescendants.includes(edge.v) || isDescendant(edge.v, clusterId) || isDescendant(edge.w, clusterId) || clusterDescendants.includes(edge.w);
+}, "edgeInCluster");
+var copy = /* @__PURE__ */ __name((clusterId, graph, newGraph, rootId) => {
+	log.debug("Copying children of ", clusterId, "root", rootId, "data", graph.node(clusterId), rootId);
+	const nodes = graph.children(clusterId) || [];
+	if (clusterId !== rootId) nodes.push(clusterId);
+	log.debug("Copying (nodes) clusterId", clusterId, "nodes", nodes);
+	nodes.forEach((node) => {
+		if (graph.children(node).length > 0) copy(node, graph, newGraph, rootId);
+		else {
+			const data = graph.node(node);
+			log.info("cp ", node, " to ", rootId, " with parent ", clusterId);
+			newGraph.setNode(node, data);
+			if (rootId !== graph.parent(node)) {
+				log.debug("Setting parent", node, graph.parent(node));
+				newGraph.setParent(node, graph.parent(node));
+			}
+			if (clusterId !== rootId && node !== clusterId) {
+				log.debug("Setting parent", node, clusterId);
+				newGraph.setParent(node, clusterId);
+			} else {
+				log.info("In copy ", clusterId, "root", rootId, "data", graph.node(clusterId), rootId);
+				log.debug("Not Setting parent for node=", node, "cluster!==rootId", clusterId !== rootId, "node!==clusterId", node !== clusterId);
+			}
+			const edges = graph.edges(node);
+			log.debug("Copying Edges", edges);
+			edges.forEach((edge) => {
+				log.info("Edge", edge);
+				const data2 = graph.edge(edge.v, edge.w, edge.name);
+				log.info("Edge data", data2, rootId);
+				try {
+					if (edgeInCluster(edge, rootId)) {
+						log.info("Copying as ", edge.v, edge.w, data2, edge.name);
+						newGraph.setEdge(edge.v, edge.w, data2, edge.name);
+						log.info("newGraph edges ", newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
+					} else log.info("Skipping copy of edge ", edge.v, "-->", edge.w, " rootId: ", rootId, " clusterId:", clusterId);
+				} catch (e) {
+					log.error(e);
+				}
+			});
+		}
+		log.debug("Removing node", node);
+		graph.removeNode(node);
+	});
+}, "copy");
+var extractDescendants = /* @__PURE__ */ __name((id, graph) => {
+	const children = graph.children(id);
+	let res = [...children];
+	for (const child of children) {
+		parents.set(child, id);
+		res = [...res, ...extractDescendants(child, graph)];
+	}
+	return res;
+}, "extractDescendants");
+var findCommonEdges = /* @__PURE__ */ __name((graph, id1, id2) => {
+	const edges1 = graph.edges().filter((edge) => edge.v === id1 || edge.w === id1);
+	const edges2 = graph.edges().filter((edge) => edge.v === id2 || edge.w === id2);
+	const edges1Prim = edges1.map((edge) => {
+		return {
+			v: edge.v === id1 ? id2 : edge.v,
+			w: edge.w === id1 ? id1 : edge.w
+		};
+	});
+	const edges2Prim = edges2.map((edge) => {
+		return {
+			v: edge.v,
+			w: edge.w
+		};
+	});
+	return edges1Prim.filter((edgeIn1) => {
+		return edges2Prim.some((edge) => edgeIn1.v === edge.v && edgeIn1.w === edge.w);
+	});
+}, "findCommonEdges");
+var findNonClusterChild = /* @__PURE__ */ __name((id, graph, clusterId) => {
+	const children = graph.children(id);
+	log.trace("Searching children of id ", id, children);
+	if (children.length < 1) return id;
+	let reserve;
+	for (const child of children) {
+		const _id = findNonClusterChild(child, graph, clusterId);
+		const commonEdges = findCommonEdges(graph, clusterId, _id);
+		if (_id) if (commonEdges.length > 0) reserve = _id;
+		else return _id;
+	}
+	return reserve;
+}, "findNonClusterChild");
+var getAnchorId = /* @__PURE__ */ __name((id) => {
+	if (!clusterDb.has(id)) return id;
+	if (!clusterDb.get(id).externalConnections) return id;
+	if (clusterDb.has(id)) return clusterDb.get(id).id;
+	return id;
+}, "getAnchorId");
+var adjustClustersAndEdges = /* @__PURE__ */ __name((graph, depth) => {
+	if (!graph || depth > 10) {
+		log.debug("Opting out, no graph ");
+		return;
+	} else log.debug("Opting in, graph ");
+	graph.nodes().forEach(function(id) {
+		if (graph.children(id).length > 0) {
+			log.debug("Cluster identified", id, " Replacement id in edges: ", findNonClusterChild(id, graph, id));
+			descendants.set(id, extractDescendants(id, graph));
+			clusterDb.set(id, {
+				id: findNonClusterChild(id, graph, id),
+				clusterData: graph.node(id)
+			});
+		}
+	});
+	graph.nodes().forEach(function(id) {
+		const children = graph.children(id);
+		const edges = graph.edges();
+		if (children.length > 0) {
+			log.debug("Cluster identified", id, descendants);
+			edges.forEach((edge) => {
+				if (isDescendant(edge.v, id) ^ isDescendant(edge.w, id)) {
+					log.debug("Edge: ", edge, " leaves cluster ", id);
+					log.debug("Descendants of XXX ", id, ": ", descendants.get(id));
+					clusterDb.get(id).externalConnections = true;
+				}
+			});
+		} else log.debug("Not a cluster ", id, descendants);
+	});
+	for (let id of clusterDb.keys()) {
+		const nonClusterChild = clusterDb.get(id).id;
+		const parent = graph.parent(nonClusterChild);
+		if (parent !== id && clusterDb.has(parent) && !clusterDb.get(parent).externalConnections) clusterDb.get(id).id = parent;
+		const hasDirectOutgoingEdge = graph.edges().some((edge) => edge.v === id);
+		if (nonClusterChild && clusterDb.get(id)?.externalConnections && hasDirectOutgoingEdge && isNodeInExtractableCluster(graph, nonClusterChild, id)) {
+			const safeAnchor = findSafeAnchorNode(graph, id, graph.parent(nonClusterChild));
+			if (safeAnchor) clusterDb.get(id).id = safeAnchor;
+		}
+	}
+	graph.edges().forEach(function(e) {
+		const edge = graph.edge(e);
+		log.debug("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
+		log.debug("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(graph.edge(e)));
+		let v = e.v;
+		let w = e.w;
+		log.debug("Fix XXX", clusterDb, "ids:", e.v, e.w, "Translating: ", clusterDb.get(e.v), " --- ", clusterDb.get(e.w));
+		if (clusterDb.get(e.v) || clusterDb.get(e.w)) {
+			log.debug("Fixing and trying - removing XXX", e.v, e.w, e.name);
+			v = getAnchorId(e.v);
+			w = getAnchorId(e.w);
+			graph.removeEdge(e.v, e.w, e.name);
+			if (v !== e.v) {
+				const parent = graph.parent(v);
+				clusterDb.get(parent).externalConnections = true;
+				edge.fromCluster = e.v;
+			}
+			if (w !== e.w) {
+				const parent = graph.parent(w);
+				clusterDb.get(parent).externalConnections = true;
+				edge.toCluster = e.w;
+			}
+			log.debug("Fix Replacing with XXX", v, w, e.name);
+			graph.setEdge(v, w, edge, e.name);
+		}
+	});
+	extractor(graph, 0);
+	log.trace(clusterDb);
+}, "adjustClustersAndEdges");
+var extractor = /* @__PURE__ */ __name((graph, depth) => {
+	if (depth > 10) {
+		log.error("Bailing out");
+		return;
+	}
+	let nodes = graph.nodes();
+	let hasChildren = false;
+	for (const node of nodes) {
+		const children = graph.children(node);
+		hasChildren = hasChildren || children.length > 0;
+	}
+	if (!hasChildren) {
+		log.debug("Done, no node has children", graph.nodes());
+		return;
+	}
+	log.debug("Nodes = ", nodes, depth);
+	for (const node of nodes) {
+		log.debug("Extracting node", node, clusterDb, clusterDb.has(node) && !clusterDb.get(node).externalConnections, !graph.parent(node), graph.node(node), graph.children("D"), " Depth ", depth);
+		if (!clusterDb.has(node)) log.debug("Not a cluster", node, depth);
+		else if (!clusterDb.get(node).externalConnections && graph.children(node) && graph.children(node).length > 0) {
+			log.debug("Cluster without external connections, without a parent and with children", node, depth);
+			let dir = graph.graph().rankdir === "TB" ? "LR" : "TB";
+			if (clusterDb.get(node)?.clusterData?.dir) {
+				dir = clusterDb.get(node).clusterData.dir;
+				log.debug("Fixing dir", clusterDb.get(node).clusterData.dir, dir);
+			}
+			const clusterGraph = new Graph({
+				multigraph: true,
+				compound: true
+			}).setGraph({
+				rankdir: dir,
+				nodesep: 50,
+				ranksep: 50,
+				marginx: 8,
+				marginy: 8
+			}).setDefaultEdgeLabel(function() {
+				return {};
+			});
+			copy(node, graph, clusterGraph, node);
+			graph.setNode(node, {
+				clusterNode: true,
+				id: node,
+				clusterData: clusterDb.get(node).clusterData,
+				label: clusterDb.get(node).label,
+				graph: clusterGraph
+			});
+		} else {
+			log.debug("Cluster ** ", node, " **not meeting the criteria !externalConnections:", !clusterDb.get(node).externalConnections, " no parent: ", !graph.parent(node), " children ", graph.children(node) && graph.children(node).length > 0, graph.children("D"), depth);
+			log.debug(clusterDb);
+		}
+	}
+	nodes = graph.nodes();
+	log.debug("New list of nodes", nodes);
+	for (const node of nodes) {
+		const data = graph.node(node);
+		log.debug(" Now next level", node, data);
+		if (data?.clusterNode) extractor(data.graph, depth + 1);
+	}
+}, "extractor");
+var sorter = /* @__PURE__ */ __name((graph, nodes) => {
+	if (nodes.length === 0) return [];
+	let result = Object.assign([], nodes);
+	nodes.forEach((node) => {
+		const sorted = sorter(graph, graph.children(node));
+		result = [...result, ...sorted];
+	});
+	return result;
+}, "sorter");
+var sortNodesByHierarchy = /* @__PURE__ */ __name((graph) => sorter(graph, graph.children()), "sortNodesByHierarchy");
+var isNodeInExtractableCluster = /* @__PURE__ */ __name((graph, node, rootId) => {
+	let parent = graph.parent(node);
+	while (parent && parent !== rootId) {
+		const cluster = clusterDb.get(parent);
+		if (cluster && !cluster.externalConnections) return true;
+		parent = graph.parent(parent);
+	}
+	return false;
+}, "isNodeInExtractableCluster");
+var findSafeAnchorNode = /* @__PURE__ */ __name((graph, clusterId, excludedCluster) => {
+	const children = graph.children(clusterId) ?? [];
+	for (const child of children) {
+		if (child === excludedCluster || isDescendant(child, excludedCluster)) continue;
+		const candidate = findNonClusterChild(child, graph, clusterId);
+		if (!candidate) continue;
+		if (!isNodeInExtractableCluster(graph, candidate, clusterId)) return candidate;
+	}
+	return null;
+}, "findSafeAnchorNode");
+function createCommonLayoutRenderer({ prepareLayout, measureLayout, runLayoutCore, paintLayout, afterPaint, paintOptions }) {
+	const measureLayoutFn = measureLayout ?? defaultMeasureLayout;
+	return /* @__PURE__ */ __name(async function render(data4Layout, svg, helpers, options) {
+		const element = svg.select("g");
+		(helpers?.insertMarkers ?? markers_default)(element, data4Layout.markers, data4Layout.type, data4Layout.diagramId);
+		clearLayoutRenderState();
+		const renderContext = {
+			element,
+			helpers,
+			options
+		};
+		renderContext.preparedLayout = await prepareLayout?.(data4Layout, renderContext);
+		const measure = await measureLayoutFn(data4Layout, renderContext);
+		const coreResult = await runLayoutCore(data4Layout, renderContext);
+		const paintContext = {
+			...renderContext,
+			measure
+		};
+		if (paintLayout) await paintLayout(data4Layout, paintContext, coreResult);
+		else await paintLayoutData(data4Layout, paintContext, paintOptions);
+		await afterPaint?.(data4Layout, paintContext, coreResult);
+	}, "render");
+}
+__name(createCommonLayoutRenderer, "createCommonLayoutRenderer");
+function clearLayoutRenderState() {
+	clear();
+	clear$1();
+	clear$2();
+	clear4();
+}
+__name(clearLayoutRenderState, "clearLayoutRenderState");
+async function defaultMeasureLayout(data4Layout, { element }) {
+	return await createGraphWithElements(element, data4Layout);
+}
+__name(defaultMeasureLayout, "defaultMeasureLayout");
+async function paintLayoutData(data4Layout, context, options = {}) {
+	const { measure } = context;
+	const { groups } = measure;
+	for (const node of options.getNodes?.(data4Layout, context) ?? data4Layout.nodes) {
+		if (options.skipNode?.(node, context)) continue;
+		await paintLayoutNode(groups, node, context, options);
+	}
+	const nodeById = buildNodeLookup(data4Layout.nodes);
+	for (const edge of data4Layout.edges) {
+		if (shouldSkipPaintEdge(edge, options)) continue;
+		await paintLayoutEdge(groups, edge, nodeById, data4Layout, options, context);
+	}
+}
+__name(paintLayoutData, "paintLayoutData");
+async function paintLayoutNode(groups, node, context, options) {
+	if (node.clusterNode) positionNode(node);
+	else if (shouldPaintAsCluster(node, context, options)) await insertCluster(groups.clusters, node);
+	else positionNode(node);
+}
+__name(paintLayoutNode, "paintLayoutNode");
+function shouldPaintAsCluster(node, context, options) {
+	return node.isGroup === true && (options.isCluster?.(node, context) ?? true);
+}
+__name(shouldPaintAsCluster, "shouldPaintAsCluster");
+function buildNodeLookup(nodes) {
+	const nodeById = /* @__PURE__ */ new Map();
+	for (const node of nodes) if (node?.id) nodeById.set(node.id, node);
+	return nodeById;
+}
+__name(buildNodeLookup, "buildNodeLookup");
+function shouldSkipPaintEdge(edge, options) {
+	return edge.isLayoutOnly || Boolean(options.skipEdge?.(edge));
+}
+__name(shouldSkipPaintEdge, "shouldSkipPaintEdge");
+async function paintLayoutEdge(groups, edge, nodeById, data4Layout, options, context) {
+	const paths = insertEdge(groups.edgePaths, { ...edge }, options.clusterDb ?? /* @__PURE__ */ new Map(), data4Layout.type, getRenderedNode(edge.start, edge, nodeById, context, options), getRenderedNode(edge.end, edge, nodeById, context, options), data4Layout.diagramId, shouldSkipIntersect(edge, options));
+	if (hasEdgeLabel(edge)) {
+		if (!edgeLabels.has(edge.id)) await insertEdgeLabel(groups.edgeLabels, edge);
+		positionRenderedEdgeLabel(edge, paths);
+	}
+}
+__name(paintLayoutEdge, "paintLayoutEdge");
+function getRenderedNode(id, edge, nodeById, context, options) {
+	return options.getEdgeNode?.(id, edge, context) ?? (id ? nodeById.get(id) ?? {} : {});
+}
+__name(getRenderedNode, "getRenderedNode");
+function shouldSkipIntersect(edge, options) {
+	return typeof options.skipIntersect === "function" ? options.skipIntersect(edge) : options.skipIntersect ?? false;
+}
+__name(shouldSkipIntersect, "shouldSkipIntersect");
+function positionRenderedEdgeLabel(edge, paths) {
+	const path = paths?.updatedPath ?? paths?.originalPath;
+	const siteConfig = getConfig();
+	const { subGraphTitleTotalMargin } = getSubGraphTitleMargins({ flowchart: siteConfig.flowchart ?? {} });
+	if (edge.label) {
+		const el = edgeLabels.get(edge.id);
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcLabelPosition(path);
+			log.debug("Moving label " + edge.label + " from (", x, ",", y, ") to (", pos.x, ",", pos.y, ") abc88");
+			if (paths?.updatedPath) {
+				x = pos.x;
+				y = pos.y;
+			}
+		}
+		el.attr("transform", `translate(${x}, ${y + subGraphTitleTotalMargin / 2})`);
+	}
+	if (edge?.startLabelLeft) {
+		const el = terminalLabels.get(edge.id).startLeft;
+		let x = edge?.x;
+		let y = edge?.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeStart ? 10 : 0, "start_left", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+	if (edge.startLabelRight) {
+		const el = terminalLabels.get(edge.id).startRight;
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeStart ? 10 : 0, "start_right", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+	if (edge.endLabelLeft) {
+		const el = terminalLabels.get(edge.id).endLeft;
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeEnd ? 10 : 0, "end_left", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+	if (edge.endLabelRight) {
+		const el = terminalLabels.get(edge.id).endRight;
+		let x = edge.x;
+		let y = edge.y;
+		if (path) {
+			const pos = utils_default.calcTerminalLabelPosition(edge.arrowTypeEnd ? 10 : 0, "end_right", path);
+			x = pos.x;
+			y = pos.y;
+		}
+		el.attr("transform", `translate(${x}, ${y})`);
+	}
+}
+__name(positionRenderedEdgeLabel, "positionRenderedEdgeLabel");
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/chunks/mermaid.core/chunk-LNGE3PJU.mjs
+function getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+__name(getDefaultExportFromCjs, "getDefaultExportFromCjs");
+var jsYaml = {};
+var loader = {};
+var common = {};
+var hasRequiredCommon;
+function requireCommon() {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
+	function isNothing(subject) {
+		return typeof subject === "undefined" || subject === null;
+	}
+	__name(isNothing, "isNothing");
+	function isObject(subject) {
+		return typeof subject === "object" && subject !== null;
+	}
+	__name(isObject, "isObject");
+	function toArray(sequence) {
+		if (Array.isArray(sequence)) return sequence;
+		else if (isNothing(sequence)) return [];
+		return [sequence];
+	}
+	__name(toArray, "toArray");
+	function extend(target, source) {
+		if (source) {
+			const sourceKeys = Object.keys(source);
+			for (let index = 0, length = sourceKeys.length; index < length; index += 1) {
+				const key = sourceKeys[index];
+				target[key] = source[key];
+			}
+		}
+		return target;
+	}
+	__name(extend, "extend");
+	function repeat(string, count) {
+		let result = "";
+		for (let cycle = 0; cycle < count; cycle += 1) result += string;
+		return result;
+	}
+	__name(repeat, "repeat");
+	function isNegativeZero(number) {
+		return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+	}
+	__name(isNegativeZero, "isNegativeZero");
+	common.isNothing = isNothing;
+	common.isObject = isObject;
+	common.toArray = toArray;
+	common.repeat = repeat;
+	common.isNegativeZero = isNegativeZero;
+	common.extend = extend;
+	return common;
+}
+__name(requireCommon, "requireCommon");
+var exception;
+var hasRequiredException;
+function requireException() {
+	if (hasRequiredException) return exception;
+	hasRequiredException = 1;
+	function formatError(exception2, compact) {
+		let where = "";
+		const message = exception2.reason || "(unknown reason)";
+		if (!exception2.mark) return message;
+		if (exception2.mark.name) where += "in \"" + exception2.mark.name + "\" ";
+		where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")";
+		if (!compact && exception2.mark.snippet) where += "\n\n" + exception2.mark.snippet;
+		return message + " " + where;
+	}
+	__name(formatError, "formatError");
+	function YAMLException2(reason, mark) {
+		Error.call(this);
+		this.name = "YAMLException";
+		this.reason = reason;
+		this.mark = mark;
+		this.message = formatError(this, false);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		else this.stack = (/* @__PURE__ */ new Error()).stack || "";
+	}
+	__name(YAMLException2, "YAMLException2");
+	YAMLException2.prototype = Object.create(Error.prototype);
+	YAMLException2.prototype.constructor = YAMLException2;
+	YAMLException2.prototype.toString = /* @__PURE__ */ __name(function toString(compact) {
+		return this.name + ": " + formatError(this, compact);
+	}, "toString");
+	exception = YAMLException2;
+	return exception;
+}
+__name(requireException, "requireException");
+var snippet;
+var hasRequiredSnippet;
+function requireSnippet() {
+	if (hasRequiredSnippet) return snippet;
+	hasRequiredSnippet = 1;
+	const common2 = requireCommon();
+	function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+		let head = "";
+		let tail = "";
+		const maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+		if (position - lineStart > maxHalfLength) {
+			head = " ... ";
+			lineStart = position - maxHalfLength + head.length;
+		}
+		if (lineEnd - position > maxHalfLength) {
+			tail = " ...";
+			lineEnd = position + maxHalfLength - tail.length;
+		}
+		return {
+			str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
+			pos: position - lineStart + head.length
+		};
+	}
+	__name(getLine, "getLine");
+	function padStart(string, max) {
+		return common2.repeat(" ", max - string.length) + string;
+	}
+	__name(padStart, "padStart");
+	function makeSnippet(mark, options) {
+		options = Object.create(options || null);
+		if (!mark.buffer) return null;
+		if (!options.maxLength) options.maxLength = 79;
+		if (typeof options.indent !== "number") options.indent = 1;
+		if (typeof options.linesBefore !== "number") options.linesBefore = 3;
+		if (typeof options.linesAfter !== "number") options.linesAfter = 2;
+		const re = /\r?\n|\r|\0/g;
+		const lineStarts = [0];
+		const lineEnds = [];
+		let match;
+		let foundLineNo = -1;
+		while (match = re.exec(mark.buffer)) {
+			lineEnds.push(match.index);
+			lineStarts.push(match.index + match[0].length);
+			if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
+		}
+		if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
+		let result = "";
+		const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+		const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+		for (let i = 1; i <= options.linesBefore; i++) {
+			if (foundLineNo - i < 0) break;
+			const line2 = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
+			result = common2.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line2.str + "\n" + result;
+		}
+		const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+		result += common2.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+		result += common2.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
+		for (let i = 1; i <= options.linesAfter; i++) {
+			if (foundLineNo + i >= lineEnds.length) break;
+			const line2 = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
+			result += common2.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line2.str + "\n";
+		}
+		return result.replace(/\n$/, "");
+	}
+	__name(makeSnippet, "makeSnippet");
+	snippet = makeSnippet;
+	return snippet;
+}
+__name(requireSnippet, "requireSnippet");
+var type;
+var hasRequiredType;
+function requireType() {
+	if (hasRequiredType) return type;
+	hasRequiredType = 1;
+	const YAMLException2 = requireException();
+	const TYPE_CONSTRUCTOR_OPTIONS = [
+		"kind",
+		"multi",
+		"resolve",
+		"construct",
+		"instanceOf",
+		"predicate",
+		"represent",
+		"representName",
+		"defaultStyle",
+		"styleAliases"
+	];
+	const YAML_NODE_KINDS = [
+		"scalar",
+		"sequence",
+		"mapping"
+	];
+	function compileStyleAliases(map2) {
+		const result = {};
+		if (map2 !== null) Object.keys(map2).forEach(function(style) {
+			map2[style].forEach(function(alias) {
+				result[String(alias)] = style;
+			});
+		});
+		return result;
+	}
+	__name(compileStyleAliases, "compileStyleAliases");
+	function Type2(tag, options) {
+		options = options || {};
+		Object.keys(options).forEach(function(name) {
+			if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new YAMLException2("Unknown option \"" + name + "\" is met in definition of \"" + tag + "\" YAML type.");
+		});
+		this.options = options;
+		this.tag = tag;
+		this.kind = options["kind"] || null;
+		this.resolve = options["resolve"] || function() {
+			return true;
+		};
+		this.construct = options["construct"] || function(data) {
+			return data;
+		};
+		this.instanceOf = options["instanceOf"] || null;
+		this.predicate = options["predicate"] || null;
+		this.represent = options["represent"] || null;
+		this.representName = options["representName"] || null;
+		this.defaultStyle = options["defaultStyle"] || null;
+		this.multi = options["multi"] || false;
+		this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
+		if (YAML_NODE_KINDS.indexOf(this.kind) === -1) throw new YAMLException2("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type.");
+	}
+	__name(Type2, "Type2");
+	type = Type2;
+	return type;
+}
+__name(requireType, "requireType");
+var schema;
+var hasRequiredSchema;
+function requireSchema() {
+	if (hasRequiredSchema) return schema;
+	hasRequiredSchema = 1;
+	const YAMLException2 = requireException();
+	const Type2 = requireType();
+	function compileList(schema2, name) {
+		const result = [];
+		schema2[name].forEach(function(currentType) {
+			let newIndex = result.length;
+			result.forEach(function(previousType, previousIndex) {
+				if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) newIndex = previousIndex;
+			});
+			result[newIndex] = currentType;
+		});
+		return result;
+	}
+	__name(compileList, "compileList");
+	function compileMap() {
+		const result = {
+			scalar: {},
+			sequence: {},
+			mapping: {},
+			fallback: {},
+			multi: {
+				scalar: [],
+				sequence: [],
+				mapping: [],
+				fallback: []
+			}
+		};
+		function collectType(type2) {
+			if (type2.multi) {
+				result.multi[type2.kind].push(type2);
+				result.multi["fallback"].push(type2);
+			} else result[type2.kind][type2.tag] = result["fallback"][type2.tag] = type2;
+		}
+		__name(collectType, "collectType");
+		for (let index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
+		return result;
+	}
+	__name(compileMap, "compileMap");
+	function Schema2(definition) {
+		return this.extend(definition);
+	}
+	__name(Schema2, "Schema2");
+	Schema2.prototype.extend = /* @__PURE__ */ __name(function extend(definition) {
+		let implicit = [];
+		let explicit = [];
+		if (definition instanceof Type2) explicit.push(definition);
+		else if (Array.isArray(definition)) explicit = explicit.concat(definition);
+		else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+			if (definition.implicit) implicit = implicit.concat(definition.implicit);
+			if (definition.explicit) explicit = explicit.concat(definition.explicit);
+		} else throw new YAMLException2("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+		implicit.forEach(function(type2) {
+			if (!(type2 instanceof Type2)) throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+			if (type2.loadKind && type2.loadKind !== "scalar") throw new YAMLException2("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+			if (type2.multi) throw new YAMLException2("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+		});
+		explicit.forEach(function(type2) {
+			if (!(type2 instanceof Type2)) throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+		});
+		const result = Object.create(Schema2.prototype);
+		result.implicit = (this.implicit || []).concat(implicit);
+		result.explicit = (this.explicit || []).concat(explicit);
+		result.compiledImplicit = compileList(result, "implicit");
+		result.compiledExplicit = compileList(result, "explicit");
+		result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
+		return result;
+	}, "extend");
+	schema = Schema2;
+	return schema;
+}
+__name(requireSchema, "requireSchema");
+var str;
+var hasRequiredStr;
+function requireStr() {
+	if (hasRequiredStr) return str;
+	hasRequiredStr = 1;
+	str = new (requireType())("tag:yaml.org,2002:str", {
+		kind: "scalar",
+		construct: /* @__PURE__ */ __name(function(data) {
+			return data !== null ? data : "";
+		}, "construct")
+	});
+	return str;
+}
+__name(requireStr, "requireStr");
+var seq;
+var hasRequiredSeq;
+function requireSeq() {
+	if (hasRequiredSeq) return seq;
+	hasRequiredSeq = 1;
+	seq = new (requireType())("tag:yaml.org,2002:seq", {
+		kind: "sequence",
+		construct: /* @__PURE__ */ __name(function(data) {
+			return data !== null ? data : [];
+		}, "construct")
+	});
+	return seq;
+}
+__name(requireSeq, "requireSeq");
+var map;
+var hasRequiredMap;
+function requireMap() {
+	if (hasRequiredMap) return map;
+	hasRequiredMap = 1;
+	map = new (requireType())("tag:yaml.org,2002:map", {
+		kind: "mapping",
+		construct: /* @__PURE__ */ __name(function(data) {
+			return data !== null ? data : {};
+		}, "construct")
+	});
+	return map;
+}
+__name(requireMap, "requireMap");
+var failsafe;
+var hasRequiredFailsafe;
+function requireFailsafe() {
+	if (hasRequiredFailsafe) return failsafe;
+	hasRequiredFailsafe = 1;
+	failsafe = new (requireSchema())({ explicit: [
+		requireStr(),
+		requireSeq(),
+		requireMap()
+	] });
+	return failsafe;
+}
+__name(requireFailsafe, "requireFailsafe");
+var _null;
+var hasRequired_null;
+function require_null() {
+	if (hasRequired_null) return _null;
+	hasRequired_null = 1;
+	const Type2 = requireType();
+	function resolveYamlNull(data) {
+		if (data === null) return true;
+		const max = data.length;
+		return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
+	}
+	__name(resolveYamlNull, "resolveYamlNull");
+	function constructYamlNull() {
+		return null;
+	}
+	__name(constructYamlNull, "constructYamlNull");
+	function isNull(object) {
+		return object === null;
+	}
+	__name(isNull, "isNull");
+	_null = new Type2("tag:yaml.org,2002:null", {
+		kind: "scalar",
+		resolve: resolveYamlNull,
+		construct: constructYamlNull,
+		predicate: isNull,
+		represent: {
+			canonical: /* @__PURE__ */ __name(function() {
+				return "~";
+			}, "canonical"),
+			lowercase: /* @__PURE__ */ __name(function() {
+				return "null";
+			}, "lowercase"),
+			uppercase: /* @__PURE__ */ __name(function() {
+				return "NULL";
+			}, "uppercase"),
+			camelcase: /* @__PURE__ */ __name(function() {
+				return "Null";
+			}, "camelcase"),
+			empty: /* @__PURE__ */ __name(function() {
+				return "";
+			}, "empty")
+		},
+		defaultStyle: "lowercase"
+	});
+	return _null;
+}
+__name(require_null, "require_null");
+var bool;
+var hasRequiredBool;
+function requireBool() {
+	if (hasRequiredBool) return bool;
+	hasRequiredBool = 1;
+	const Type2 = requireType();
+	function resolveYamlBoolean(data) {
+		if (data === null) return false;
+		const max = data.length;
+		return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
+	}
+	__name(resolveYamlBoolean, "resolveYamlBoolean");
+	function constructYamlBoolean(data) {
+		return data === "true" || data === "True" || data === "TRUE";
+	}
+	__name(constructYamlBoolean, "constructYamlBoolean");
+	function isBoolean(object) {
+		return Object.prototype.toString.call(object) === "[object Boolean]";
+	}
+	__name(isBoolean, "isBoolean");
+	bool = new Type2("tag:yaml.org,2002:bool", {
+		kind: "scalar",
+		resolve: resolveYamlBoolean,
+		construct: constructYamlBoolean,
+		predicate: isBoolean,
+		represent: {
+			lowercase: /* @__PURE__ */ __name(function(object) {
+				return object ? "true" : "false";
+			}, "lowercase"),
+			uppercase: /* @__PURE__ */ __name(function(object) {
+				return object ? "TRUE" : "FALSE";
+			}, "uppercase"),
+			camelcase: /* @__PURE__ */ __name(function(object) {
+				return object ? "True" : "False";
+			}, "camelcase")
+		},
+		defaultStyle: "lowercase"
+	});
+	return bool;
+}
+__name(requireBool, "requireBool");
+var int;
+var hasRequiredInt;
+function requireInt() {
+	if (hasRequiredInt) return int;
+	hasRequiredInt = 1;
+	const common2 = requireCommon();
+	const Type2 = requireType();
+	function isHexCode(c) {
+		return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+	}
+	__name(isHexCode, "isHexCode");
+	function isOctCode(c) {
+		return c >= 48 && c <= 55;
+	}
+	__name(isOctCode, "isOctCode");
+	function isDecCode(c) {
+		return c >= 48 && c <= 57;
+	}
+	__name(isDecCode, "isDecCode");
+	function resolveYamlInteger(data) {
+		if (data === null) return false;
+		const max = data.length;
+		let index = 0;
+		let hasDigits = false;
+		if (!max) return false;
+		let ch = data[index];
+		if (ch === "-" || ch === "+") ch = data[++index];
+		if (ch === "0") {
+			if (index + 1 === max) return true;
+			ch = data[++index];
+			if (ch === "b") {
+				index++;
+				for (; index < max; index++) {
+					ch = data[index];
+					if (ch !== "0" && ch !== "1") return false;
+					hasDigits = true;
+				}
+				return hasDigits && isFinite(parseYamlInteger(data));
+			}
+			if (ch === "x") {
+				index++;
+				for (; index < max; index++) {
+					if (!isHexCode(data.charCodeAt(index))) return false;
+					hasDigits = true;
+				}
+				return hasDigits && isFinite(parseYamlInteger(data));
+			}
+			if (ch === "o") {
+				index++;
+				for (; index < max; index++) {
+					if (!isOctCode(data.charCodeAt(index))) return false;
+					hasDigits = true;
+				}
+				return hasDigits && isFinite(parseYamlInteger(data));
+			}
+		}
+		for (; index < max; index++) {
+			if (!isDecCode(data.charCodeAt(index))) return false;
+			hasDigits = true;
+		}
+		if (!hasDigits) return false;
+		return isFinite(parseYamlInteger(data));
+	}
+	__name(resolveYamlInteger, "resolveYamlInteger");
+	function parseYamlInteger(data) {
+		let value = data;
+		let sign = 1;
+		let ch = value[0];
+		if (ch === "-" || ch === "+") {
+			if (ch === "-") sign = -1;
+			value = value.slice(1);
+			ch = value[0];
+		}
+		if (value === "0") return 0;
+		if (ch === "0") {
+			if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+			if (value[1] === "x") return sign * parseInt(value.slice(2), 16);
+			if (value[1] === "o") return sign * parseInt(value.slice(2), 8);
+		}
+		return sign * parseInt(value, 10);
+	}
+	__name(parseYamlInteger, "parseYamlInteger");
+	function constructYamlInteger(data) {
+		return parseYamlInteger(data);
+	}
+	__name(constructYamlInteger, "constructYamlInteger");
+	function isInteger(object) {
+		return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common2.isNegativeZero(object);
+	}
+	__name(isInteger, "isInteger");
+	int = new Type2("tag:yaml.org,2002:int", {
+		kind: "scalar",
+		resolve: resolveYamlInteger,
+		construct: constructYamlInteger,
+		predicate: isInteger,
+		represent: {
+			binary: /* @__PURE__ */ __name(function(obj) {
+				return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+			}, "binary"),
+			octal: /* @__PURE__ */ __name(function(obj) {
+				return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+			}, "octal"),
+			decimal: /* @__PURE__ */ __name(function(obj) {
+				return obj.toString(10);
+			}, "decimal"),
+			hexadecimal: /* @__PURE__ */ __name(function(obj) {
+				return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+			}, "hexadecimal")
+		},
+		defaultStyle: "decimal",
+		styleAliases: {
+			binary: [2, "bin"],
+			octal: [8, "oct"],
+			decimal: [10, "dec"],
+			hexadecimal: [16, "hex"]
+		}
+	});
+	return int;
+}
+__name(requireInt, "requireInt");
+var float;
+var hasRequiredFloat;
+function requireFloat() {
+	if (hasRequiredFloat) return float;
+	hasRequiredFloat = 1;
+	const common2 = requireCommon();
+	const Type2 = requireType();
+	const YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+	const YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+	function resolveYamlFloat(data) {
+		if (data === null) return false;
+		if (!YAML_FLOAT_PATTERN.test(data)) return false;
+		if (isFinite(parseFloat(data, 10))) return true;
+		return YAML_FLOAT_SPECIAL_PATTERN.test(data);
+	}
+	__name(resolveYamlFloat, "resolveYamlFloat");
+	function constructYamlFloat(data) {
+		let value = data.toLowerCase();
+		const sign = value[0] === "-" ? -1 : 1;
+		if ("+-".indexOf(value[0]) >= 0) value = value.slice(1);
+		if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+		else if (value === ".nan") return NaN;
+		return sign * parseFloat(value, 10);
+	}
+	__name(constructYamlFloat, "constructYamlFloat");
+	const SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+	function representYamlFloat(object, style) {
+		if (isNaN(object)) switch (style) {
+			case "lowercase": return ".nan";
+			case "uppercase": return ".NAN";
+			case "camelcase": return ".NaN";
+		}
+		else if (Number.POSITIVE_INFINITY === object) switch (style) {
+			case "lowercase": return ".inf";
+			case "uppercase": return ".INF";
+			case "camelcase": return ".Inf";
+		}
+		else if (Number.NEGATIVE_INFINITY === object) switch (style) {
+			case "lowercase": return "-.inf";
+			case "uppercase": return "-.INF";
+			case "camelcase": return "-.Inf";
+		}
+		else if (common2.isNegativeZero(object)) return "-0.0";
+		const res = object.toString(10);
+		return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+	}
+	__name(representYamlFloat, "representYamlFloat");
+	function isFloat(object) {
+		return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common2.isNegativeZero(object));
+	}
+	__name(isFloat, "isFloat");
+	float = new Type2("tag:yaml.org,2002:float", {
+		kind: "scalar",
+		resolve: resolveYamlFloat,
+		construct: constructYamlFloat,
+		predicate: isFloat,
+		represent: representYamlFloat,
+		defaultStyle: "lowercase"
+	});
+	return float;
+}
+__name(requireFloat, "requireFloat");
+var json;
+var hasRequiredJson;
+function requireJson() {
+	if (hasRequiredJson) return json;
+	hasRequiredJson = 1;
+	json = requireFailsafe().extend({ implicit: [
+		require_null(),
+		requireBool(),
+		requireInt(),
+		requireFloat()
+	] });
+	return json;
+}
+__name(requireJson, "requireJson");
+var core;
+var hasRequiredCore;
+function requireCore() {
+	if (hasRequiredCore) return core;
+	hasRequiredCore = 1;
+	core = requireJson();
+	return core;
+}
+__name(requireCore, "requireCore");
+var timestamp;
+var hasRequiredTimestamp;
+function requireTimestamp() {
+	if (hasRequiredTimestamp) return timestamp;
+	hasRequiredTimestamp = 1;
+	const Type2 = requireType();
+	const YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+	const YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+	function resolveYamlTimestamp(data) {
+		if (data === null) return false;
+		if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+		if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+		return false;
+	}
+	__name(resolveYamlTimestamp, "resolveYamlTimestamp");
+	function constructYamlTimestamp(data) {
+		let fraction = 0;
+		let delta = null;
+		let match = YAML_DATE_REGEXP.exec(data);
+		if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+		if (match === null) throw new Error("Date resolve error");
+		const year = +match[1];
+		const month = +match[2] - 1;
+		const day = +match[3];
+		if (!match[4]) return new Date(Date.UTC(year, month, day));
+		const hour = +match[4];
+		const minute = +match[5];
+		const second = +match[6];
+		if (match[7]) {
+			fraction = match[7].slice(0, 3);
+			while (fraction.length < 3) fraction += "0";
+			fraction = +fraction;
+		}
+		if (match[9]) {
+			const tzHour = +match[10];
+			const tzMinute = +(match[11] || 0);
+			delta = (tzHour * 60 + tzMinute) * 6e4;
+			if (match[9] === "-") delta = -delta;
+		}
+		const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+		if (delta) date.setTime(date.getTime() - delta);
+		return date;
+	}
+	__name(constructYamlTimestamp, "constructYamlTimestamp");
+	function representYamlTimestamp(object) {
+		return object.toISOString();
+	}
+	__name(representYamlTimestamp, "representYamlTimestamp");
+	timestamp = new Type2("tag:yaml.org,2002:timestamp", {
+		kind: "scalar",
+		resolve: resolveYamlTimestamp,
+		construct: constructYamlTimestamp,
+		instanceOf: Date,
+		represent: representYamlTimestamp
+	});
+	return timestamp;
+}
+__name(requireTimestamp, "requireTimestamp");
+var merge;
+var hasRequiredMerge;
+function requireMerge() {
+	if (hasRequiredMerge) return merge;
+	hasRequiredMerge = 1;
+	const Type2 = requireType();
+	function resolveYamlMerge(data) {
+		return data === "<<" || data === null;
+	}
+	__name(resolveYamlMerge, "resolveYamlMerge");
+	merge = new Type2("tag:yaml.org,2002:merge", {
+		kind: "scalar",
+		resolve: resolveYamlMerge
+	});
+	return merge;
+}
+__name(requireMerge, "requireMerge");
+var binary;
+var hasRequiredBinary;
+function requireBinary() {
+	if (hasRequiredBinary) return binary;
+	hasRequiredBinary = 1;
+	const Type2 = requireType();
+	const BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+	function resolveYamlBinary(data) {
+		if (data === null) return false;
+		let bitlen = 0;
+		const max = data.length;
+		const map2 = BASE64_MAP;
+		for (let idx = 0; idx < max; idx++) {
+			const code = map2.indexOf(data.charAt(idx));
+			if (code > 64) continue;
+			if (code < 0) return false;
+			bitlen += 6;
+		}
+		return bitlen % 8 === 0;
+	}
+	__name(resolveYamlBinary, "resolveYamlBinary");
+	function constructYamlBinary(data) {
+		const input = data.replace(/[\r\n=]/g, "");
+		const max = input.length;
+		const map2 = BASE64_MAP;
+		let bits = 0;
+		const result = [];
+		for (let idx = 0; idx < max; idx++) {
+			if (idx % 4 === 0 && idx) {
+				result.push(bits >> 16 & 255);
+				result.push(bits >> 8 & 255);
+				result.push(bits & 255);
+			}
+			bits = bits << 6 | map2.indexOf(input.charAt(idx));
+		}
+		const tailbits = max % 4 * 6;
+		if (tailbits === 0) {
+			result.push(bits >> 16 & 255);
+			result.push(bits >> 8 & 255);
+			result.push(bits & 255);
+		} else if (tailbits === 18) {
+			result.push(bits >> 10 & 255);
+			result.push(bits >> 2 & 255);
+		} else if (tailbits === 12) result.push(bits >> 4 & 255);
+		return new Uint8Array(result);
+	}
+	__name(constructYamlBinary, "constructYamlBinary");
+	function representYamlBinary(object) {
+		let result = "";
+		let bits = 0;
+		const max = object.length;
+		const map2 = BASE64_MAP;
+		for (let idx = 0; idx < max; idx++) {
+			if (idx % 3 === 0 && idx) {
+				result += map2[bits >> 18 & 63];
+				result += map2[bits >> 12 & 63];
+				result += map2[bits >> 6 & 63];
+				result += map2[bits & 63];
+			}
+			bits = (bits << 8) + object[idx];
+		}
+		const tail = max % 3;
+		if (tail === 0) {
+			result += map2[bits >> 18 & 63];
+			result += map2[bits >> 12 & 63];
+			result += map2[bits >> 6 & 63];
+			result += map2[bits & 63];
+		} else if (tail === 2) {
+			result += map2[bits >> 10 & 63];
+			result += map2[bits >> 4 & 63];
+			result += map2[bits << 2 & 63];
+			result += map2[64];
+		} else if (tail === 1) {
+			result += map2[bits >> 2 & 63];
+			result += map2[bits << 4 & 63];
+			result += map2[64];
+			result += map2[64];
+		}
+		return result;
+	}
+	__name(representYamlBinary, "representYamlBinary");
+	function isBinary(obj) {
+		return Object.prototype.toString.call(obj) === "[object Uint8Array]";
+	}
+	__name(isBinary, "isBinary");
+	binary = new Type2("tag:yaml.org,2002:binary", {
+		kind: "scalar",
+		resolve: resolveYamlBinary,
+		construct: constructYamlBinary,
+		predicate: isBinary,
+		represent: representYamlBinary
+	});
+	return binary;
+}
+__name(requireBinary, "requireBinary");
+var omap;
+var hasRequiredOmap;
+function requireOmap() {
+	if (hasRequiredOmap) return omap;
+	hasRequiredOmap = 1;
+	const Type2 = requireType();
+	const _hasOwnProperty = Object.prototype.hasOwnProperty;
+	const _toString = Object.prototype.toString;
+	function resolveYamlOmap(data) {
+		if (data === null) return true;
+		const objectKeys = [];
+		const object = data;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			const pair = object[index];
+			let pairHasKey = false;
+			if (_toString.call(pair) !== "[object Object]") return false;
+			let pairKey;
+			for (pairKey in pair) if (_hasOwnProperty.call(pair, pairKey)) if (!pairHasKey) pairHasKey = true;
+			else return false;
+			if (!pairHasKey) return false;
+			if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
+			else return false;
+		}
+		return true;
+	}
+	__name(resolveYamlOmap, "resolveYamlOmap");
+	function constructYamlOmap(data) {
+		return data !== null ? data : [];
+	}
+	__name(constructYamlOmap, "constructYamlOmap");
+	omap = new Type2("tag:yaml.org,2002:omap", {
+		kind: "sequence",
+		resolve: resolveYamlOmap,
+		construct: constructYamlOmap
+	});
+	return omap;
+}
+__name(requireOmap, "requireOmap");
+var pairs;
+var hasRequiredPairs;
+function requirePairs() {
+	if (hasRequiredPairs) return pairs;
+	hasRequiredPairs = 1;
+	const Type2 = requireType();
+	const _toString = Object.prototype.toString;
+	function resolveYamlPairs(data) {
+		if (data === null) return true;
+		const object = data;
+		const result = new Array(object.length);
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			const pair = object[index];
+			if (_toString.call(pair) !== "[object Object]") return false;
+			const keys = Object.keys(pair);
+			if (keys.length !== 1) return false;
+			result[index] = [keys[0], pair[keys[0]]];
+		}
+		return true;
+	}
+	__name(resolveYamlPairs, "resolveYamlPairs");
+	function constructYamlPairs(data) {
+		if (data === null) return [];
+		const object = data;
+		const result = new Array(object.length);
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			const pair = object[index];
+			const keys = Object.keys(pair);
+			result[index] = [keys[0], pair[keys[0]]];
+		}
+		return result;
+	}
+	__name(constructYamlPairs, "constructYamlPairs");
+	pairs = new Type2("tag:yaml.org,2002:pairs", {
+		kind: "sequence",
+		resolve: resolveYamlPairs,
+		construct: constructYamlPairs
+	});
+	return pairs;
+}
+__name(requirePairs, "requirePairs");
+var set;
+var hasRequiredSet;
+function requireSet() {
+	if (hasRequiredSet) return set;
+	hasRequiredSet = 1;
+	const Type2 = requireType();
+	const _hasOwnProperty = Object.prototype.hasOwnProperty;
+	function resolveYamlSet(data) {
+		if (data === null) return true;
+		const object = data;
+		for (const key in object) if (_hasOwnProperty.call(object, key)) {
+			if (object[key] !== null) return false;
+		}
+		return true;
+	}
+	__name(resolveYamlSet, "resolveYamlSet");
+	function constructYamlSet(data) {
+		return data !== null ? data : {};
+	}
+	__name(constructYamlSet, "constructYamlSet");
+	set = new Type2("tag:yaml.org,2002:set", {
+		kind: "mapping",
+		resolve: resolveYamlSet,
+		construct: constructYamlSet
+	});
+	return set;
+}
+__name(requireSet, "requireSet");
+var _default;
+var hasRequired_default;
+function require_default() {
+	if (hasRequired_default) return _default;
+	hasRequired_default = 1;
+	_default = requireCore().extend({
+		implicit: [requireTimestamp(), requireMerge()],
+		explicit: [
+			requireBinary(),
+			requireOmap(),
+			requirePairs(),
+			requireSet()
+		]
+	});
+	return _default;
+}
+__name(require_default, "require_default");
+var hasRequiredLoader;
+function requireLoader() {
+	if (hasRequiredLoader) return loader;
+	hasRequiredLoader = 1;
+	const common2 = requireCommon();
+	const YAMLException2 = requireException();
+	const makeSnippet = requireSnippet();
+	const DEFAULT_SCHEMA2 = require_default();
+	const _hasOwnProperty = Object.prototype.hasOwnProperty;
+	const CONTEXT_FLOW_IN = 1;
+	const CONTEXT_FLOW_OUT = 2;
+	const CONTEXT_BLOCK_IN = 3;
+	const CONTEXT_BLOCK_OUT = 4;
+	const CHOMPING_CLIP = 1;
+	const CHOMPING_STRIP = 2;
+	const CHOMPING_KEEP = 3;
+	const PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+	const PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+	const PATTERN_FLOW_INDICATORS = /[,\[\]{}]/;
+	const PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
+	const PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
+	function _class(obj) {
+		return Object.prototype.toString.call(obj);
+	}
+	__name(_class, "_class");
+	function isEol(c) {
+		return c === 10 || c === 13;
+	}
+	__name(isEol, "isEol");
+	function isWhiteSpace(c) {
+		return c === 9 || c === 32;
+	}
+	__name(isWhiteSpace, "isWhiteSpace");
+	function isWsOrEol(c) {
+		return c === 9 || c === 32 || c === 10 || c === 13;
+	}
+	__name(isWsOrEol, "isWsOrEol");
+	function isFlowIndicator(c) {
+		return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+	}
+	__name(isFlowIndicator, "isFlowIndicator");
+	function fromHexCode(c) {
+		if (c >= 48 && c <= 57) return c - 48;
+		const lc = c | 32;
+		if (lc >= 97 && lc <= 102) return lc - 97 + 10;
+		return -1;
+	}
+	__name(fromHexCode, "fromHexCode");
+	function escapedHexLen(c) {
+		if (c === 120) return 2;
+		if (c === 117) return 4;
+		if (c === 85) return 8;
+		return 0;
+	}
+	__name(escapedHexLen, "escapedHexLen");
+	function fromDecimalCode(c) {
+		if (c >= 48 && c <= 57) return c - 48;
+		return -1;
+	}
+	__name(fromDecimalCode, "fromDecimalCode");
+	function simpleEscapeSequence(c) {
+		switch (c) {
+			case 48: return "\0";
+			case 97: return "\x07";
+			case 98: return "\b";
+			case 116: return "	";
+			case 9: return "	";
+			case 110: return "\n";
+			case 118: return "\v";
+			case 102: return "\f";
+			case 114: return "\r";
+			case 101: return "\x1B";
+			case 32: return " ";
+			case 34: return "\"";
+			case 47: return "/";
+			case 92: return "\\";
+			case 78: return "…";
+			case 95: return "\xA0";
+			case 76: return "\u2028";
+			case 80: return "\u2029";
+			default: return "";
+		}
+	}
+	__name(simpleEscapeSequence, "simpleEscapeSequence");
+	function charFromCodepoint(c) {
+		if (c <= 65535) return String.fromCharCode(c);
+		return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
+	}
+	__name(charFromCodepoint, "charFromCodepoint");
+	function setProperty(object, key, value) {
+		if (key === "__proto__") Object.defineProperty(object, key, {
+			configurable: true,
+			enumerable: true,
+			writable: true,
+			value
+		});
+		else object[key] = value;
+	}
+	__name(setProperty, "setProperty");
+	const simpleEscapeCheck = new Array(256);
+	const simpleEscapeMap = new Array(256);
+	for (let i = 0; i < 256; i++) {
+		simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+		simpleEscapeMap[i] = simpleEscapeSequence(i);
+	}
+	function State(input, options) {
+		this.input = input;
+		this.filename = options["filename"] || null;
+		this.schema = options["schema"] || DEFAULT_SCHEMA2;
+		this.onWarning = options["onWarning"] || null;
+		this.legacy = options["legacy"] || false;
+		this.json = options["json"] || false;
+		this.listener = options["listener"] || null;
+		this.maxDepth = typeof options["maxDepth"] === "number" ? options["maxDepth"] : 100;
+		this.maxTotalMergeKeys = typeof options["maxTotalMergeKeys"] === "number" ? options["maxTotalMergeKeys"] : 1e4;
+		this.implicitTypes = this.schema.compiledImplicit;
+		this.typeMap = this.schema.compiledTypeMap;
+		this.length = input.length;
+		this.position = 0;
+		this.line = 0;
+		this.lineStart = 0;
+		this.lineIndent = 0;
+		this.depth = 0;
+		this.totalMergeKeys = 0;
+		this.firstTabInLine = -1;
+		this.documents = [];
+		this.anchorMapTransactions = [];
+	}
+	__name(State, "State");
+	function generateError(state, message) {
+		const mark = {
+			name: state.filename,
+			buffer: state.input.slice(0, -1),
+			position: state.position,
+			line: state.line,
+			column: state.position - state.lineStart
+		};
+		mark.snippet = makeSnippet(mark);
+		return new YAMLException2(message, mark);
+	}
+	__name(generateError, "generateError");
+	function throwError(state, message) {
+		throw generateError(state, message);
+	}
+	__name(throwError, "throwError");
+	function throwWarning(state, message) {
+		if (state.onWarning) state.onWarning.call(null, generateError(state, message));
+	}
+	__name(throwWarning, "throwWarning");
+	function storeAnchor(state, name, value) {
+		const transactions = state.anchorMapTransactions;
+		if (transactions.length !== 0) {
+			const transaction = transactions[transactions.length - 1];
+			if (!_hasOwnProperty.call(transaction, name)) transaction[name] = {
+				existed: _hasOwnProperty.call(state.anchorMap, name),
+				value: state.anchorMap[name]
+			};
+		}
+		state.anchorMap[name] = value;
+	}
+	__name(storeAnchor, "storeAnchor");
+	function beginAnchorTransaction(state) {
+		state.anchorMapTransactions.push(/* @__PURE__ */ Object.create(null));
+	}
+	__name(beginAnchorTransaction, "beginAnchorTransaction");
+	function commitAnchorTransaction(state) {
+		const transaction = state.anchorMapTransactions.pop();
+		const transactions = state.anchorMapTransactions;
+		if (transactions.length === 0) return;
+		const parent = transactions[transactions.length - 1];
+		const names = Object.keys(transaction);
+		for (let index = 0, length = names.length; index < length; index += 1) {
+			const name = names[index];
+			if (!_hasOwnProperty.call(parent, name)) parent[name] = transaction[name];
+		}
+	}
+	__name(commitAnchorTransaction, "commitAnchorTransaction");
+	function rollbackAnchorTransaction(state) {
+		const transaction = state.anchorMapTransactions.pop();
+		const names = Object.keys(transaction);
+		for (let index = names.length - 1; index >= 0; index -= 1) {
+			const entry = transaction[names[index]];
+			if (entry.existed) state.anchorMap[names[index]] = entry.value;
+			else delete state.anchorMap[names[index]];
+		}
+	}
+	__name(rollbackAnchorTransaction, "rollbackAnchorTransaction");
+	function snapshotState(state) {
+		return {
+			position: state.position,
+			line: state.line,
+			lineStart: state.lineStart,
+			lineIndent: state.lineIndent,
+			firstTabInLine: state.firstTabInLine,
+			tag: state.tag,
+			anchor: state.anchor,
+			kind: state.kind,
+			result: state.result
+		};
+	}
+	__name(snapshotState, "snapshotState");
+	function restoreState(state, snapshot) {
+		state.position = snapshot.position;
+		state.line = snapshot.line;
+		state.lineStart = snapshot.lineStart;
+		state.lineIndent = snapshot.lineIndent;
+		state.firstTabInLine = snapshot.firstTabInLine;
+		state.tag = snapshot.tag;
+		state.anchor = snapshot.anchor;
+		state.kind = snapshot.kind;
+		state.result = snapshot.result;
+	}
+	__name(restoreState, "restoreState");
+	const directiveHandlers = {
+		YAML: /* @__PURE__ */ __name(function handleYamlDirective(state, name, args) {
+			if (state.version !== null) throwError(state, "duplication of %YAML directive");
+			if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
+			const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+			if (match === null) throwError(state, "ill-formed argument of the YAML directive");
+			const major = parseInt(match[1], 10);
+			const minor = parseInt(match[2], 10);
+			if (major !== 1) throwError(state, "unacceptable YAML version of the document");
+			state.version = args[0];
+			state.checkLineBreaks = minor < 2;
+			if (minor !== 1 && minor !== 2) throwWarning(state, "unsupported YAML version of the document");
+		}, "handleYamlDirective"),
+		TAG: /* @__PURE__ */ __name(function handleTagDirective(state, name, args) {
+			let prefix;
+			if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments");
+			const handle = args[0];
+			prefix = args[1];
+			if (!PATTERN_TAG_HANDLE.test(handle)) throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+			if (_hasOwnProperty.call(state.tagMap, handle)) throwError(state, "there is a previously declared suffix for \"" + handle + "\" tag handle");
+			if (!PATTERN_TAG_URI.test(prefix)) throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+			try {
+				prefix = decodeURIComponent(prefix);
+			} catch (err) {
+				throwError(state, "tag prefix is malformed: " + prefix);
+			}
+			state.tagMap[handle] = prefix;
+		}, "handleTagDirective")
+	};
+	function captureSegment(state, start, end, checkJson) {
+		if (start < end) {
+			const _result = state.input.slice(start, end);
+			if (checkJson) for (let _position = 0, _length = _result.length; _position < _length; _position += 1) {
+				const _character = _result.charCodeAt(_position);
+				if (!(_character === 9 || _character >= 32 && _character <= 1114111)) throwError(state, "expected valid JSON character");
+			}
+			else if (PATTERN_NON_PRINTABLE.test(_result)) throwError(state, "the stream contains non-printable characters");
+			state.result += _result;
+		}
+	}
+	__name(captureSegment, "captureSegment");
+	function mergeMappings(state, destination, source, overridableKeys) {
+		if (!common2.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+		const sourceKeys = Object.keys(source);
+		for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+			const key = sourceKeys[index];
+			if (state.maxTotalMergeKeys !== -1 && ++state.totalMergeKeys > state.maxTotalMergeKeys) throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
+			if (!_hasOwnProperty.call(destination, key)) {
+				setProperty(destination, key, source[key]);
+				overridableKeys[key] = true;
+			}
+		}
+	}
+	__name(mergeMappings, "mergeMappings");
+	function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+		if (Array.isArray(keyNode)) {
+			keyNode = Array.prototype.slice.call(keyNode);
+			for (let index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+				if (Array.isArray(keyNode[index])) throwError(state, "nested arrays are not supported inside keys");
+				if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") keyNode[index] = "[object Object]";
+			}
+		}
+		if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") keyNode = "[object Object]";
+		keyNode = String(keyNode);
+		if (_result === null) _result = {};
+		if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) mergeMappings(state, _result, valueNode[index], overridableKeys);
+		else mergeMappings(state, _result, valueNode, overridableKeys);
+		else {
+			if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
+				state.line = startLine || state.line;
+				state.lineStart = startLineStart || state.lineStart;
+				state.position = startPos || state.position;
+				throwError(state, "duplicated mapping key");
+			}
+			setProperty(_result, keyNode, valueNode);
+			delete overridableKeys[keyNode];
+		}
+		return _result;
+	}
+	__name(storeMappingPair, "storeMappingPair");
+	function readLineBreak(state) {
+		const ch = state.input.charCodeAt(state.position);
+		if (ch === 10) state.position++;
+		else if (ch === 13) {
+			state.position++;
+			if (state.input.charCodeAt(state.position) === 10) state.position++;
+		} else throwError(state, "a line break is expected");
+		state.line += 1;
+		state.lineStart = state.position;
+		state.firstTabInLine = -1;
+	}
+	__name(readLineBreak, "readLineBreak");
+	function skipSeparationSpace(state, allowComments, checkIndent) {
+		let lineBreaks = 0;
+		let ch = state.input.charCodeAt(state.position);
+		while (ch !== 0) {
+			while (isWhiteSpace(ch)) {
+				if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position;
+				ch = state.input.charCodeAt(++state.position);
+			}
+			if (allowComments && ch === 35) do
+				ch = state.input.charCodeAt(++state.position);
+			while (ch !== 10 && ch !== 13 && ch !== 0);
+			if (isEol(ch)) {
+				readLineBreak(state);
+				ch = state.input.charCodeAt(state.position);
+				lineBreaks++;
+				state.lineIndent = 0;
+				while (ch === 32) {
+					state.lineIndent++;
+					ch = state.input.charCodeAt(++state.position);
+				}
+			} else break;
+		}
+		if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) throwWarning(state, "deficient indentation");
+		return lineBreaks;
+	}
+	__name(skipSeparationSpace, "skipSeparationSpace");
+	function testDocumentSeparator(state) {
+		let _position = state.position;
+		let ch = state.input.charCodeAt(_position);
+		if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+			_position += 3;
+			ch = state.input.charCodeAt(_position);
+			if (ch === 0 || isWsOrEol(ch)) return true;
+		}
+		return false;
+	}
+	__name(testDocumentSeparator, "testDocumentSeparator");
+	function writeFoldedLines(state, count) {
+		if (count === 1) state.result += " ";
+		else if (count > 1) state.result += common2.repeat("\n", count - 1);
+	}
+	__name(writeFoldedLines, "writeFoldedLines");
+	function readPlainScalar(state, nodeIndent, withinFlowCollection) {
+		let captureStart;
+		let captureEnd;
+		let hasPendingContent;
+		let _line;
+		let _lineStart;
+		let _lineIndent;
+		const _kind = state.kind;
+		const _result = state.result;
+		let ch = state.input.charCodeAt(state.position);
+		if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) return false;
+		if (ch === 63 || ch === 45) {
+			const following = state.input.charCodeAt(state.position + 1);
+			if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) return false;
+		}
+		state.kind = "scalar";
+		state.result = "";
+		captureStart = captureEnd = state.position;
+		hasPendingContent = false;
+		while (ch !== 0) {
+			if (ch === 58) {
+				const following = state.input.charCodeAt(state.position + 1);
+				if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) break;
+			} else if (ch === 35) {
+				if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break;
+			} else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch)) break;
+			else if (isEol(ch)) {
+				_line = state.line;
+				_lineStart = state.lineStart;
+				_lineIndent = state.lineIndent;
+				skipSeparationSpace(state, false, -1);
+				if (state.lineIndent >= nodeIndent) {
+					hasPendingContent = true;
+					ch = state.input.charCodeAt(state.position);
+					continue;
+				} else {
+					state.position = captureEnd;
+					state.line = _line;
+					state.lineStart = _lineStart;
+					state.lineIndent = _lineIndent;
+					break;
+				}
+			}
+			if (hasPendingContent) {
+				captureSegment(state, captureStart, captureEnd, false);
+				writeFoldedLines(state, state.line - _line);
+				captureStart = captureEnd = state.position;
+				hasPendingContent = false;
+			}
+			if (!isWhiteSpace(ch)) captureEnd = state.position + 1;
+			ch = state.input.charCodeAt(++state.position);
+		}
+		captureSegment(state, captureStart, captureEnd, false);
+		if (state.result) return true;
+		state.kind = _kind;
+		state.result = _result;
+		return false;
+	}
+	__name(readPlainScalar, "readPlainScalar");
+	function readSingleQuotedScalar(state, nodeIndent) {
+		let captureStart;
+		let captureEnd;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 39) return false;
+		state.kind = "scalar";
+		state.result = "";
+		state.position++;
+		captureStart = captureEnd = state.position;
+		while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 39) {
+			captureSegment(state, captureStart, state.position, true);
+			ch = state.input.charCodeAt(++state.position);
+			if (ch === 39) {
+				captureStart = state.position;
+				state.position++;
+				captureEnd = state.position;
+			} else return true;
+		} else if (isEol(ch)) {
+			captureSegment(state, captureStart, captureEnd, true);
+			writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+			captureStart = captureEnd = state.position;
+		} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a single quoted scalar");
+		else {
+			state.position++;
+			if (!isWhiteSpace(ch)) captureEnd = state.position;
+		}
+		throwError(state, "unexpected end of the stream within a single quoted scalar");
+	}
+	__name(readSingleQuotedScalar, "readSingleQuotedScalar");
+	function readDoubleQuotedScalar(state, nodeIndent) {
+		let captureStart;
+		let captureEnd;
+		let tmp;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 34) return false;
+		state.kind = "scalar";
+		state.result = "";
+		state.position++;
+		captureStart = captureEnd = state.position;
+		while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 34) {
+			captureSegment(state, captureStart, state.position, true);
+			state.position++;
+			return true;
+		} else if (ch === 92) {
+			captureSegment(state, captureStart, state.position, true);
+			ch = state.input.charCodeAt(++state.position);
+			if (isEol(ch)) skipSeparationSpace(state, false, nodeIndent);
+			else if (ch < 256 && simpleEscapeCheck[ch]) {
+				state.result += simpleEscapeMap[ch];
+				state.position++;
+			} else if ((tmp = escapedHexLen(ch)) > 0) {
+				let hexLength = tmp;
+				let hexResult = 0;
+				for (; hexLength > 0; hexLength--) {
+					ch = state.input.charCodeAt(++state.position);
+					if ((tmp = fromHexCode(ch)) >= 0) hexResult = (hexResult << 4) + tmp;
+					else throwError(state, "expected hexadecimal character");
+				}
+				state.result += charFromCodepoint(hexResult);
+				state.position++;
+			} else throwError(state, "unknown escape sequence");
+			captureStart = captureEnd = state.position;
+		} else if (isEol(ch)) {
+			captureSegment(state, captureStart, captureEnd, true);
+			writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+			captureStart = captureEnd = state.position;
+		} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a double quoted scalar");
+		else {
+			state.position++;
+			if (!isWhiteSpace(ch)) captureEnd = state.position;
+		}
+		throwError(state, "unexpected end of the stream within a double quoted scalar");
+	}
+	__name(readDoubleQuotedScalar, "readDoubleQuotedScalar");
+	function readFlowCollection(state, nodeIndent) {
+		let readNext = true;
+		let _line;
+		let _lineStart;
+		let _pos;
+		const _tag = state.tag;
+		let _result;
+		const _anchor = state.anchor;
+		let terminator;
+		let isPair;
+		let isExplicitPair;
+		let isMapping;
+		const overridableKeys = /* @__PURE__ */ Object.create(null);
+		let keyNode;
+		let keyTag;
+		let valueNode;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch === 91) {
+			terminator = 93;
+			isMapping = false;
+			_result = [];
+		} else if (ch === 123) {
+			terminator = 125;
+			isMapping = true;
+			_result = {};
+		} else return false;
+		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+		ch = state.input.charCodeAt(++state.position);
+		while (ch !== 0) {
+			skipSeparationSpace(state, true, nodeIndent);
+			ch = state.input.charCodeAt(state.position);
+			if (ch === terminator) {
+				state.position++;
+				state.tag = _tag;
+				state.anchor = _anchor;
+				state.kind = isMapping ? "mapping" : "sequence";
+				state.result = _result;
+				return true;
+			} else if (!readNext) throwError(state, "missed comma between flow collection entries");
+			else if (ch === 44) throwError(state, "expected the node content, but found ','");
+			keyTag = keyNode = valueNode = null;
+			isPair = isExplicitPair = false;
+			if (ch === 63) {
+				if (isWsOrEol(state.input.charCodeAt(state.position + 1))) {
+					isPair = isExplicitPair = true;
+					state.position++;
+					skipSeparationSpace(state, true, nodeIndent);
+				}
+			}
+			_line = state.line;
+			_lineStart = state.lineStart;
+			_pos = state.position;
+			composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+			keyTag = state.tag;
+			keyNode = state.result;
+			skipSeparationSpace(state, true, nodeIndent);
+			ch = state.input.charCodeAt(state.position);
+			if ((isExplicitPair || state.line === _line) && ch === 58) {
+				isPair = true;
+				ch = state.input.charCodeAt(++state.position);
+				skipSeparationSpace(state, true, nodeIndent);
+				composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+				valueNode = state.result;
+			}
+			if (isMapping) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
+			else if (isPair) _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
+			else _result.push(keyNode);
+			skipSeparationSpace(state, true, nodeIndent);
+			ch = state.input.charCodeAt(state.position);
+			if (ch === 44) {
+				readNext = true;
+				ch = state.input.charCodeAt(++state.position);
+			} else readNext = false;
+		}
+		throwError(state, "unexpected end of the stream within a flow collection");
+	}
+	__name(readFlowCollection, "readFlowCollection");
+	function readBlockScalar(state, nodeIndent) {
+		let folding;
+		let chomping = CHOMPING_CLIP;
+		let didReadContent = false;
+		let detectedIndent = false;
+		let textIndent = nodeIndent;
+		let emptyLines = 0;
+		let atMoreIndented = false;
+		let tmp;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch === 124) folding = false;
+		else if (ch === 62) folding = true;
+		else return false;
+		state.kind = "scalar";
+		state.result = "";
+		while (ch !== 0) {
+			ch = state.input.charCodeAt(++state.position);
+			if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
+			else throwError(state, "repeat of a chomping mode identifier");
+			else if ((tmp = fromDecimalCode(ch)) >= 0) if (tmp === 0) throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+			else if (!detectedIndent) {
+				textIndent = nodeIndent + tmp - 1;
+				detectedIndent = true;
+			} else throwError(state, "repeat of an indentation width identifier");
+			else break;
+		}
+		if (isWhiteSpace(ch)) {
+			do
+				ch = state.input.charCodeAt(++state.position);
+			while (isWhiteSpace(ch));
+			if (ch === 35) do
+				ch = state.input.charCodeAt(++state.position);
+			while (!isEol(ch) && ch !== 0);
+		}
+		while (ch !== 0) {
+			readLineBreak(state);
+			state.lineIndent = 0;
+			ch = state.input.charCodeAt(state.position);
+			while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
+				state.lineIndent++;
+				ch = state.input.charCodeAt(++state.position);
+			}
+			if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent;
+			if (isEol(ch)) {
+				emptyLines++;
+				continue;
+			}
+			if (!detectedIndent && textIndent === 0) throwError(state, "missing indentation for block scalar");
+			if (state.lineIndent < textIndent) {
+				if (chomping === CHOMPING_KEEP) state.result += common2.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+				else if (chomping === CHOMPING_CLIP) {
+					if (didReadContent) state.result += "\n";
+				}
+				break;
+			}
+			if (folding) if (isWhiteSpace(ch)) {
+				atMoreIndented = true;
+				state.result += common2.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+			} else if (atMoreIndented) {
+				atMoreIndented = false;
+				state.result += common2.repeat("\n", emptyLines + 1);
+			} else if (emptyLines === 0) {
+				if (didReadContent) state.result += " ";
+			} else state.result += common2.repeat("\n", emptyLines);
+			else state.result += common2.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+			didReadContent = true;
+			detectedIndent = true;
+			emptyLines = 0;
+			const captureStart = state.position;
+			while (!isEol(ch) && ch !== 0) ch = state.input.charCodeAt(++state.position);
+			captureSegment(state, captureStart, state.position, false);
+		}
+		return true;
+	}
+	__name(readBlockScalar, "readBlockScalar");
+	function readBlockSequence(state, nodeIndent) {
+		const _tag = state.tag;
+		const _anchor = state.anchor;
+		const _result = [];
+		let detected = false;
+		if (state.firstTabInLine !== -1) return false;
+		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+		let ch = state.input.charCodeAt(state.position);
+		while (ch !== 0) {
+			if (state.firstTabInLine !== -1) {
+				state.position = state.firstTabInLine;
+				throwError(state, "tab characters must not be used in indentation");
+			}
+			if (ch !== 45) break;
+			if (!isWsOrEol(state.input.charCodeAt(state.position + 1))) break;
+			detected = true;
+			state.position++;
+			if (skipSeparationSpace(state, true, -1)) {
+				if (state.lineIndent <= nodeIndent) {
+					_result.push(null);
+					ch = state.input.charCodeAt(state.position);
+					continue;
+				}
+			}
+			const _line = state.line;
+			composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+			_result.push(state.result);
+			skipSeparationSpace(state, true, -1);
+			ch = state.input.charCodeAt(state.position);
+			if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a sequence entry");
+			else if (state.lineIndent < nodeIndent) break;
+		}
+		if (detected) {
+			state.tag = _tag;
+			state.anchor = _anchor;
+			state.kind = "sequence";
+			state.result = _result;
+			return true;
+		}
+		return false;
+	}
+	__name(readBlockSequence, "readBlockSequence");
+	function readBlockMapping(state, nodeIndent, flowIndent) {
+		let allowCompact;
+		let _keyLine;
+		let _keyLineStart;
+		let _keyPos;
+		const _tag = state.tag;
+		const _anchor = state.anchor;
+		const _result = {};
+		const overridableKeys = /* @__PURE__ */ Object.create(null);
+		let keyTag = null;
+		let keyNode = null;
+		let valueNode = null;
+		let atExplicitKey = false;
+		let detected = false;
+		if (state.firstTabInLine !== -1) return false;
+		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+		let ch = state.input.charCodeAt(state.position);
+		while (ch !== 0) {
+			if (!atExplicitKey && state.firstTabInLine !== -1) {
+				state.position = state.firstTabInLine;
+				throwError(state, "tab characters must not be used in indentation");
+			}
+			const following = state.input.charCodeAt(state.position + 1);
+			const _line = state.line;
+			if ((ch === 63 || ch === 58) && isWsOrEol(following)) {
+				if (ch === 63) {
+					if (atExplicitKey) {
+						storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+						keyTag = keyNode = valueNode = null;
+					}
+					detected = true;
+					atExplicitKey = true;
+					allowCompact = true;
+				} else if (atExplicitKey) {
+					atExplicitKey = false;
+					allowCompact = true;
+				} else throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+				state.position += 1;
+				ch = following;
+			} else {
+				_keyLine = state.line;
+				_keyLineStart = state.lineStart;
+				_keyPos = state.position;
+				if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break;
+				if (state.line === _line) {
+					ch = state.input.charCodeAt(state.position);
+					while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
+					if (ch === 58) {
+						ch = state.input.charCodeAt(++state.position);
+						if (!isWsOrEol(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+						if (atExplicitKey) {
+							storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+							keyTag = keyNode = valueNode = null;
+						}
+						detected = true;
+						atExplicitKey = false;
+						allowCompact = false;
+						keyTag = state.tag;
+						keyNode = state.result;
+					} else if (detected) throwError(state, "can not read an implicit mapping pair; a colon is missed");
+					else {
+						state.tag = _tag;
+						state.anchor = _anchor;
+						return true;
+					}
+				} else if (detected) throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+				else {
+					state.tag = _tag;
+					state.anchor = _anchor;
+					return true;
+				}
+			}
+			if (state.line === _line || state.lineIndent > nodeIndent) {
+				if (atExplicitKey) {
+					_keyLine = state.line;
+					_keyLineStart = state.lineStart;
+					_keyPos = state.position;
+				}
+				if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) if (atExplicitKey) keyNode = state.result;
+				else valueNode = state.result;
+				if (!atExplicitKey) {
+					storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
+					keyTag = keyNode = valueNode = null;
+				}
+				skipSeparationSpace(state, true, -1);
+				ch = state.input.charCodeAt(state.position);
+			}
+			if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry");
+			else if (state.lineIndent < nodeIndent) break;
+		}
+		if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+		if (detected) {
+			state.tag = _tag;
+			state.anchor = _anchor;
+			state.kind = "mapping";
+			state.result = _result;
+		}
+		return detected;
+	}
+	__name(readBlockMapping, "readBlockMapping");
+	function readTagProperty(state) {
+		let isVerbatim = false;
+		let isNamed = false;
+		let tagHandle;
+		let tagName;
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 33) return false;
+		if (state.tag !== null) throwError(state, "duplication of a tag property");
+		ch = state.input.charCodeAt(++state.position);
+		if (ch === 60) {
+			isVerbatim = true;
+			ch = state.input.charCodeAt(++state.position);
+		} else if (ch === 33) {
+			isNamed = true;
+			tagHandle = "!!";
+			ch = state.input.charCodeAt(++state.position);
+		} else tagHandle = "!";
+		let _position = state.position;
+		if (isVerbatim) {
+			do
+				ch = state.input.charCodeAt(++state.position);
+			while (ch !== 0 && ch !== 62);
+			if (state.position < state.length) {
+				tagName = state.input.slice(_position, state.position);
+				ch = state.input.charCodeAt(++state.position);
+			} else throwError(state, "unexpected end of the stream within a verbatim tag");
+		} else {
+			while (ch !== 0 && !isWsOrEol(ch)) {
+				if (ch === 33) if (!isNamed) {
+					tagHandle = state.input.slice(_position - 1, state.position + 1);
+					if (!PATTERN_TAG_HANDLE.test(tagHandle)) throwError(state, "named tag handle cannot contain such characters");
+					isNamed = true;
+					_position = state.position + 1;
+				} else throwError(state, "tag suffix cannot contain exclamation marks");
+				ch = state.input.charCodeAt(++state.position);
+			}
+			tagName = state.input.slice(_position, state.position);
+			if (PATTERN_FLOW_INDICATORS.test(tagName)) throwError(state, "tag suffix cannot contain flow indicator characters");
+		}
+		if (tagName && !PATTERN_TAG_URI.test(tagName)) throwError(state, "tag name cannot contain such characters: " + tagName);
+		try {
+			tagName = decodeURIComponent(tagName);
+		} catch (err) {
+			throwError(state, "tag name is malformed: " + tagName);
+		}
+		if (isVerbatim) state.tag = tagName;
+		else if (_hasOwnProperty.call(state.tagMap, tagHandle)) state.tag = state.tagMap[tagHandle] + tagName;
+		else if (tagHandle === "!") state.tag = "!" + tagName;
+		else if (tagHandle === "!!") state.tag = "tag:yaml.org,2002:" + tagName;
+		else throwError(state, "undeclared tag handle \"" + tagHandle + "\"");
+		return true;
+	}
+	__name(readTagProperty, "readTagProperty");
+	function readAnchorProperty(state) {
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 38) return false;
+		if (state.anchor !== null) throwError(state, "duplication of an anchor property");
+		ch = state.input.charCodeAt(++state.position);
+		const _position = state.position;
+		while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
+		if (state.position === _position) throwError(state, "name of an anchor node must contain at least one character");
+		state.anchor = state.input.slice(_position, state.position);
+		return true;
+	}
+	__name(readAnchorProperty, "readAnchorProperty");
+	function readAlias(state) {
+		let ch = state.input.charCodeAt(state.position);
+		if (ch !== 42) return false;
+		ch = state.input.charCodeAt(++state.position);
+		const _position = state.position;
+		while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
+		if (state.position === _position) throwError(state, "name of an alias node must contain at least one character");
+		const alias = state.input.slice(_position, state.position);
+		if (!_hasOwnProperty.call(state.anchorMap, alias)) throwError(state, "unidentified alias \"" + alias + "\"");
+		state.result = state.anchorMap[alias];
+		skipSeparationSpace(state, true, -1);
+		return true;
+	}
+	__name(readAlias, "readAlias");
+	function tryReadBlockMappingFromProperty(state, propertyStart, nodeIndent, flowIndent) {
+		const fallbackState = snapshotState(state);
+		beginAnchorTransaction(state);
+		restoreState(state, propertyStart);
+		state.tag = null;
+		state.anchor = null;
+		state.kind = null;
+		state.result = null;
+		if (readBlockMapping(state, nodeIndent, flowIndent) && state.kind === "mapping") {
+			commitAnchorTransaction(state);
+			return true;
+		}
+		rollbackAnchorTransaction(state);
+		restoreState(state, fallbackState);
+		return false;
+	}
+	__name(tryReadBlockMappingFromProperty, "tryReadBlockMappingFromProperty");
+	function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+		let allowBlockScalars;
+		let allowBlockCollections;
+		let indentStatus = 1;
+		let atNewLine = false;
+		let hasContent = false;
+		let propertyStart = null;
+		let type2;
+		let flowIndent;
+		let blockIndent;
+		if (state.depth >= state.maxDepth) throwError(state, "nesting exceeded maxDepth (" + state.maxDepth + ")");
+		state.depth += 1;
+		if (state.listener !== null) state.listener("open", state);
+		state.tag = null;
+		state.anchor = null;
+		state.kind = null;
+		state.result = null;
+		const allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+		if (allowToSeek) {
+			if (skipSeparationSpace(state, true, -1)) {
+				atNewLine = true;
+				if (state.lineIndent > parentIndent) indentStatus = 1;
+				else if (state.lineIndent === parentIndent) indentStatus = 0;
+				else if (state.lineIndent < parentIndent) indentStatus = -1;
+			}
+		}
+		if (indentStatus === 1) while (true) {
+			const ch = state.input.charCodeAt(state.position);
+			const propertyState = snapshotState(state);
+			if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null)) break;
+			if (!readTagProperty(state) && !readAnchorProperty(state)) break;
+			if (propertyStart === null) propertyStart = propertyState;
+			if (skipSeparationSpace(state, true, -1)) {
+				atNewLine = true;
+				allowBlockCollections = allowBlockStyles;
+				if (state.lineIndent > parentIndent) indentStatus = 1;
+				else if (state.lineIndent === parentIndent) indentStatus = 0;
+				else if (state.lineIndent < parentIndent) indentStatus = -1;
+			} else allowBlockCollections = false;
+		}
+		if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact;
+		if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+			if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) flowIndent = parentIndent;
+			else flowIndent = parentIndent + 1;
+			blockIndent = state.position - state.lineStart;
+			if (indentStatus === 1) if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) hasContent = true;
+			else {
+				const ch = state.input.charCodeAt(state.position);
+				if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, flowIndent)) hasContent = true;
+				else if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) hasContent = true;
+				else if (readAlias(state)) {
+					hasContent = true;
+					if (state.tag !== null || state.anchor !== null) throwError(state, "alias node should not have any properties");
+				} else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+					hasContent = true;
+					if (state.tag === null) state.tag = "?";
+				}
+				if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+			}
+			else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+		}
+		if (state.tag === null) {
+			if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+		} else if (state.tag === "?") {
+			if (state.result !== null && state.kind !== "scalar") throwError(state, "unacceptable node kind for !<?> tag; it should be \"scalar\", not \"" + state.kind + "\"");
+			for (let typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+				type2 = state.implicitTypes[typeIndex];
+				if (type2.resolve(state.result)) {
+					state.result = type2.construct(state.result);
+					state.tag = type2.tag;
+					if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+					break;
+				}
+			}
+		} else if (state.tag !== "!") {
+			if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) type2 = state.typeMap[state.kind || "fallback"][state.tag];
+			else {
+				type2 = null;
+				const typeList = state.typeMap.multi[state.kind || "fallback"];
+				for (let typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+					type2 = typeList[typeIndex];
+					break;
+				}
+			}
+			if (!type2) throwError(state, "unknown tag !<" + state.tag + ">");
+			if (state.result !== null && type2.kind !== state.kind) throwError(state, "unacceptable node kind for !<" + state.tag + "> tag; it should be \"" + type2.kind + "\", not \"" + state.kind + "\"");
+			if (!type2.resolve(state.result, state.tag)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+			else {
+				state.result = type2.construct(state.result, state.tag);
+				if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+			}
+		}
+		if (state.listener !== null) state.listener("close", state);
+		state.depth -= 1;
+		return state.tag !== null || state.anchor !== null || hasContent;
+	}
+	__name(composeNode, "composeNode");
+	function readDocument(state) {
+		const documentStart = state.position;
+		let hasDirectives = false;
+		let ch;
+		state.version = null;
+		state.checkLineBreaks = state.legacy;
+		state.tagMap = /* @__PURE__ */ Object.create(null);
+		state.anchorMap = /* @__PURE__ */ Object.create(null);
+		while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+			skipSeparationSpace(state, true, -1);
+			ch = state.input.charCodeAt(state.position);
+			if (state.lineIndent > 0 || ch !== 37) break;
+			hasDirectives = true;
+			ch = state.input.charCodeAt(++state.position);
+			let _position = state.position;
+			while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
+			const directiveName = state.input.slice(_position, state.position);
+			const directiveArgs = [];
+			if (directiveName.length < 1) throwError(state, "directive name must not be less than one character in length");
+			while (ch !== 0) {
+				while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
+				if (ch === 35) {
+					do
+						ch = state.input.charCodeAt(++state.position);
+					while (ch !== 0 && !isEol(ch));
+					break;
+				}
+				if (isEol(ch)) break;
+				_position = state.position;
+				while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
+				directiveArgs.push(state.input.slice(_position, state.position));
+			}
+			if (ch !== 0) readLineBreak(state);
+			if (_hasOwnProperty.call(directiveHandlers, directiveName)) directiveHandlers[directiveName](state, directiveName, directiveArgs);
+			else throwWarning(state, "unknown document directive \"" + directiveName + "\"");
+		}
+		skipSeparationSpace(state, true, -1);
+		if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
+			state.position += 3;
+			skipSeparationSpace(state, true, -1);
+		} else if (hasDirectives) throwError(state, "directives end mark is expected");
+		composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+		skipSeparationSpace(state, true, -1);
+		if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) throwWarning(state, "non-ASCII line breaks are interpreted as content");
+		state.documents.push(state.result);
+		if (state.position === state.lineStart && testDocumentSeparator(state)) {
+			if (state.input.charCodeAt(state.position) === 46) {
+				state.position += 3;
+				skipSeparationSpace(state, true, -1);
+			}
+			return;
+		}
+		if (state.position < state.length - 1) throwError(state, "end of the stream or a document separator is expected");
+	}
+	__name(readDocument, "readDocument");
+	function loadDocuments(input, options) {
+		input = String(input);
+		options = options || {};
+		if (input.length !== 0) {
+			if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) input += "\n";
+			if (input.charCodeAt(0) === 65279) input = input.slice(1);
+		}
+		const state = new State(input, options);
+		const nullpos = input.indexOf("\0");
+		if (nullpos !== -1) {
+			state.position = nullpos;
+			throwError(state, "null byte is not allowed in input");
+		}
+		state.input += "\0";
+		while (state.input.charCodeAt(state.position) === 32) {
+			state.lineIndent += 1;
+			state.position += 1;
+		}
+		while (state.position < state.length - 1) readDocument(state);
+		return state.documents;
+	}
+	__name(loadDocuments, "loadDocuments");
+	function loadAll2(input, iterator, options) {
+		if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
+			options = iterator;
+			iterator = null;
+		}
+		const documents = loadDocuments(input, options);
+		if (typeof iterator !== "function") return documents;
+		for (let index = 0, length = documents.length; index < length; index += 1) iterator(documents[index]);
+	}
+	__name(loadAll2, "loadAll2");
+	function load2(input, options) {
+		const documents = loadDocuments(input, options);
+		if (documents.length === 0) return;
+		else if (documents.length === 1) return documents[0];
+		throw new YAMLException2("expected a single document in the stream, but found more");
+	}
+	__name(load2, "load2");
+	loader.loadAll = loadAll2;
+	loader.load = load2;
+	return loader;
+}
+__name(requireLoader, "requireLoader");
+var dumper = {};
+var hasRequiredDumper;
+function requireDumper() {
+	if (hasRequiredDumper) return dumper;
+	hasRequiredDumper = 1;
+	const common2 = requireCommon();
+	const YAMLException2 = requireException();
+	const DEFAULT_SCHEMA2 = require_default();
+	const _toString = Object.prototype.toString;
+	const _hasOwnProperty = Object.prototype.hasOwnProperty;
+	const CHAR_BOM = 65279;
+	const CHAR_TAB = 9;
+	const CHAR_LINE_FEED = 10;
+	const CHAR_CARRIAGE_RETURN = 13;
+	const CHAR_SPACE = 32;
+	const CHAR_EXCLAMATION = 33;
+	const CHAR_DOUBLE_QUOTE = 34;
+	const CHAR_SHARP = 35;
+	const CHAR_PERCENT = 37;
+	const CHAR_AMPERSAND = 38;
+	const CHAR_SINGLE_QUOTE = 39;
+	const CHAR_ASTERISK = 42;
+	const CHAR_COMMA = 44;
+	const CHAR_MINUS = 45;
+	const CHAR_COLON = 58;
+	const CHAR_EQUALS = 61;
+	const CHAR_GREATER_THAN = 62;
+	const CHAR_QUESTION = 63;
+	const CHAR_COMMERCIAL_AT = 64;
+	const CHAR_LEFT_SQUARE_BRACKET = 91;
+	const CHAR_RIGHT_SQUARE_BRACKET = 93;
+	const CHAR_GRAVE_ACCENT = 96;
+	const CHAR_LEFT_CURLY_BRACKET = 123;
+	const CHAR_VERTICAL_LINE = 124;
+	const CHAR_RIGHT_CURLY_BRACKET = 125;
+	const ESCAPE_SEQUENCES = {};
+	ESCAPE_SEQUENCES[0] = "\\0";
+	ESCAPE_SEQUENCES[7] = "\\a";
+	ESCAPE_SEQUENCES[8] = "\\b";
+	ESCAPE_SEQUENCES[9] = "\\t";
+	ESCAPE_SEQUENCES[10] = "\\n";
+	ESCAPE_SEQUENCES[11] = "\\v";
+	ESCAPE_SEQUENCES[12] = "\\f";
+	ESCAPE_SEQUENCES[13] = "\\r";
+	ESCAPE_SEQUENCES[27] = "\\e";
+	ESCAPE_SEQUENCES[34] = "\\\"";
+	ESCAPE_SEQUENCES[92] = "\\\\";
+	ESCAPE_SEQUENCES[133] = "\\N";
+	ESCAPE_SEQUENCES[160] = "\\_";
+	ESCAPE_SEQUENCES[8232] = "\\L";
+	ESCAPE_SEQUENCES[8233] = "\\P";
+	const DEPRECATED_BOOLEANS_SYNTAX = [
+		"y",
+		"Y",
+		"yes",
+		"Yes",
+		"YES",
+		"on",
+		"On",
+		"ON",
+		"n",
+		"N",
+		"no",
+		"No",
+		"NO",
+		"off",
+		"Off",
+		"OFF"
+	];
+	const DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+	function compileStyleMap(schema2, map2) {
+		if (map2 === null) return {};
+		const result = {};
+		const keys = Object.keys(map2);
+		for (let index = 0, length = keys.length; index < length; index += 1) {
+			let tag = keys[index];
+			let style = String(map2[tag]);
+			if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
+			const type2 = schema2.compiledTypeMap["fallback"][tag];
+			if (type2 && _hasOwnProperty.call(type2.styleAliases, style)) style = type2.styleAliases[style];
+			result[tag] = style;
+		}
+		return result;
+	}
+	__name(compileStyleMap, "compileStyleMap");
+	function encodeHex(character) {
+		let handle;
+		let length;
+		const string = character.toString(16).toUpperCase();
+		if (character <= 255) {
+			handle = "x";
+			length = 2;
+		} else if (character <= 65535) {
+			handle = "u";
+			length = 4;
+		} else if (character <= 4294967295) {
+			handle = "U";
+			length = 8;
+		} else throw new YAMLException2("code point within a string may not be greater than 0xFFFFFFFF");
+		return "\\" + handle + common2.repeat("0", length - string.length) + string;
+	}
+	__name(encodeHex, "encodeHex");
+	const QUOTING_TYPE_SINGLE = 1;
+	const QUOTING_TYPE_DOUBLE = 2;
+	function State(options) {
+		this.schema = options["schema"] || DEFAULT_SCHEMA2;
+		this.indent = Math.max(1, options["indent"] || 2);
+		this.noArrayIndent = options["noArrayIndent"] || false;
+		this.skipInvalid = options["skipInvalid"] || false;
+		this.flowLevel = common2.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
+		this.styleMap = compileStyleMap(this.schema, options["styles"] || null);
+		this.sortKeys = options["sortKeys"] || false;
+		this.lineWidth = options["lineWidth"] || 80;
+		this.noRefs = options["noRefs"] || false;
+		this.noCompatMode = options["noCompatMode"] || false;
+		this.condenseFlow = options["condenseFlow"] || false;
+		this.quotingType = options["quotingType"] === "\"" ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
+		this.forceQuotes = options["forceQuotes"] || false;
+		this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null;
+		this.implicitTypes = this.schema.compiledImplicit;
+		this.explicitTypes = this.schema.compiledExplicit;
+		this.tag = null;
+		this.result = "";
+		this.duplicates = [];
+		this.usedDuplicates = null;
+	}
+	__name(State, "State");
+	function indentString(string, spaces) {
+		const ind = common2.repeat(" ", spaces);
+		let position = 0;
+		let result = "";
+		const length = string.length;
+		while (position < length) {
+			let line;
+			const next = string.indexOf("\n", position);
+			if (next === -1) {
+				line = string.slice(position);
+				position = length;
+			} else {
+				line = string.slice(position, next + 1);
+				position = next + 1;
+			}
+			if (line.length && line !== "\n") result += ind;
+			result += line;
+		}
+		return result;
+	}
+	__name(indentString, "indentString");
+	function generateNextLine(state, level) {
+		return "\n" + common2.repeat(" ", state.indent * level);
+	}
+	__name(generateNextLine, "generateNextLine");
+	function testImplicitResolving(state, str2) {
+		for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) if (state.implicitTypes[index].resolve(str2)) return true;
+		return false;
+	}
+	__name(testImplicitResolving, "testImplicitResolving");
+	function isWhitespace(c) {
+		return c === CHAR_SPACE || c === CHAR_TAB;
+	}
+	__name(isWhitespace, "isWhitespace");
+	function isPrintable(c) {
+		return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111;
+	}
+	__name(isPrintable, "isPrintable");
+	function isNsCharOrWhitespace(c) {
+		return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+	}
+	__name(isNsCharOrWhitespace, "isNsCharOrWhitespace");
+	function isPlainSafe(c, prev, inblock) {
+		const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
+		const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
+		return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar;
+	}
+	__name(isPlainSafe, "isPlainSafe");
+	function isPlainSafeFirst(c) {
+		return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
+	}
+	__name(isPlainSafeFirst, "isPlainSafeFirst");
+	function isPlainSafeLast(c) {
+		return !isWhitespace(c) && c !== CHAR_COLON;
+	}
+	__name(isPlainSafeLast, "isPlainSafeLast");
+	function codePointAt(string, pos) {
+		const first = string.charCodeAt(pos);
+		let second;
+		if (first >= 55296 && first <= 56319 && pos + 1 < string.length) {
+			second = string.charCodeAt(pos + 1);
+			if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536;
+		}
+		return first;
+	}
+	__name(codePointAt, "codePointAt");
+	function needIndentIndicator(string) {
+		return /^\n* /.test(string);
+	}
+	__name(needIndentIndicator, "needIndentIndicator");
+	const STYLE_PLAIN = 1;
+	const STYLE_SINGLE = 2;
+	const STYLE_LITERAL = 3;
+	const STYLE_FOLDED = 4;
+	const STYLE_DOUBLE = 5;
+	function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
+		let i;
+		let char = 0;
+		let prevChar = null;
+		let hasLineBreak = false;
+		let hasFoldableLine = false;
+		const shouldTrackWidth = lineWidth !== -1;
+		let previousLineBreak = -1;
+		let plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
+		if (singleLineOnly || forceQuotes) for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+			char = codePointAt(string, i);
+			if (!isPrintable(char)) return STYLE_DOUBLE;
+			plain = plain && isPlainSafe(char, prevChar, inblock);
+			prevChar = char;
+		}
+		else {
+			for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+				char = codePointAt(string, i);
+				if (char === CHAR_LINE_FEED) {
+					hasLineBreak = true;
+					if (shouldTrackWidth) {
+						hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+						previousLineBreak = i;
+					}
+				} else if (!isPrintable(char)) return STYLE_DOUBLE;
+				plain = plain && isPlainSafe(char, prevChar, inblock);
+				prevChar = char;
+			}
+			hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+		}
+		if (!hasLineBreak && !hasFoldableLine) {
+			if (plain && !forceQuotes && !testAmbiguousType(string)) return STYLE_PLAIN;
+			return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+		}
+		if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE;
+		if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+		return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+	}
+	__name(chooseScalarStyle, "chooseScalarStyle");
+	function writeScalar(state, string, level, iskey, inblock) {
+		state.dump = (function() {
+			if (string.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"\"" : "''";
+			if (!state.noCompatMode) {
+				if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"" + string + "\"" : "'" + string + "'";
+			}
+			const indent = state.indent * Math.max(1, level);
+			const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+			const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
+			function testAmbiguity(string2) {
+				return testImplicitResolving(state, string2);
+			}
+			__name(testAmbiguity, "testAmbiguity");
+			switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
+				case STYLE_PLAIN: return string;
+				case STYLE_SINGLE: return "'" + string.replace(/'/g, "''") + "'";
+				case STYLE_LITERAL: return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
+				case STYLE_FOLDED: return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
+				case STYLE_DOUBLE: return "\"" + escapeString(string) + "\"";
+				default: throw new YAMLException2("impossible error: invalid scalar style");
+			}
+		})();
+	}
+	__name(writeScalar, "writeScalar");
+	function blockHeader(string, indentPerLevel) {
+		const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
+		const clip = string[string.length - 1] === "\n";
+		return indentIndicator + (clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-") + "\n";
+	}
+	__name(blockHeader, "blockHeader");
+	function dropEndingNewline(string) {
+		return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
+	}
+	__name(dropEndingNewline, "dropEndingNewline");
+	function foldString(string, width) {
+		const lineRe = /(\n+)([^\n]*)/g;
+		let result = (function() {
+			let nextLF = string.indexOf("\n");
+			nextLF = nextLF !== -1 ? nextLF : string.length;
+			lineRe.lastIndex = nextLF;
+			return foldLine(string.slice(0, nextLF), width);
+		})();
+		let prevMoreIndented = string[0] === "\n" || string[0] === " ";
+		let moreIndented;
+		let match;
+		while (match = lineRe.exec(string)) {
+			const prefix = match[1];
+			const line = match[2];
+			moreIndented = line[0] === " ";
+			result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
+			prevMoreIndented = moreIndented;
+		}
+		return result;
+	}
+	__name(foldString, "foldString");
+	function foldLine(line, width) {
+		if (line === "" || line[0] === " ") return line;
+		const breakRe = / [^ ]/g;
+		let match;
+		let start = 0;
+		let end;
+		let curr = 0;
+		let next = 0;
+		let result = "";
+		while (match = breakRe.exec(line)) {
+			next = match.index;
+			if (next - start > width) {
+				end = curr > start ? curr : next;
+				result += "\n" + line.slice(start, end);
+				start = end + 1;
+			}
+			curr = next;
+		}
+		result += "\n";
+		if (line.length - start > width && curr > start) result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
+		else result += line.slice(start);
+		return result.slice(1);
+	}
+	__name(foldLine, "foldLine");
+	function escapeString(string) {
+		let result = "";
+		let char = 0;
+		for (let i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
+			char = codePointAt(string, i);
+			const escapeSeq = ESCAPE_SEQUENCES[char];
+			if (!escapeSeq && isPrintable(char)) {
+				result += string[i];
+				if (char >= 65536) result += string[i + 1];
+			} else result += escapeSeq || encodeHex(char);
+		}
+		return result;
+	}
+	__name(escapeString, "escapeString");
+	function writeFlowSequence(state, level, object) {
+		let _result = "";
+		const _tag = state.tag;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			let value = object[index];
+			if (state.replacer) value = state.replacer.call(object, String(index), value);
+			if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
+				if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
+				_result += state.dump;
+			}
+		}
+		state.tag = _tag;
+		state.dump = "[" + _result + "]";
+	}
+	__name(writeFlowSequence, "writeFlowSequence");
+	function writeBlockSequence(state, level, object, compact) {
+		let _result = "";
+		const _tag = state.tag;
+		for (let index = 0, length = object.length; index < length; index += 1) {
+			let value = object[index];
+			if (state.replacer) value = state.replacer.call(object, String(index), value);
+			if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
+				if (!compact || _result !== "") _result += generateNextLine(state, level);
+				if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) _result += "-";
+				else _result += "- ";
+				_result += state.dump;
+			}
+		}
+		state.tag = _tag;
+		state.dump = _result || "[]";
+	}
+	__name(writeBlockSequence, "writeBlockSequence");
+	function writeFlowMapping(state, level, object) {
+		let _result = "";
+		const _tag = state.tag;
+		const objectKeyList = Object.keys(object);
+		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+			let pairBuffer = "";
+			if (_result !== "") pairBuffer += ", ";
+			if (state.condenseFlow) pairBuffer += "\"";
+			const objectKey = objectKeyList[index];
+			let objectValue = object[objectKey];
+			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+			if (!writeNode(state, level, objectKey, false, false)) continue;
+			if (state.dump.length > 1024) pairBuffer += "? ";
+			pairBuffer += state.dump + (state.condenseFlow ? "\"" : "") + ":" + (state.condenseFlow ? "" : " ");
+			if (!writeNode(state, level, objectValue, false, false)) continue;
+			pairBuffer += state.dump;
+			_result += pairBuffer;
+		}
+		state.tag = _tag;
+		state.dump = "{" + _result + "}";
+	}
+	__name(writeFlowMapping, "writeFlowMapping");
+	function writeBlockMapping(state, level, object, compact) {
+		let _result = "";
+		const _tag = state.tag;
+		const objectKeyList = Object.keys(object);
+		if (state.sortKeys === true) objectKeyList.sort();
+		else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
+		else if (state.sortKeys) throw new YAMLException2("sortKeys must be a boolean or a function");
+		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+			let pairBuffer = "";
+			if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
+			const objectKey = objectKeyList[index];
+			let objectValue = object[objectKey];
+			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+			if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
+			const explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+			if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
+			else pairBuffer += "? ";
+			pairBuffer += state.dump;
+			if (explicitPair) pairBuffer += generateNextLine(state, level);
+			if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
+			if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
+			else pairBuffer += ": ";
+			pairBuffer += state.dump;
+			_result += pairBuffer;
+		}
+		state.tag = _tag;
+		state.dump = _result || "{}";
+	}
+	__name(writeBlockMapping, "writeBlockMapping");
+	function detectType(state, object, explicit) {
+		const typeList = explicit ? state.explicitTypes : state.implicitTypes;
+		for (let index = 0, length = typeList.length; index < length; index += 1) {
+			const type2 = typeList[index];
+			if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) {
+				if (explicit) if (type2.multi && type2.representName) state.tag = type2.representName(object);
+				else state.tag = type2.tag;
+				else state.tag = "?";
+				if (type2.represent) {
+					const style = state.styleMap[type2.tag] || type2.defaultStyle;
+					let _result;
+					if (_toString.call(type2.represent) === "[object Function]") _result = type2.represent(object, style);
+					else if (_hasOwnProperty.call(type2.represent, style)) _result = type2.represent[style](object, style);
+					else throw new YAMLException2("!<" + type2.tag + "> tag resolver accepts not \"" + style + "\" style");
+					state.dump = _result;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+	__name(detectType, "detectType");
+	function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+		state.tag = null;
+		state.dump = object;
+		if (!detectType(state, object, false)) detectType(state, object, true);
+		const type2 = _toString.call(state.dump);
+		const inblock = block;
+		if (block) block = state.flowLevel < 0 || state.flowLevel > level;
+		const objectOrArray = type2 === "[object Object]" || type2 === "[object Array]";
+		let duplicateIndex;
+		let duplicate;
+		if (objectOrArray) {
+			duplicateIndex = state.duplicates.indexOf(object);
+			duplicate = duplicateIndex !== -1;
+		}
+		if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
+		if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
+		else {
+			if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
+			if (type2 === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
+				writeBlockMapping(state, level, state.dump, compact);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+			} else {
+				writeFlowMapping(state, level, state.dump);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+			}
+			else if (type2 === "[object Array]") if (block && state.dump.length !== 0) {
+				if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
+				else writeBlockSequence(state, level, state.dump, compact);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+			} else {
+				writeFlowSequence(state, level, state.dump);
+				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+			}
+			else if (type2 === "[object String]") {
+				if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
+			} else if (type2 === "[object Undefined]") return false;
+			else {
+				if (state.skipInvalid) return false;
+				throw new YAMLException2("unacceptable kind of an object to dump " + type2);
+			}
+			if (state.tag !== null && state.tag !== "?") {
+				let tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
+				if (state.tag[0] === "!") tagStr = "!" + tagStr;
+				else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
+				else tagStr = "!<" + tagStr + ">";
+				state.dump = tagStr + " " + state.dump;
+			}
+		}
+		return true;
+	}
+	__name(writeNode, "writeNode");
+	function getDuplicateReferences(object, state) {
+		const objects = [];
+		const duplicatesIndexes = [];
+		inspectNode(object, objects, duplicatesIndexes);
+		const length = duplicatesIndexes.length;
+		for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
+		state.usedDuplicates = new Array(length);
+	}
+	__name(getDuplicateReferences, "getDuplicateReferences");
+	function inspectNode(object, objects, duplicatesIndexes) {
+		if (object !== null && typeof object === "object") {
+			const index = objects.indexOf(object);
+			if (index !== -1) {
+				if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
+			} else {
+				objects.push(object);
+				if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
+				else {
+					const objectKeyList = Object.keys(object);
+					for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
+				}
+			}
+		}
+	}
+	__name(inspectNode, "inspectNode");
+	function dump2(input, options) {
+		options = options || {};
+		const state = new State(options);
+		if (!state.noRefs) getDuplicateReferences(input, state);
+		let value = input;
+		if (state.replacer) value = state.replacer.call({ "": value }, "", value);
+		if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+		return "";
+	}
+	__name(dump2, "dump2");
+	dumper.dump = dump2;
+	return dumper;
+}
+__name(requireDumper, "requireDumper");
+var hasRequiredJsYaml;
+function requireJsYaml() {
+	if (hasRequiredJsYaml) return jsYaml;
+	hasRequiredJsYaml = 1;
+	const loader2 = requireLoader();
+	const dumper2 = requireDumper();
+	function renamed(from, to) {
+		return function() {
+			throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
+		};
+	}
+	__name(renamed, "renamed");
+	jsYaml.Type = requireType();
+	jsYaml.Schema = requireSchema();
+	jsYaml.FAILSAFE_SCHEMA = requireFailsafe();
+	jsYaml.JSON_SCHEMA = requireJson();
+	jsYaml.CORE_SCHEMA = requireCore();
+	jsYaml.DEFAULT_SCHEMA = require_default();
+	jsYaml.load = loader2.load;
+	jsYaml.loadAll = loader2.loadAll;
+	jsYaml.dump = dumper2.dump;
+	jsYaml.YAMLException = requireException();
+	jsYaml.types = {
+		binary: requireBinary(),
+		float: requireFloat(),
+		map: requireMap(),
+		null: require_null(),
+		pairs: requirePairs(),
+		set: requireSet(),
+		timestamp: requireTimestamp(),
+		bool: requireBool(),
+		int: requireInt(),
+		merge: requireMerge(),
+		omap: requireOmap(),
+		seq: requireSeq(),
+		str: requireStr()
+	};
+	jsYaml.safeLoad = renamed("safeLoad", "load");
+	jsYaml.safeLoadAll = renamed("safeLoadAll", "loadAll");
+	jsYaml.safeDump = renamed("safeDump", "dump");
+	return jsYaml;
+}
+__name(requireJsYaml, "requireJsYaml");
+var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = /* @__PURE__ */ getDefaultExportFromCjs(requireJsYaml());
+
+//#endregion
+//#region ../../node_modules/.pnpm/stylis@4.4.0/node_modules/stylis/src/Enum.js
+var COMMENT = "comm";
+var RULESET = "rule";
+var DECLARATION = "decl";
+var MEDIA = "@media";
+var IMPORT = "@import";
+var SUPPORTS = "@supports";
+var NAMESPACE = "@namespace";
+var KEYFRAMES = "@keyframes";
+var LAYER = "@layer";
+var SCOPE = "@scope";
+
+//#endregion
+//#region ../../node_modules/.pnpm/stylis@4.4.0/node_modules/stylis/src/Utility.js
+/**
+* @param {number}
+* @return {number}
+*/
+var abs = Math.abs;
+/**
+* @param {number}
+* @return {string}
+*/
+var from = String.fromCharCode;
+/**
+* @param {string} value
+* @return {string}
+*/
+function trim(value) {
+	return value.trim();
+}
+/**
+* @param {string} value
+* @param {(string|RegExp)} pattern
+* @param {string} replacement
+* @return {string}
+*/
+function replace(value, pattern, replacement) {
+	return value.replace(pattern, replacement);
+}
+/**
+* @param {string} value
+* @param {number} index
+* @return {number}
+*/
+function charat(value, index) {
+	return value.charCodeAt(index) | 0;
+}
+/**
+* @param {string} value
+* @param {number} begin
+* @param {number} end
+* @return {string}
+*/
+function substr(value, begin, end) {
+	return value.slice(begin, end);
+}
+/**
+* @param {string} value
+* @return {number}
+*/
+function strlen(value) {
+	return value.length;
+}
+/**
+* @param {any[]} value
+* @return {number}
+*/
+function sizeof(value) {
+	return value.length;
+}
+/**
+* @param {any} value
+* @param {any[]} array
+* @return {any}
+*/
+function append(value, array) {
+	return array.push(value), value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/stylis@4.4.0/node_modules/stylis/src/Tokenizer.js
+var line = 1;
+var column = 1;
+var length = 0;
+var position = 0;
+var character = 0;
+var characters = "";
+/**
+* @param {string} value
+* @param {object | null} root
+* @param {object | null} parent
+* @param {string} type
+* @param {string[] | string} props
+* @param {object[] | string} children
+* @param {object[]} siblings
+* @param {number} length
+*/
+function node(value, root, parent, type, props, children, length, siblings) {
+	return {
+		value,
+		root,
+		parent,
+		type,
+		props,
+		children,
+		line,
+		column,
+		length,
+		return: "",
+		siblings
+	};
+}
+/**
+* @return {number}
+*/
+function char() {
+	return character;
+}
+/**
+* @return {number}
+*/
+function prev() {
+	character = position > 0 ? charat(characters, --position) : 0;
+	if (column--, character === 10) column = 1, line--;
+	return character;
+}
+/**
+* @return {number}
+*/
+function next() {
+	character = position < length ? charat(characters, position++) : 0;
+	if (column++, character === 10) column = 1, line++;
+	return character;
+}
+/**
+* @return {number}
+*/
+function peek() {
+	return charat(characters, position);
+}
+/**
+* @return {number}
+*/
+function caret() {
+	return position;
+}
+/**
+* @param {number} begin
+* @param {number} end
+* @return {string}
+*/
+function slice(begin, end) {
+	return substr(characters, begin, end);
+}
+/**
+* @param {number} type
+* @return {number}
+*/
+function token(type) {
+	switch (type) {
+		case 0:
+		case 9:
+		case 10:
+		case 13:
+		case 32: return 5;
+		case 33:
+		case 43:
+		case 44:
+		case 47:
+		case 62:
+		case 64:
+		case 126:
+		case 59:
+		case 123:
+		case 125: return 4;
+		case 58: return 3;
+		case 34:
+		case 39:
+		case 40:
+		case 91: return 2;
+		case 41:
+		case 93: return 1;
+	}
+	return 0;
+}
+/**
+* @param {string} value
+* @return {any[]}
+*/
+function alloc(value) {
+	return line = column = 1, length = strlen(characters = value), position = 0, [];
+}
+/**
+* @param {any} value
+* @return {any}
+*/
+function dealloc(value) {
+	return characters = "", value;
+}
+/**
+* @param {number} type
+* @return {string}
+*/
+function delimit(type) {
+	return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)));
+}
+/**
+* @param {number} type
+* @return {string}
+*/
+function whitespace(type) {
+	while (character = peek()) if (character < 33) next();
+	else break;
+	return token(type) > 2 || token(character) > 3 ? "" : " ";
+}
+/**
+* @param {number} index
+* @param {number} count
+* @return {string}
+*/
+function escaping(index, count) {
+	while (--count && next()) if (character < 48 || character > 102 || character > 57 && character < 65 || character > 70 && character < 97) break;
+	return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32));
+}
+/**
+* @param {number} type
+* @return {number}
+*/
+function delimiter(type) {
+	while (next()) switch (character) {
+		case type: return position;
+		case 34:
+		case 39:
+			if (type !== 34 && type !== 39) delimiter(character);
+			break;
+		case 40:
+			if (type === 41) delimiter(type);
+			break;
+		case 92:
+			next();
+			break;
+	}
+	return position;
+}
+/**
+* @param {number} type
+* @param {number} index
+* @return {number}
+*/
+function commenter(type, index) {
+	while (next()) if (type + character === 57) break;
+	else if (type + character === 84 && peek() === 47) break;
+	return "/*" + slice(index, position - 1) + "*" + from(type === 47 ? type : next());
+}
+/**
+* @param {number} index
+* @return {string}
+*/
+function identifier(index) {
+	while (!token(peek())) next();
+	return slice(index, position);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/stylis@4.4.0/node_modules/stylis/src/Parser.js
+/**
+* @param {string} value
+* @return {object[]}
+*/
+function compile(value) {
+	return dealloc(parse$1("", null, null, null, [""], value = alloc(value), 0, [0], value));
+}
+/**
+* @param {string} value
+* @param {object} root
+* @param {object?} parent
+* @param {string[]} rule
+* @param {string[]} rules
+* @param {string[]} rulesets
+* @param {number[]} pseudo
+* @param {number[]} points
+* @param {string[]} declarations
+* @return {object}
+*/
+function parse$1(value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
+	var index = 0;
+	var offset = 0;
+	var length = pseudo;
+	var atrule = 0;
+	var property = 0;
+	var previous = 0;
+	var variable = 1;
+	var scanning = 1;
+	var ampersand = 1;
+	var parens = 0;
+	var character = 0;
+	var type = "";
+	var props = rules;
+	var children = rulesets;
+	var reference = rule;
+	var characters = type;
+	while (scanning) switch (previous = character, character = next()) {
+		case 40:
+			if (previous != 108 && charat(characters, length - 1) == 58) parens++, characters += "(";
+			else characters += delimit(character);
+			break;
+		case 41:
+			parens--, characters += ")";
+			break;
+		case 34:
+		case 39:
+		case 91:
+			characters += delimit(character);
+			break;
+		case 9:
+		case 10:
+		case 13:
+		case 32:
+			if (parens > 0) {
+				characters += from(character);
+				break;
+			}
+			characters += whitespace(previous);
+			break;
+		case 92:
+			characters += escaping(caret() - 1, 7);
+			continue;
+		case 47:
+			switch (peek()) {
+				case 42:
+				case 47:
+					append(comment(commenter(next(), caret()), root, parent, declarations), declarations);
+					if ((token(previous || 1) == 5 || token(peek() || 1) == 5) && strlen(characters) && substr(characters, -1, void 0) !== " ") characters += " ";
+					break;
+				default: characters += "/";
+			}
+			break;
+		case 123 * variable: points[index++] = strlen(characters) * ampersand;
+		case 125 * variable:
+		case 59:
+		case 0:
+			if (parens > 0 && character) {
+				characters += from(character);
+				break;
+			}
+			switch (character) {
+				case 0:
+				case 125: scanning = 0;
+				case 59 + offset:
+					if (ampersand == -1) characters = replace(characters, /\f/g, "");
+					if (property > 0 && (strlen(characters) - length || variable === 0)) append(property > 32 ? declaration(characters + ";", rule, parent, length - 1, declarations) : declaration(replace(characters, " ", "") + ";", rule, parent, length - 2, declarations), declarations);
+					break;
+				case 59: characters += ";";
+				default:
+					append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length, rulesets), rulesets);
+					if (character === 123) if (offset === 0) parse$1(characters, root, reference, reference, props, rulesets, length, points, children);
+					else {
+						switch (atrule) {
+							case 99: if (charat(characters, 3) === 110) break;
+							case 108: if (charat(characters, 2) === 97) break;
+							default: offset = 0;
+							case 100:
+							case 109:
+							case 115:
+						}
+						if (offset) parse$1(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length, children), children), rules, children, length, points, rule ? props : children);
+						else parse$1(characters, reference, reference, reference, [""], children, 0, points, children);
+					}
+			}
+			index = offset = property = 0, variable = ampersand = 1, type = characters = "", length = pseudo;
+			break;
+		case 58: length = 1 + strlen(characters), property = previous;
+		default:
+			if (variable < 1) {
+				if (character == 123) --variable;
+				else if (character == 125 && variable++ == 0 && prev() == 125) continue;
+			}
+			switch (characters += from(character), character * variable) {
+				case 38:
+					ampersand = offset > 0 ? 1 : (characters += "\f", -1);
+					break;
+				case 44:
+					if (parens > 0) break;
+					points[index++] = (strlen(characters) - 1) * ampersand, ampersand = 1;
+					break;
+				case 64:
+					if (peek() === 45) characters += delimit(next());
+					atrule = peek(), offset = length = strlen(type = characters += identifier(caret())), character++;
+					break;
+				case 45: if (previous === 45 && strlen(characters) == 2) variable = 0;
+			}
+	}
+	return rulesets;
+}
+/**
+* @param {string} value
+* @param {object} root
+* @param {object?} parent
+* @param {number} index
+* @param {number} offset
+* @param {string[]} rules
+* @param {number[]} points
+* @param {string} type
+* @param {string[]} props
+* @param {string[]} children
+* @param {number} length
+* @param {object[]} siblings
+* @return {object}
+*/
+function ruleset(value, root, parent, index, offset, rules, points, type, props, children, length, siblings) {
+	var post = offset - 1;
+	var rule = offset === 0 ? rules : [""];
+	var size = sizeof(rule);
+	for (var i = 0, j = 0, k = 0; i < index; ++i) for (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x) if (z = trim(j > 0 ? rule[x] + " " + y : replace(y, /&\f/g, rule[x]))) props[k++] = z;
+	return node(value, root, parent, offset === 0 ? RULESET : type, props, children, length, siblings);
+}
+/**
+* @param {number} value
+* @param {object} root
+* @param {object?} parent
+* @param {object[]} siblings
+* @return {object}
+*/
+function comment(value, root, parent, siblings) {
+	return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0, siblings);
+}
+/**
+* @param {string} value
+* @param {object} root
+* @param {object?} parent
+* @param {number} length
+* @param {object[]} siblings
+* @return {object}
+*/
+function declaration(value, root, parent, length, siblings) {
+	return node(value, root, parent, DECLARATION, substr(value, 0, length), substr(value, length + 1, -1), length, siblings);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/stylis@4.4.0/node_modules/stylis/src/Serializer.js
+/**
+* @param {object[]} children
+* @param {function} callback
+* @return {string}
+*/
+function serialize(children, callback) {
+	var output = "";
+	for (var i = 0; i < children.length; i++) output += callback(children[i], i, children, callback) || "";
+	return output;
+}
+/**
+* @param {object} element
+* @param {number} index
+* @param {object[]} children
+* @param {function} callback
+* @return {string}
+*/
+function stringify(element, index, children, callback) {
+	switch (element.type) {
+		case LAYER: if (element.children.length) break;
+		case IMPORT:
+		case NAMESPACE:
+		case DECLARATION: return element.return = element.return || element.value;
+		case COMMENT: return "";
+		case KEYFRAMES: return element.return = element.value + "{" + serialize(element.children, callback) + "}";
+		case RULESET: if (!strlen(element.value = element.props.join(","))) return "";
+	}
+	return strlen(children = serialize(element.children, callback)) ? element.return = element.value + "{" + children + "}" : "";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/stylis@4.4.0/node_modules/stylis/src/Middleware.js
+/**
+* @param {function[]} collection
+* @return {function}
+*/
+function middleware(collection) {
+	var length = sizeof(collection);
+	return function(element, index, children, callback) {
+		var output = "";
+		for (var i = 0; i < length; i++) output += collection[i](element, index, children, callback) || "";
+		return output;
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@11.17.2/node_modules/mermaid/dist/mermaid.core.mjs
+var id = "c4";
+var c4Detector_default = {
+	id,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*C4Context|C4Container|C4Component|C4Dynamic|C4Deployment/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./c4Diagram-7LVT6UL2.js");
+		return {
+			id,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id2 = "flowchart";
+var flowDetector_default = {
+	id: id2,
+	detector: /* @__PURE__ */ __name((txt, config) => {
+		if (config?.flowchart?.defaultRenderer === "dagre-wrapper" || config?.flowchart?.defaultRenderer === "elk") return false;
+		return /^\s*graph/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./flowDiagram-HODETNUW.js");
+		return {
+			id: id2,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id3 = "flowchart-v2";
+var flowDetector_v2_default = {
+	id: id3,
+	detector: /* @__PURE__ */ __name((txt, config) => {
+		if (config?.flowchart?.defaultRenderer === "dagre-d3") return false;
+		if (config?.flowchart?.defaultRenderer === "elk") config.layout = "elk";
+		if (/^\s*graph/.test(txt) && config?.flowchart?.defaultRenderer === "dagre-wrapper") return true;
+		return /^\s*flowchart/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./flowDiagram-HODETNUW.js");
+		return {
+			id: id3,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id4 = "swimlane";
+var detector_default = {
+	id: id4,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*swimlane-beta\b/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./swimlanesDiagram-VR7AAH4N.js");
+		return {
+			id: id4,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id5 = "er";
+var erDetector_default = {
+	id: id5,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*erDiagram/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./erDiagram-RLTQ6QDP.js");
+		return {
+			id: id5,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id6 = "gitGraph";
+var gitGraphDetector_default = {
+	id: id6,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*gitGraph/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./gitGraphDiagram-WWUBYQGX.js");
+		return {
+			id: id6,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id7 = "gantt";
+var ganttDetector_default = {
+	id: id7,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*gantt/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./ganttDiagram-EL5Y4UJY.js");
+		return {
+			id: id7,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id8 = "info";
+var info = {
+	id: id8,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*info/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./infoDiagram-27XIBGKW.js");
+		return {
+			id: id8,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id9 = "pie";
+var pie = {
+	id: id9,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*pie/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./pieDiagram-E7YTZNPT.js");
+		return {
+			id: id9,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id10 = "quadrantChart";
+var quadrantDetector_default = {
+	id: id10,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*quadrantChart/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./quadrantDiagram-AXDQQJYC.js");
+		return {
+			id: id10,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id11 = "xychart";
+var xychartDetector_default = {
+	id: id11,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*xychart(-beta)?/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./xychartDiagram-S5SC5T6Z.js");
+		return {
+			id: id11,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id12 = "requirement";
+var requirementDetector_default = {
+	id: id12,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*requirement(Diagram)?/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./requirementDiagram-BXWQKSXE.js");
+		return {
+			id: id12,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id13 = "sequence";
+var sequenceDetector_default = {
+	id: id13,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*sequenceDiagram/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./sequenceDiagram-WJ2MYXX4.js");
+		return {
+			id: id13,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id14 = "class";
+var classDetector_default = {
+	id: id14,
+	detector: /* @__PURE__ */ __name((txt, config) => {
+		if (config?.class?.defaultRenderer === "dagre-wrapper") return false;
+		return /^\s*classDiagram/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./classDiagram-ZZMXUADV.js");
+		return {
+			id: id14,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id15 = "classDiagram";
+var classDetector_V2_default = {
+	id: id15,
+	detector: /* @__PURE__ */ __name((txt, config) => {
+		if (/^\s*classDiagram/.test(txt) && config?.class?.defaultRenderer === "dagre-wrapper") return true;
+		return /^\s*classDiagram-v2/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./classDiagram-v2-VYDZK3BY.js");
+		return {
+			id: id15,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id16 = "state";
+var stateDetector_default = {
+	id: id16,
+	detector: /* @__PURE__ */ __name((txt, config) => {
+		if (config?.state?.defaultRenderer === "dagre-wrapper") return false;
+		return /^\s*stateDiagram/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./stateDiagram-D77RDMKH.js");
+		return {
+			id: id16,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id17 = "stateDiagram";
+var stateDetector_V2_default = {
+	id: id17,
+	detector: /* @__PURE__ */ __name((txt, config) => {
+		if (/^\s*stateDiagram-v2/.test(txt)) return true;
+		if (/^\s*stateDiagram/.test(txt) && config?.state?.defaultRenderer === "dagre-wrapper") return true;
+		return false;
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./stateDiagram-v2-MP3YSRHH.js");
+		return {
+			id: id17,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id18 = "journey";
+var journeyDetector_default = {
+	id: id18,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*journey/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./journeyDiagram-3NMN7TZE.js");
+		return {
+			id: id18,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var renderer = { draw: /* @__PURE__ */ __name((_text, id39, version) => {
+	log.debug("rendering svg for syntax error\n");
+	const svg = selectSvgElement(id39);
+	const g = svg.append("g");
+	svg.attr("viewBox", "0 0 2412 512");
+	configureSvgSize(svg, 100, 512, true);
+	g.append("path").attr("class", "error-icon").attr("d", "m411.313,123.313c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32-9.375,9.375-20.688-20.688c-12.484-12.5-32.766-12.5-45.25,0l-16,16c-1.261,1.261-2.304,2.648-3.31,4.051-21.739-8.561-45.324-13.426-70.065-13.426-105.867,0-192,86.133-192,192s86.133,192 192,192 192-86.133 192-192c0-24.741-4.864-48.327-13.426-70.065 1.402-1.007 2.79-2.049 4.051-3.31l16-16c12.5-12.492 12.5-32.758 0-45.25l-20.688-20.688 9.375-9.375 32.001-31.999zm-219.313,100.687c-52.938,0-96,43.063-96,96 0,8.836-7.164,16-16,16s-16-7.164-16-16c0-70.578 57.422-128 128-128 8.836,0 16,7.164 16,16s-7.164,16-16,16z");
+	g.append("path").attr("class", "error-icon").attr("d", "m459.02,148.98c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l16,16c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16.001-16z");
+	g.append("path").attr("class", "error-icon").attr("d", "m340.395,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16-16c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l15.999,16z");
+	g.append("path").attr("class", "error-icon").attr("d", "m400,64c8.844,0 16-7.164 16-16v-32c0-8.836-7.156-16-16-16-8.844,0-16,7.164-16,16v32c0,8.836 7.156,16 16,16z");
+	g.append("path").attr("class", "error-icon").attr("d", "m496,96.586h-32c-8.844,0-16,7.164-16,16 0,8.836 7.156,16 16,16h32c8.844,0 16-7.164 16-16 0-8.836-7.156-16-16-16z");
+	g.append("path").attr("class", "error-icon").attr("d", "m436.98,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688l32-32c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32c-6.251,6.25-6.251,16.375-0.001,22.625z");
+	g.append("text").attr("class", "error-text").attr("x", 1440).attr("y", 250).attr("font-size", "150px").style("text-anchor", "middle").text("Syntax error in text");
+	g.append("text").attr("class", "error-text").attr("x", 1250).attr("y", 400).attr("font-size", "100px").style("text-anchor", "middle").text(`mermaid version ${version}`);
+}, "draw") };
+var errorRenderer_default = renderer;
+var errorDiagram_default = {
+	db: {},
+	renderer,
+	parser: { parse: /* @__PURE__ */ __name(() => {}, "parse") }
+};
+var id19 = "flowchart-elk";
+var detector_default2 = {
+	id: id19,
+	detector: /* @__PURE__ */ __name((txt, config = {}) => {
+		if (/^\s*flowchart-elk/.test(txt) || /^\s*(flowchart|graph)/.test(txt) && config?.flowchart?.defaultRenderer === "elk") {
+			config.layout = "elk";
+			return true;
+		}
+		return false;
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./flowDiagram-HODETNUW.js");
+		return {
+			id: id19,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id20 = "timeline";
+var detector_default3 = {
+	id: id20,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*timeline/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./timeline-definition-24CTP7MA.js");
+		return {
+			id: id20,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id21 = "mindmap";
+var detector_default4 = {
+	id: id21,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*mindmap/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./mindmap-definition-YA3MSWOX.js");
+		return {
+			id: id21,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id22 = "kanban";
+var detector_default5 = {
+	id: id22,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*kanban/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./kanban-definition-UXKFOSKX.js");
+		return {
+			id: id22,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id23 = "sankey";
+var sankeyDetector_default = {
+	id: id23,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*sankey(-beta)?/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./sankeyDiagram-P5KCCOFB.js");
+		return {
+			id: id23,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id24 = "packet";
+var packet = {
+	id: id24,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*packet(-beta)?/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./diagram-Z3DM3KII.js");
+		return {
+			id: id24,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id25 = "radar";
+var radar = {
+	id: id25,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*radar-beta/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./diagram-UQ7AKVKN.js");
+		return {
+			id: id25,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id26 = "block";
+var blockDetector_default = {
+	id: id26,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*block(-beta)?/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./blockDiagram-I7D4REHJ.js");
+		return {
+			id: id26,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id27 = "treeView";
+var detector_default6 = {
+	id: id27,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*treeView-beta/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./diagram-S7CK7UJ4.js");
+		return {
+			id: id27,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id28 = "architecture";
+var architectureDetector_default = {
+	id: id28,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*architecture/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./architectureDiagram-5GKGNRK7.js");
+		return {
+			id: id28,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id29 = "eventmodeling";
+var detector_default7 = {
+	id: id29,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*eventmodeling/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./diagram-VSXAHHWV.js");
+		return {
+			id: id29,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id30 = "ishikawa";
+var ishikawa = {
+	id: id30,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*ishikawa(-beta)?\b/i.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./ishikawaDiagram-5VMMS53U.js");
+		return {
+			id: id30,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id31 = "venn";
+var vennDetector_default = {
+	id: id31,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*venn-beta/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./vennDiagram-4TSXK5OY.js");
+		return {
+			id: id31,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id32 = "treemap";
+var treemap = {
+	id: id32,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*treemap/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./diagram-VX7I27RA.js");
+		return {
+			id: id32,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id33 = "wardley";
+var wardleyDetector_default = {
+	id: id33,
+	detector: /* @__PURE__ */ __name((text) => {
+		return /^\s*wardley-beta/i.test(text);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./wardleyDiagram-VM6X3IG4.js");
+		return {
+			id: id33,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id34 = "cynefin";
+var cynefin = {
+	id: id34,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*cynefin-beta(?:[\s:]|$)/.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./cynefinDiagram-5FMLGOSQ.js");
+		return {
+			id: id34,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id35 = "railroad";
+var railroad = {
+	id: id35,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*railroad-beta/i.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./railroadDiagram-O6MQD6OU.js");
+		return {
+			id: id35,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id36 = "railroadEbnf";
+var railroadEbnf = {
+	id: id36,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*railroad-ebnf-beta/i.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./ebnfDiagram-PWID7BFC.js");
+		return {
+			id: id36,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id37 = "railroadAbnf";
+var railroadAbnf = {
+	id: id37,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*railroad-abnf-beta/i.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./abnfDiagram-VCTEODGH.js");
+		return {
+			id: id37,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var id38 = "railroadPeg";
+var railroadPeg = {
+	id: id38,
+	detector: /* @__PURE__ */ __name((txt) => {
+		return /^\s*railroad-peg-beta/i.test(txt);
+	}, "detector"),
+	loader: /* @__PURE__ */ __name(async () => {
+		const { diagram: diagram2 } = await import("./pegDiagram-XKGWAZYB.js");
+		return {
+			id: id38,
+			diagram: diagram2
+		};
+	}, "loader")
+};
+var hasLoadedDiagrams = false;
+var addDiagrams = /* @__PURE__ */ __name(() => {
+	if (hasLoadedDiagrams) return;
+	hasLoadedDiagrams = true;
+	registerDiagram("error", errorDiagram_default, (text) => {
+		return text.toLowerCase().trim() === "error";
+	});
+	registerDiagram("---", {
+		db: { clear: /* @__PURE__ */ __name(() => {}, "clear") },
+		styles: {},
+		renderer: { draw: /* @__PURE__ */ __name(() => {}, "draw") },
+		parser: { parse: /* @__PURE__ */ __name(() => {
+			throw new Error("Diagrams beginning with --- are not valid. If you were trying to use a YAML front-matter, please ensure that you've correctly opened and closed the YAML front-matter with un-indented `---` blocks");
+		}, "parse") },
+		init: /* @__PURE__ */ __name(() => null, "init")
+	}, (text) => {
+		return text.toLowerCase().trimStart().startsWith("---");
+	});
+	registerLazyLoadedDiagrams(detector_default2, detector_default4, architectureDetector_default);
+	registerLazyLoadedDiagrams(c4Detector_default, detector_default5, classDetector_V2_default, classDetector_default, erDetector_default, ganttDetector_default, info, pie, requirementDetector_default, sequenceDetector_default, detector_default, flowDetector_v2_default, flowDetector_default, detector_default3, gitGraphDetector_default, stateDetector_V2_default, stateDetector_default, journeyDetector_default, quadrantDetector_default, sankeyDetector_default, packet, xychartDetector_default, blockDetector_default, detector_default7, detector_default6, radar, ishikawa, treemap, railroad, railroadEbnf, railroadAbnf, railroadPeg, vennDetector_default, wardleyDetector_default, cynefin);
+}, "addDiagrams");
+var loadRegisteredDiagrams = /* @__PURE__ */ __name(async () => {
+	log.debug(`Loading registered diagrams`);
+	const failed = (await Promise.allSettled(Object.entries(detectors).map(async ([key, { detector: detector39, loader: loader39 }]) => {
+		if (!loader39) return;
+		try {
+			getDiagram(key);
+		} catch {
+			try {
+				const { diagram: diagram2, id: id39 } = await loader39();
+				registerDiagram(id39, diagram2, detector39);
+			} catch (err) {
+				log.error(`Failed to load external diagram with key ${key}. Removing from detectors.`);
+				delete detectors[key];
+				throw err;
+			}
+		}
+	}))).filter((result) => result.status === "rejected");
+	if (failed.length > 0) {
+		log.error(`Failed to load ${failed.length} external diagrams`);
+		for (const res of failed) log.error(res);
+		throw new Error(`Failed to load ${failed.length} external diagrams`);
+	}
+}, "loadRegisteredDiagrams");
+var SVG_ROLE = "graphics-document document";
+function setA11yDiagramInfo(svg, diagramType) {
+	svg.attr("role", SVG_ROLE);
+	if (diagramType !== "") svg.attr("aria-roledescription", diagramType);
+}
+__name(setA11yDiagramInfo, "setA11yDiagramInfo");
+function addSVGa11yTitleDescription(svg, a11yTitle, a11yDesc, baseId) {
+	if (svg.insert === void 0) return;
+	if (a11yDesc) {
+		const descId = `chart-desc-${baseId}`;
+		svg.attr("aria-describedby", descId);
+		svg.insert("desc", ":first-child").attr("id", descId).text(a11yDesc);
+	}
+	if (a11yTitle) {
+		const titleId = `chart-title-${baseId}`;
+		svg.attr("aria-labelledby", titleId);
+		svg.insert("title", ":first-child").attr("id", titleId).text(a11yTitle);
+	}
+}
+__name(addSVGa11yTitleDescription, "addSVGa11yTitleDescription");
+var Diagram = class _Diagram {
+	constructor(type, text, db, parser, renderer2) {
+		this.type = type;
+		this.text = text;
+		this.db = db;
+		this.parser = parser;
+		this.renderer = renderer2;
+	}
+	static {
+		__name(this, "Diagram");
+	}
+	static async fromText(text, metadata = {}) {
+		const config = getConfig();
+		const type = detectType(text, config);
+		text = encodeEntities(text) + "\n";
+		try {
+			getDiagram(type);
+		} catch {
+			const loader39 = getDiagramLoader(type);
+			if (!loader39) throw new UnknownDiagramError(`Diagram ${type} not found.`);
+			const { id: id39, diagram: diagram2 } = await loader39();
+			registerDiagram(id39, diagram2);
+		}
+		const { db, parser, renderer: renderer2, init: init2 } = getDiagram(type);
+		if (parser.parser) parser.parser.yy = db;
+		db.clear?.();
+		init2?.(config);
+		if (metadata.title) db.setDiagramTitle?.(metadata.title);
+		await parser.parse(text);
+		return new _Diagram(type, text, db, parser, renderer2);
+	}
+	async render(id39, version) {
+		await this.renderer.draw(this.text, id39, version, this);
+	}
+	getParser() {
+		return this.parser;
+	}
+	getType() {
+		return this.type;
+	}
+};
+var interactionFunctions = [];
+var attachFunctions = /* @__PURE__ */ __name(() => {
+	interactionFunctions.forEach((f) => {
+		f();
+	});
+	interactionFunctions = [];
+}, "attachFunctions");
+var cleanupComments = /* @__PURE__ */ __name((text) => {
+	return text.replace(/^\s*%%(?!{)[^\n]+\n?/gm, "").trimStart();
+}, "cleanupComments");
+function extractFrontMatter(text) {
+	const matches = text.match(frontMatterRegex);
+	if (!matches) return {
+		text,
+		metadata: {}
+	};
+	const indent = matches[1];
+	const yamlBody = indent ? matches[2].split("\n").map((line) => line.startsWith(indent) ? line.slice(indent.length) : line).join("\n") : matches[2];
+	let parsed = load(yamlBody, { schema: JSON_SCHEMA }) ?? {};
+	parsed = typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	const metadata = {};
+	if (parsed.displayMode) metadata.displayMode = parsed.displayMode.toString();
+	if (parsed.title) metadata.title = parsed.title.toString();
+	if (parsed.config) metadata.config = parsed.config;
+	return {
+		text: text.slice(matches[0].length),
+		metadata
+	};
+}
+__name(extractFrontMatter, "extractFrontMatter");
+var cleanupText = /* @__PURE__ */ __name((code) => {
+	return code.replace(/\r\n?/g, "\n").replace(/<(\w+)([^>]*)>/g, (match, tag, attributes) => "<" + tag + attributes.replace(/="([^"]*)"/g, "='$1'") + ">");
+}, "cleanupText");
+var processFrontmatter = /* @__PURE__ */ __name((code) => {
+	const { text, metadata } = extractFrontMatter(code);
+	const { displayMode, title, config = {} } = metadata;
+	if (displayMode) {
+		if (!config.gantt) config.gantt = {};
+		config.gantt.displayMode = displayMode;
+	}
+	return {
+		title,
+		config,
+		text
+	};
+}, "processFrontmatter");
+var processDirectives = /* @__PURE__ */ __name((code) => {
+	const initDirective = utils_default.detectInit(code) ?? {};
+	const wrapDirectives = utils_default.detectDirective(code, "wrap");
+	if (Array.isArray(wrapDirectives)) initDirective.wrap = wrapDirectives.some(({ type }) => type === "wrap");
+	else if (wrapDirectives?.type === "wrap") initDirective.wrap = true;
+	return {
+		text: removeDirectives(code),
+		directive: initDirective
+	};
+}, "processDirectives");
+function preprocessDiagram(code) {
+	const frontMatterResult = processFrontmatter(cleanupText(code));
+	const directiveResult = processDirectives(frontMatterResult.text);
+	const config = cleanAndMerge(frontMatterResult.config, directiveResult.directive);
+	code = cleanupComments(directiveResult.text);
+	return {
+		code,
+		title: frontMatterResult.title,
+		config
+	};
+}
+__name(preprocessDiagram, "preprocessDiagram");
+function toBase64(str) {
+	const utf8Bytes = new TextEncoder().encode(str);
+	const utf8Str = Array.from(utf8Bytes, (byte) => String.fromCodePoint(byte)).join("");
+	return btoa(utf8Str);
+}
+__name(toBase64, "toBase64");
+var MAX_TEXTLENGTH = 5e4;
+var MAX_TEXTLENGTH_EXCEEDED_MSG = "graph TB;a[Maximum text size in diagram exceeded];style a fill:#faa";
+var SECURITY_LVL_SANDBOX = "sandbox";
+var SECURITY_LVL_LOOSE = "loose";
+var XMLNS_SVG_STD = "http://www.w3.org/2000/svg";
+var XMLNS_XLINK_STD = "http://www.w3.org/1999/xlink";
+var XMLNS_XHTML_STD = "http://www.w3.org/1999/xhtml";
+var IFRAME_WIDTH = "100%";
+var IFRAME_HEIGHT = "100%";
+var IFRAME_STYLES = "border:0;margin:0;";
+var IFRAME_BODY_STYLE = "margin:0";
+var IFRAME_SANDBOX_OPTS = "allow-top-navigation-by-user-activation allow-popups";
+var IFRAME_NOT_SUPPORTED_MSG = "The \"iframe\" tag is not supported by your browser.";
+var DOMPURIFY_TAGS = ["foreignobject"];
+var DOMPURIFY_ATTR = ["dominant-baseline"];
+function processAndSetConfigs(text) {
+	const processed = preprocessDiagram(text);
+	reset();
+	addDirective(processed.config ?? {});
+	return processed;
+}
+__name(processAndSetConfigs, "processAndSetConfigs");
+async function parse(text, parseOptions) {
+	addDiagrams();
+	try {
+		const { code, config } = processAndSetConfigs(text);
+		return {
+			diagramType: (await getDiagramFromText(code)).type,
+			config
+		};
+	} catch (error) {
+		if (parseOptions?.suppressErrors) return false;
+		throw error;
+	}
+}
+__name(parse, "parse");
+var cssImportantStyles = /* @__PURE__ */ __name((cssClass, element, cssClasses = []) => {
+	return `.${cssClass} ${element} ${sanitizeCss(`{ ${cssClasses.join(" !important; ")} !important; }`)}`;
+}, "cssImportantStyles");
+var createCssStyles = /* @__PURE__ */ __name((config, classDefs = /* @__PURE__ */ new Map()) => {
+	const cssStyles = new CSSStyleSheet();
+	if (config.fontFamily !== void 0) cssStyles.insertRule(`:root { --mermaid-font-family: ${config.fontFamily}}`, cssStyles.cssRules.length);
+	if (config.altFontFamily !== void 0) cssStyles.insertRule(`:root { --mermaid-alt-font-family: ${config.altFontFamily}}`, cssStyles.cssRules.length);
+	if (classDefs instanceof Map) {
+		const cssElements = getEffectiveHtmlLabels(config) ? ["> *", "span"] : [
+			"rect",
+			"polygon",
+			"ellipse",
+			"circle",
+			"path"
+		];
+		classDefs.forEach((styleClassDef) => {
+			if (!isEmpty(styleClassDef.styles)) cssElements.forEach((cssElement) => {
+				cssStyles.insertRule(cssImportantStyles(styleClassDef.id, cssElement, styleClassDef.styles), cssStyles.cssRules.length);
+			});
+			if (!isEmpty(styleClassDef.textStyles)) cssStyles.insertRule(cssImportantStyles(styleClassDef.id, "tspan", (styleClassDef?.textStyles || []).map((s) => s.replace("color", "fill"))), cssStyles.cssRules.length);
+		});
+	}
+	let cssString = "";
+	if (config.themeCSS !== void 0) if (typeof cssStyles.replaceSync === "function") {
+		const themeCssStyleSheet = new CSSStyleSheet();
+		themeCssStyleSheet.replaceSync(config.themeCSS);
+		cssString = cssStyleSheetToString(themeCssStyleSheet) + "\n";
+	} else cssString += `${config.themeCSS}
+`;
+	return cssString + cssStyleSheetToString(cssStyles);
+}, "createCssStyles");
+var compileCSS = /* @__PURE__ */ __name((namespace, css) => {
+	return serialize(compile(`${namespace}{${css}}`), middleware([/* @__PURE__ */ __name(function addNamespace(element, _index, _children, _callback) {
+		if (element.type === "rule" && Array.isArray(element.props)) {
+			if (element.parent && element.parent.type === "@keyframes") return;
+			element.props = element.props.map((prop) => {
+				if (prop === namespace && Array.isArray(element.children) && element.children.every((child) => {
+					if (child.type !== "decl") return false;
+					return (/* @__PURE__ */ new Set([
+						"font-family",
+						"font-size",
+						"fill"
+					])).has(child.props);
+				})) return prop;
+				if (!((prop.startsWith(`${namespace} `) || prop.startsWith(`${namespace}>`)) && !prop.startsWith(`${namespace} ||`))) return `${namespace} ${prop}`;
+				return prop;
+			});
+		} else if (element.type.startsWith("@")) {
+			if (![...[
+				"@media",
+				"@supports",
+				"@layer",
+				"@scope",
+				"@container",
+				"@starting-style"
+			], "@keyframes"].includes(element.type)) {
+				log.warn(`Removing unsupported at-rule ${element.type} from CSS`);
+				element.type = COMMENT;
+			}
+		}
+	}, "addNamespace"), stringify]));
+}, "compileCSS");
+var createUserStyles = /* @__PURE__ */ __name((config, graphType, classDefs, svgId) => {
+	const userCSSstyles = createCssStyles(config, classDefs);
+	return compileCSS(svgId, styles_default(graphType, userCSSstyles, {
+		...config.themeVariables,
+		theme: config.theme,
+		look: config.look
+	}, svgId));
+}, "createUserStyles");
+var cleanUpSvgCode = /* @__PURE__ */ __name((svgCode = "", inSandboxMode, useArrowMarkerUrls) => {
+	let cleanedUpSvg = svgCode;
+	if (!useArrowMarkerUrls && !inSandboxMode) cleanedUpSvg = cleanedUpSvg.replace(/marker-end="url\([\d+./:=?A-Za-z-]*?#/g, "marker-end=\"url(#");
+	cleanedUpSvg = decodeEntities(cleanedUpSvg);
+	cleanedUpSvg = cleanedUpSvg.replace(/<br>/g, "<br/>");
+	return cleanedUpSvg;
+}, "cleanUpSvgCode");
+var putIntoIFrame = /* @__PURE__ */ __name((svgCode = "", svgElement) => {
+	return `<iframe style="width:${IFRAME_WIDTH};height:${svgElement?.viewBox?.baseVal?.height ? svgElement.viewBox.baseVal.height + "px" : IFRAME_HEIGHT};${IFRAME_STYLES}" src="data:text/html;charset=UTF-8;base64,${toBase64(`<body style="${IFRAME_BODY_STYLE}">${svgCode}</body>`)}" sandbox="${IFRAME_SANDBOX_OPTS}">
+  ${IFRAME_NOT_SUPPORTED_MSG}
+</iframe>`;
+}, "putIntoIFrame");
+var appendDivSvgG = /* @__PURE__ */ __name((parentRoot, id39, enclosingDivId, divStyle, svgXlink) => {
+	const enclosingDiv = parentRoot.append("div");
+	enclosingDiv.attr("id", enclosingDivId);
+	if (divStyle) enclosingDiv.attr("style", divStyle);
+	const svgNode = enclosingDiv.append("svg").attr("id", id39).attr("width", "100%").attr("xmlns", XMLNS_SVG_STD);
+	if (svgXlink) svgNode.attr("xmlns:xlink", svgXlink);
+	svgNode.append("g");
+	return parentRoot;
+}, "appendDivSvgG");
+function sandboxedIframe(parentNode, iFrameId) {
+	return parentNode.append("iframe").attr("id", iFrameId).attr("style", "width: 100%; height: 100%;").attr("sandbox", "");
+}
+__name(sandboxedIframe, "sandboxedIframe");
+var removeExistingElements = /* @__PURE__ */ __name((doc, id39, divId, iFrameId) => {
+	doc.getElementById(id39)?.remove();
+	doc.getElementById(divId)?.remove();
+	doc.getElementById(iFrameId)?.remove();
+}, "removeExistingElements");
+var render = /* @__PURE__ */ __name(async function(id39, text, svgContainingElement) {
+	addDiagrams();
+	const processed = processAndSetConfigs(text);
+	text = processed.code;
+	const config = getConfig();
+	log.debug(config);
+	if (text.length > (config?.maxTextSize ?? MAX_TEXTLENGTH)) text = MAX_TEXTLENGTH_EXCEEDED_MSG;
+	const idSelector = `#${id39}`;
+	const iFrameID = "i" + id39;
+	const iFrameID_selector = "#" + iFrameID;
+	const enclosingDivID = "d" + id39;
+	const enclosingDivID_selector = "#" + enclosingDivID;
+	const removeTempElements = /* @__PURE__ */ __name(() => {
+		const node = select_default(isSandboxed ? iFrameID_selector : enclosingDivID_selector).node();
+		if (node && "remove" in node) node.remove();
+	}, "removeTempElements");
+	let root = select_default(document.body);
+	const isSandboxed = config.securityLevel === SECURITY_LVL_SANDBOX;
+	const isLooseSecurityLevel = config.securityLevel === SECURITY_LVL_LOOSE;
+	const fontFamily = config.fontFamily;
+	if (svgContainingElement !== void 0) {
+		if (svgContainingElement) svgContainingElement.innerHTML = "";
+		if (isSandboxed) {
+			const iframe = sandboxedIframe(select_default(svgContainingElement), iFrameID);
+			root = select_default(iframe.nodes()[0].contentDocument.body);
+			root.node().style.margin = "0";
+		} else root = select_default(svgContainingElement);
+		appendDivSvgG(root, id39, enclosingDivID, `font-family: ${fontFamily}`, XMLNS_XLINK_STD);
+	} else {
+		removeExistingElements(document, id39, enclosingDivID, iFrameID);
+		if (isSandboxed) {
+			const iframe = sandboxedIframe(select_default(document.body), iFrameID);
+			root = select_default(iframe.nodes()[0].contentDocument.body);
+			root.node().style.margin = "0";
+		} else root = select_default("body");
+		appendDivSvgG(root, id39, enclosingDivID);
+	}
+	let diag;
+	let parseEncounteredException;
+	try {
+		diag = await Diagram.fromText(text, { title: processed.title });
+	} catch (error) {
+		if (config.suppressErrorRendering) {
+			removeTempElements();
+			throw error;
+		}
+		diag = await Diagram.fromText("error");
+		parseEncounteredException = error;
+	}
+	const element = root.select(enclosingDivID_selector).node();
+	const diagramType = diag.type;
+	const svg = element.firstChild;
+	const firstChild = svg.firstChild;
+	const diagramClassDefs = diag.renderer.getClasses?.(text, diag);
+	const rules = createUserStyles(config, diagramType, diagramClassDefs, idSelector);
+	const style1 = document.createElement("style");
+	style1.innerHTML = rules;
+	svg.insertBefore(style1, firstChild);
+	try {
+		await diag.renderer.draw(text, id39, "11.17.2", diag);
+	} catch (e) {
+		if (config.suppressErrorRendering) removeTempElements();
+		else errorRenderer_default.draw(text, id39, "11.17.2");
+		throw e;
+	}
+	const svgNode = root.select(`${enclosingDivID_selector} svg`);
+	const a11yTitle = diag.db.getAccTitle?.();
+	const a11yDescr = diag.db.getAccDescription?.();
+	addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr);
+	const svgCode = (/* @__PURE__ */ __name(() => {
+		root.select(`[id="${id39}"]`).selectAll("foreignobject > *").attr("xmlns", XMLNS_XHTML_STD);
+		let code = root.select(enclosingDivID_selector).node().innerHTML;
+		log.debug("config.arrowMarkerAbsolute", config.arrowMarkerAbsolute);
+		code = cleanUpSvgCode(code, isSandboxed, evaluate(config.arrowMarkerAbsolute));
+		if (isSandboxed) {
+			const svgEl = root.select(enclosingDivID_selector + " svg").node();
+			code = putIntoIFrame(code, svgEl);
+		} else if (!isLooseSecurityLevel) code = purify.sanitize(code, {
+			ADD_TAGS: DOMPURIFY_TAGS,
+			ADD_ATTR: DOMPURIFY_ATTR,
+			HTML_INTEGRATION_POINTS: { foreignobject: true }
+		});
+		attachFunctions();
+		return code;
+	}, "serializeSvg"))();
+	if (parseEncounteredException) throw parseEncounteredException;
+	removeTempElements();
+	return {
+		diagramType,
+		svg: svgCode,
+		bindFunctions: diag.db.bindFunctions
+	};
+}, "render");
+function initialize(userOptions = {}) {
+	const options = assignWithDepth_default({}, userOptions);
+	if (options?.fontFamily && !options.themeVariables?.fontFamily) {
+		if (!options.themeVariables) options.themeVariables = {};
+		options.themeVariables.fontFamily = options.fontFamily;
+	}
+	saveConfigFromInitialize(options);
+	if (options?.theme && options.theme in themes_default) options.themeVariables = themes_default[options.theme].getThemeVariables(options.themeVariables);
+	else if (options) options.themeVariables = themes_default.default.getThemeVariables(options.themeVariables);
+	const config = typeof options === "object" ? setSiteConfig(options) : getSiteConfig();
+	setLogLevel(config.logLevel);
+	addDiagrams();
+}
+__name(initialize, "initialize");
+var getDiagramFromText = /* @__PURE__ */ __name((text, metadata = {}) => {
+	const { code } = preprocessDiagram(text);
+	return Diagram.fromText(code, metadata);
+}, "getDiagramFromText");
+function addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr) {
+	setA11yDiagramInfo(svgNode, diagramType);
+	addSVGa11yTitleDescription(svgNode, a11yTitle, a11yDescr, svgNode.attr("id"));
+}
+__name(addA11yInfo, "addA11yInfo");
+var mermaidAPI = Object.freeze({
+	render,
+	parse,
+	getDiagramFromText,
+	initialize,
+	getConfig,
+	/**
+	* @deprecated This function does nothing. It will be overwritten by the next
+	*             call to {@link render} or {@link parse}.
+	*/
+	setConfig,
+	getSiteConfig,
+	updateSiteConfig,
+	reset: /* @__PURE__ */ __name(() => {
+		reset();
+	}, "reset"),
+	globalReset: /* @__PURE__ */ __name(() => {
+		reset(defaultConfig);
+	}, "globalReset"),
+	defaultConfig
+});
+setLogLevel(getConfig().logLevel);
+reset(getConfig());
+var handleError = /* @__PURE__ */ __name((error, errors, parseError) => {
+	log.warn(error);
+	if (isDetailedError(error)) {
+		if (parseError) parseError(error.str, error.hash);
+		errors.push({
+			...error,
+			message: error.str,
+			error
+		});
+	} else {
+		if (parseError) parseError(error);
+		if (error instanceof Error) errors.push({
+			str: error.message,
+			message: error.message,
+			hash: error.name,
+			error
+		});
+	}
+}, "handleError");
+var run = /* @__PURE__ */ __name(async function(options = { querySelector: ".mermaid" }) {
+	try {
+		await runThrowsErrors(options);
+	} catch (e) {
+		if (isDetailedError(e)) log.error(e.str);
+		if (mermaid.parseError) mermaid.parseError(e);
+		if (!options.suppressErrors) {
+			log.error("Use the suppressErrors option to suppress these errors");
+			throw e;
+		}
+	}
+}, "run");
+var runThrowsErrors = /* @__PURE__ */ __name(async function({ postRenderCallback, querySelector, nodes } = { querySelector: ".mermaid" }) {
+	const conf = mermaidAPI.getConfig();
+	log.debug(`${!postRenderCallback ? "No " : ""}Callback function found`);
+	let nodesToProcess;
+	if (nodes) nodesToProcess = nodes;
+	else if (querySelector) nodesToProcess = document.querySelectorAll(querySelector);
+	else throw new Error("Nodes and querySelector are both undefined");
+	log.debug(`Found ${nodesToProcess.length} diagrams`);
+	if (conf?.startOnLoad !== void 0) {
+		log.debug("Start On Load: " + conf?.startOnLoad);
+		mermaidAPI.updateSiteConfig({ startOnLoad: conf?.startOnLoad });
+	}
+	const idGenerator = new utils_default.InitIDGenerator(conf.deterministicIds, conf.deterministicIDSeed);
+	let txt;
+	const errors = [];
+	for (const element of Array.from(nodesToProcess)) {
+		log.info("Rendering diagram: " + element.id);
+		if (element.getAttribute("data-processed")) continue;
+		element.setAttribute("data-processed", "true");
+		const id39 = `mermaid-${idGenerator.next()}`;
+		txt = element.innerHTML;
+		txt = dedent(utils_default.entityDecode(txt)).trim().replace(/<br\s*\/?>/gi, "<br/>");
+		const init2 = utils_default.detectInit(txt);
+		if (init2) log.debug("Detected early reinit: ", init2);
+		try {
+			const { svg, bindFunctions } = await render2(id39, txt, element);
+			element.innerHTML = svg;
+			if (postRenderCallback) await postRenderCallback(id39);
+			if (bindFunctions) bindFunctions(element);
+		} catch (error) {
+			handleError(error, errors, mermaid.parseError);
+		}
+	}
+	if (errors.length > 0) throw errors[0];
+}, "runThrowsErrors");
+var initialize2 = /* @__PURE__ */ __name(function(config) {
+	mermaidAPI.initialize(config);
+}, "initialize");
+var init = /* @__PURE__ */ __name(async function(config, nodes, callback) {
+	log.warn("mermaid.init is deprecated. Please use run instead.");
+	if (config) initialize2(config);
+	const runOptions = {
+		postRenderCallback: callback,
+		querySelector: ".mermaid"
+	};
+	if (typeof nodes === "string") runOptions.querySelector = nodes;
+	else if (nodes) if (nodes instanceof HTMLElement) runOptions.nodes = [nodes];
+	else runOptions.nodes = nodes;
+	await run(runOptions);
+}, "init");
+var registerExternalDiagrams = /* @__PURE__ */ __name(async (diagrams, { lazyLoad = true } = {}) => {
+	addDiagrams();
+	registerLazyLoadedDiagrams(...diagrams);
+	if (lazyLoad === false) await loadRegisteredDiagrams();
+}, "registerExternalDiagrams");
+var contentLoaded = /* @__PURE__ */ __name(function() {
+	if (mermaid.startOnLoad) {
+		const { startOnLoad } = mermaidAPI.getConfig();
+		if (startOnLoad) mermaid.run().catch((err) => log.error("Mermaid failed to initialize", err));
+	}
+}, "contentLoaded");
+if (typeof document !== "undefined") window.addEventListener("load", contentLoaded, false);
+var setParseErrorHandler = /* @__PURE__ */ __name(function(parseErrorHandler) {
+	mermaid.parseError = parseErrorHandler;
+}, "setParseErrorHandler");
+var executionQueue = [];
+var executionQueueRunning = false;
+var executeQueue = /* @__PURE__ */ __name(async () => {
+	if (executionQueueRunning) return;
+	executionQueueRunning = true;
+	while (executionQueue.length > 0) {
+		const f = executionQueue.shift();
+		if (f) try {
+			await f();
+		} catch (e) {
+			log.error("Error executing queue", e);
+		}
+	}
+	executionQueueRunning = false;
+}, "executeQueue");
+var parse2 = /* @__PURE__ */ __name(async (text, parseOptions) => {
+	return new Promise((resolve, reject) => {
+		const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => {
+			mermaidAPI.parse(text, parseOptions).then((r) => {
+				res(r);
+				resolve(r);
+			}, (e) => {
+				log.error("Error parsing", e);
+				mermaid.parseError?.(e);
+				rej(e);
+				reject(e);
+			});
+		}), "performCall");
+		executionQueue.push(performCall);
+		executeQueue().catch(reject);
+	});
+}, "parse");
+var render2 = /* @__PURE__ */ __name((id39, text, container) => {
+	return new Promise((resolve, reject) => {
+		const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => {
+			mermaidAPI.render(id39, text, container).then((r) => {
+				res(r);
+				resolve(r);
+			}, (e) => {
+				log.error("Error parsing", e);
+				mermaid.parseError?.(e);
+				rej(e);
+				reject(e);
+			});
+		}), "performCall");
+		executionQueue.push(performCall);
+		executeQueue().catch(reject);
+	});
+}, "render");
+var mermaid = {
+	startOnLoad: true,
+	mermaidAPI,
+	parse: parse2,
+	render: render2,
+	init,
+	run,
+	registerExternalDiagrams,
+	registerLayoutLoaders,
+	initialize: initialize2,
+	parseError: void 0,
+	contentLoaded,
+	setParseErrorHandler,
+	detectType,
+	registerIconPacks,
+	getRegisteredDiagramsMetadata: /* @__PURE__ */ __name(() => {
+		return Object.keys(detectors).map((id39) => ({ id: id39 }));
+	}, "getRegisteredDiagramsMetadata")
+};
+var mermaid_default = mermaid;
+/*! Check if previously processed */
+/*!
+* Wait for document loaded before starting the execution
+*/
+
+//#endregion
+export { createCommonLayoutRenderer as a, insertMeasuredNode as c, render$1 as d, mermaid_default as default, selectSvgElement as f, clusterDb as i, sortNodesByHierarchy as l, load as n, createLayoutElementGroups as o, adjustClustersAndEdges as r, findNonClusterChild as s, JSON_SCHEMA as t, getRegisteredLayoutAlgorithm as u };