@statelyai/sdk 0.39.1 → 0.41.0

package/dist/sourceCoverage.mjs

@@ -0,0 +1,3572 @@
+import { a as __toESM$1 } from "./chunk-D1OLi6Wq.mjs";
+import { At as boolean, Bt as discriminatedUnion, Er as toJSONSchema, Et as array, Lt as custom, Nn as record, Rn as string, St as _null, Tn as object, Xn as union, Zn as unknown, dn as literal, un as lazy, wn as number, yt as _enum } from "./schemas-DsQ8UYlM.mjs";
+import { a as XSTATE_V5_PROFILE, d as isCodeExpression, l as XSTATE_V6_PROFILE, r as LEGACY_MACHINE_PROFILES } from "./rolldown-runtime-95iHPtFO-Bo6l7CbO.mjs";
+import { l as stripExportDefault } from "./machineGraph-DYtFKHlq-ChbeTHlv.mjs";
+import { i as require_typescript, n as getXStateSourceCoverageAnalysis, t as getXStateCoverageBranchProjection } from "./xstateSource-JvwXWv6G-KnMMoZlG.mjs";
+import "xstate";
+import "xstate/graph";
+
+//#region ../graph-tools/dist/validation-Dw_E9VuI.mjs
+function resolveProfileData(data, namespace) {
+	const prefix = `${namespace}.`;
+	return Object.fromEntries(Object.entries(data).filter(([key]) => key.startsWith(prefix)).map(([key, value]) => [key.slice(prefix.length), value]));
+}
+const ARCHITECTURE_PROFILE = "@statelyai/architecture@1.0.0";
+const ARCHITECTURE_NAMESPACE = "@statelyai.architecture";
+const architectureTargetSchema = discriminatedUnion("kind", [object({
+	kind: literal("machine"),
+	machineId: string().min(1),
+	projectId: string().min(1).optional()
+}), object({
+	kind: literal("view"),
+	viewId: string().min(1)
+})]);
+const architectureViewSchema = object({
+	id: string().min(1),
+	name: string().min(1),
+	kind: _enum([
+		"system-context",
+		"container",
+		"component",
+		"custom"
+	]),
+	nodeIds: array(string()),
+	edgeIds: array(string())
+});
+const architectureGraphDataSchema = object({
+	version: literal(1),
+	views: array(architectureViewSchema),
+	activeViewId: string().optional(),
+	projectOverview: boolean().optional()
+});
+const architectureNodeDataSchema = object({
+	kind: string().optional(),
+	externalId: string().optional(),
+	technology: string().optional(),
+	target: architectureTargetSchema.optional()
+});
+const architectureEdgeDataSchema = object({
+	kind: string().optional(),
+	externalId: string().optional(),
+	technology: string().optional()
+});
+function architectureData(data) {
+	return resolveProfileData(Object.fromEntries(Object.entries(data)), ARCHITECTURE_NAMESPACE);
+}
+function getArchitectureNodeData(node) {
+	const data = architectureData(node.data);
+	if (!Object.keys(data).length) return void 0;
+	const parsed = architectureNodeDataSchema.safeParse(data);
+	return parsed.success ? parsed.data : void 0;
+}
+const jsonSchema7Schema = lazy(() => object({
+	$schema: string().optional(),
+	type: _enum([
+		"object",
+		"array",
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null"
+	]).optional(),
+	properties: record(string(), jsonSchema7Schema).optional(),
+	items: jsonSchema7Schema.optional(),
+	additionalProperties: union([boolean(), jsonSchema7Schema]).optional(),
+	required: array(string()).optional(),
+	anyOf: array(jsonSchema7Schema).optional(),
+	oneOf: array(jsonSchema7Schema).optional(),
+	enum: array(union([
+		string(),
+		number(),
+		boolean(),
+		_null()
+	])).optional(),
+	const: union([
+		string(),
+		number(),
+		boolean(),
+		_null()
+	]).optional(),
+	minLength: number().optional()
+}).strict());
+function draft7Schema(schema) {
+	return jsonSchema7Schema.parse(toJSONSchema(schema, { target: "draft-7" }));
+}
+const ARCHITECTURE_PROFILE_MANIFEST = {
+	profile: ARCHITECTURE_PROFILE,
+	namespace: ARCHITECTURE_NAMESPACE,
+	lineage: "@statelyai/architecture",
+	projection: {
+		readOnlyPaths: [
+			"initialNodeId",
+			"nodes.*.initialNodeId",
+			"nodes.*.data.initialId",
+			"nodes.*.data.entry",
+			"nodes.*.data.exit",
+			"nodes.*.data.invokes",
+			"nodes.*.data.history",
+			"edges.*.data.guard",
+			"edges.*.data.actions",
+			"edges.*.data.transitionType"
+		],
+		adapt: (graph) => ({ data: {
+			nodes: Object.fromEntries(graph.nodes.map((node) => [node.id, { kind: getArchitectureNodeData(node)?.kind ?? "component" }])),
+			edges: Object.fromEntries(graph.edges.map((edge) => [edge.id, { kind: "relationship" }]))
+		} }),
+		analyzeCompatibility: (graph) => graph.nodes.some((node) => node.data.initialId || Array.isArray(node.data.entry) && node.data.entry.length || Array.isArray(node.data.exit) && node.data.exit.length || Array.isArray(node.data.invokes) && node.data.invokes.length) || graph.edges.some((edge) => edge.data.guard || Array.isArray(edge.data.actions) && edge.data.actions.length || edge.data.transitionType && edge.data.transitionType !== "normal") ? [{
+			level: "warning",
+			message: "State-machine initial states, effects, guards and transition behavior are retained but read-only in Architecture. Relationships describe structure; architecture simulation is unavailable."
+		}] : []
+	},
+	name: "Architecture",
+	description: "Components, relationships, and navigable system views.",
+	selectable: true,
+	restrictFormatsToListed: true,
+	defaultFormat: "xgraph",
+	graph: { dataSchema: draft7Schema(architectureGraphDataSchema) },
+	authoring: {
+		terminology: {
+			node: "component",
+			edge: "relationship",
+			graph: "architecture"
+		},
+		nodeTypes: [
+			"element",
+			"actor",
+			"person",
+			"system",
+			"container",
+			"component",
+			"service",
+			"database",
+			"queue",
+			"group",
+			"junction"
+		].map((kind) => ({
+			kind,
+			label: kind.charAt(0).toUpperCase() + kind.slice(1),
+			authorable: true,
+			canContain: true,
+			dataSchema: draft7Schema(architectureNodeDataSchema)
+		})),
+		edgeTypes: [{
+			kind: "relationship",
+			label: "Relationship",
+			authorable: true,
+			dataSchema: draft7Schema(architectureEdgeDataSchema)
+		}],
+		attachments: {
+			actions: false,
+			guards: false,
+			invokes: false,
+			tags: false
+		},
+		supportsInitialNode: false,
+		supportsTargetlessEdges: false,
+		supportsReenterEdges: false
+	},
+	operations: {
+		simulate: false,
+		validate: true,
+		export: true
+	},
+	formats: [{
+		format: "xgraph",
+		import: true,
+		export: true
+	}, ...[
+		"structurizr-json",
+		"d2",
+		"mermaid"
+	].map((format) => ({
+		format,
+		import: true,
+		export: false
+	}))]
+};
+function analyzeXStateV5Compatibility(graph) {
+	const issues = [];
+	const graphPaths = [["data.version", graph.data.version], ["data.options", graph.data.options]].filter(([, value]) => value != null);
+	if (graphPaths.length) issues.push({
+		level: "warning",
+		message: "XState v6 machine fields are retained but read-only in XState v5.",
+		readOnlyPaths: graphPaths.map(([path]) => path)
+	});
+	for (const node of graph.nodes) {
+		const paths = [
+			["data.initialInput", node.data.initialInput],
+			["data.timeout", node.data.timeout],
+			["data.route", node.data.route],
+			["data.schemas", node.data.schemas]
+		].filter(([, value]) => value != null);
+		if (paths.length) issues.push({
+			level: "warning",
+			message: `XState v6 fields on ${node.data.key ?? node.id} are retained but read-only in XState v5.`,
+			nodeIds: [node.id],
+			readOnlyPaths: paths.map(([path]) => `nodes.${node.id}.${path}`)
+		});
+	}
+	for (const edge of graph.edges) {
+		const paths = [["data.matches", edge.data.matches], ["data.input", edge.data.input]].filter(([, value]) => value != null);
+		if (paths.length) issues.push({
+			level: "warning",
+			message: "XState v6 transition fields are retained but read-only in XState v5.",
+			edgeIds: [edge.id],
+			readOnlyPaths: paths.map(([path]) => `edges.${edge.id}.${path}`)
+		});
+	}
+	return issues;
+}
+const XSTATE_V5_PROJECTION = {
+	readOnlyPaths: [
+		"data.version",
+		"data.options",
+		"nodes.*.data.initialInput",
+		"nodes.*.data.timeout",
+		"nodes.*.data.route",
+		"nodes.*.data.schemas",
+		"edges.*.data.matches",
+		"edges.*.data.input"
+	],
+	analyzeCompatibility: analyzeXStateV5Compatibility
+};
+const XSTATE_V6_PROJECTION = {};
+/**
+* Derive LangGraph authoring kinds into its namespace. Canonical fields and
+* graph topology are never returned, so the adapter cannot rewrite them.
+*/
+const LANGGRAPH_PROJECTION = { adapt: (graph) => ({ data: {
+	nodes: Object.fromEntries(graph.nodes.map((node) => [node.id, { kind: node.data.type === "final" ? "end" : node.data.kind === "agent" || node.data.kind === "task" || node.data.kind === "entrypoint" ? node.data.kind : "node" }])),
+	edges: Object.fromEntries(graph.edges.map((edge) => {
+		const source = graph.nodes.find((node) => node.id === edge.sourceId);
+		return [edge.id, { kind: edge.data.kind === "call" ? "call" : edge.data.kind === "conditional" || edge.data.guard != null || source?.data.type === "choice" ? "conditional" : "edge" }];
+	}))
+} }) };
+/** Stately's semantic projection of the LangGraph 1.x APIs across runtimes. */
+const LANGGRAPH_PROFILE = "@statelyai/langgraph@1.0.0";
+const LANGGRAPH_PROFILE_MANIFEST = {
+	profile: LANGGRAPH_PROFILE,
+	namespace: "@statelyai.langgraph",
+	lineage: "@statelyai/langgraph",
+	projection: LANGGRAPH_PROJECTION,
+	selectable: false,
+	name: "LangGraph",
+	description: "LangGraph 1.x graph semantics for Python and JavaScript/TypeScript source.",
+	restrictFormatsToListed: true,
+	authoring: {
+		terminology: {
+			node: "node",
+			edge: "edge",
+			graph: "graph"
+		},
+		nodeTypes: [
+			{
+				kind: "node",
+				label: "Node",
+				description: "Graph API node",
+				authorable: true
+			},
+			{
+				kind: "task",
+				label: "Task",
+				description: "Functional API task",
+				authorable: true
+			},
+			{
+				kind: "entrypoint",
+				label: "Entrypoint",
+				description: "Functional API entrypoint",
+				authorable: true
+			},
+			{
+				kind: "agent",
+				label: "Agent",
+				description: "Prebuilt agent",
+				authorable: true
+			},
+			{
+				kind: "end",
+				label: "END",
+				description: "Terminal sentinel",
+				authorable: true,
+				terminal: true
+			}
+		],
+		edgeTypes: [
+			{
+				kind: "edge",
+				label: "Edge",
+				description: "Direct route",
+				authorable: true
+			},
+			{
+				kind: "conditional",
+				label: "Conditional edge",
+				description: "Runtime-routed branch",
+				authorable: true
+			},
+			{
+				kind: "call",
+				label: "Call",
+				description: "Functional API call",
+				authorable: true
+			}
+		],
+		attachments: {},
+		supportsInitialNode: false,
+		supportsTargetlessEdges: false,
+		supportsReenterEdges: false
+	},
+	operations: {
+		simulate: false,
+		validate: false,
+		export: false
+	},
+	formats: [
+		{
+			format: "python",
+			import: true,
+			export: false,
+			sourcePreserving: true
+		},
+		{
+			format: "typescript",
+			import: true,
+			export: false,
+			sourcePreserving: true
+		},
+		{
+			format: "javascript",
+			import: true,
+			export: false,
+			sourcePreserving: true
+		}
+	],
+	features: {
+		graphApi: true,
+		functionalApi: true,
+		prebuiltAgents: true
+	}
+};
+let syntaxChecker;
+/**
+* Installs the parser used to validate profile code blocks. The main entry
+* stays free of the TypeScript compiler, so `@statelyai/graph-tools/typescript`
+* installs a TypeScript-backed checker when it loads. Until then, profile code
+* is treated as syntactically valid.
+*/
+function setProfileCodeSyntaxChecker(checker) {
+	syntaxChecker = checker;
+}
+function hasNoParseErrors(source) {
+	return syntaxChecker ? syntaxChecker(source) : true;
+}
+const XSTATE_FORMATS = [
+	{
+		format: "typescript",
+		import: true,
+		export: true,
+		sourcePreserving: true
+	},
+	{
+		format: "javascript",
+		import: true,
+		export: true,
+		sourcePreserving: true
+	},
+	{
+		format: "json",
+		import: true,
+		export: true
+	},
+	{
+		format: "yaml",
+		import: true,
+		export: true
+	}
+];
+const XSTATE_AUTHORING = {
+	terminology: {
+		node: "state",
+		edge: "transition",
+		graph: "machine"
+	},
+	nodeTypes: [
+		{
+			kind: "normal",
+			label: "Normal",
+			description: "Basic state",
+			authorable: true,
+			canContain: true
+		},
+		{
+			kind: "parallel",
+			label: "Parallel",
+			description: "Concurrent child states",
+			authorable: true,
+			canContain: true
+		},
+		{
+			kind: "final",
+			label: "Final",
+			description: "Terminal state",
+			authorable: true,
+			terminal: true
+		},
+		{
+			kind: "history",
+			label: "History",
+			description: "Restores previous state",
+			authorable: true
+		},
+		{
+			kind: "choice",
+			label: "Choice",
+			description: "Guarded eventless routing",
+			authorable: true
+		}
+	],
+	edgeTypes: [{
+		kind: "transition",
+		label: "Transition",
+		authorable: true
+	}],
+	attachments: {
+		actions: true,
+		guards: true,
+		invokes: true,
+		tags: true
+	},
+	supportsInitialNode: true,
+	supportsTargetlessEdges: true,
+	supportsReenterEdges: true
+};
+function isExpression(code) {
+	return code.trim().length > 0 && hasNoParseErrors(`(${code})`);
+}
+function isImplementation(code) {
+	return isExpression(stripExportDefault(code)) || hasNoParseErrors(`function implementation() {\n${code}\n}`);
+}
+function isAsyncImplementation(code) {
+	return isExpression(stripExportDefault(code)) || hasNoParseErrors(`async function implementation() {\n${code}\n}`);
+}
+function pathEndsWith(location, suffix) {
+	return suffix.every((segment, index) => location.path[location.path.length - suffix.length + index] === segment);
+}
+function commented(code) {
+	return code.replace(/\r\n?|\u2028|\u2029/g, "\n").split("\n").map((line) => `// ${line}`).join("\n");
+}
+function indent(code, spaces) {
+	const prefix = " ".repeat(spaces);
+	return code.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function indentAfterFirstLine(code, spaces) {
+	const [first = "", ...rest] = code.split("\n");
+	if (rest.length === 0) return first;
+	return `${first}\n${indent(rest.join("\n"), spaces)}`;
+}
+const throwingBody = (invalidCode) => `// FIXME(stately): authored code does not compile\n${commented(invalidCode)}\nthrow new Error('Invalid authored code');`;
+const falseBody = (invalidCode) => `// FIXME(stately): authored code does not compile\n${commented(invalidCode)}\nreturn false;`;
+const throwingExpression = (invalidCode) => `(() => {\n${indent(throwingBody(invalidCode), 2)}\n})()`;
+const functionThrowingExpression = (invalidCode) => `() => {\n${indent(throwingBody(invalidCode), 2)}\n}`;
+const functionFalseExpression = (invalidCode) => `() => {\n${indent(falseBody(invalidCode), 2)}\n}`;
+const throwingImplementationBody = (invalidCode) => indentAfterFirstLine(throwingBody(invalidCode), 2);
+const falseImplementationBody = (invalidCode) => indentAfterFirstLine(falseBody(invalidCode), 2);
+function implementationTarget(location, collection) {
+	const index = location.path[3];
+	const implementations = location.graph.data.implementations?.[collection];
+	const implementation = typeof index === "number" ? implementations?.[index] : void 0;
+	if (!implementation?.id) return void 0;
+	return {
+		kind: "source",
+		sourceType: collection === "actors" ? "actor" : collection.slice(0, -1),
+		id: implementation.id,
+		label: implementation.name || implementation.id
+	};
+}
+function entityTarget(location) {
+	const [collection, index] = location.path;
+	const isNode = collection === "nodes" && typeof index === "number";
+	const isEdge = collection === "edges" && typeof index === "number";
+	const owner = isNode ? location.graph.nodes[index] : isEdge ? location.graph.edges[index] : void 0;
+	if (!owner) return void 0;
+	const dataOffset = location.path.indexOf("data");
+	const field = location.path[dataOffset + 1];
+	const itemIndex = location.path[dataOffset + 2];
+	if ((field === "entry" || field === "exit" || field === "actions") && typeof itemIndex === "number") {
+		const action = owner.data[field]?.[itemIndex];
+		if (action?.id) return {
+			kind: "entity",
+			id: `action:${action.id}`,
+			label: action.type ? `Action: ${action.type}` : "Action"
+		};
+	}
+	if (field === "invokes" && typeof itemIndex === "number") {
+		const invoke = owner.data.invokes?.[itemIndex];
+		if (invoke?.id) return {
+			kind: "entity",
+			id: `invoke:${invoke.id}`,
+			label: invoke.src ? `Invoke: ${invoke.src}` : "Invoke"
+		};
+	}
+	if (isEdge && field === "guard") return {
+		kind: "entity",
+		id: `guard:${owner.id}`,
+		label: "Guard"
+	};
+	if (isEdge && field === "context") return {
+		kind: "entity",
+		id: `context:${owner.id}`,
+		label: "Context"
+	};
+	if (field === "meta") return {
+		kind: "entity",
+		id: `meta:${owner.id}`,
+		label: "Meta"
+	};
+}
+const implementationBlock = (name, collection, exportInvalid, isValid = isImplementation) => ({
+	name,
+	matches: ({ path }) => path.length === 6 && path[0] === "data" && path[1] === "implementations" && path[2] === collection && typeof path[3] === "number" && path[4] === "code" && path[5] === "body",
+	isValid,
+	exportInvalid,
+	getTarget: (location) => implementationTarget(location, collection)
+});
+const XSTATE_CODE_BLOCKS = [
+	implementationBlock("action implementation", "actions", throwingImplementationBody),
+	implementationBlock("guard implementation", "guards", falseImplementationBody),
+	implementationBlock("actor implementation", "actors", throwingImplementationBody, isAsyncImplementation),
+	implementationBlock("delay implementation", "delays", throwingImplementationBody),
+	{
+		name: "inline guard",
+		matches: (location) => pathEndsWith(location, ["guard", "code"]),
+		isValid: isExpression,
+		exportInvalid: functionFalseExpression,
+		getTarget: entityTarget
+	},
+	{
+		name: "inline action",
+		matches: (location) => {
+			if (!pathEndsWith(location, ["params", "code"])) return false;
+			const owner = location.ancestors.at(-2);
+			return !!owner && typeof owner === "object" && owner.type === "xstate.expr";
+		},
+		isValid: isExpression,
+		exportInvalid: functionThrowingExpression,
+		getTarget: entityTarget,
+		getSourceValue: (location) => {
+			const owner = location.ancestors.at(-2);
+			return owner && typeof owner === "object" ? owner : void 0;
+		}
+	},
+	{
+		name: "code expression",
+		matches: (location) => pathEndsWith(location, ["expr"]) && !!location.parent && typeof location.parent === "object" && location.parent["@type"] === "code",
+		isValid: isExpression,
+		exportInvalid: throwingExpression,
+		getTarget: entityTarget
+	}
+];
+const XSTATE_PROFILE_MANIFESTS = [{
+	profile: XSTATE_V5_PROFILE,
+	namespace: "@statelyai.xstate",
+	lineage: "@statelyai/xstate",
+	projection: XSTATE_V5_PROJECTION,
+	name: "XState v5",
+	formats: [...XSTATE_FORMATS],
+	authoring: XSTATE_AUTHORING,
+	code: { blocks: XSTATE_CODE_BLOCKS },
+	operations: {
+		simulate: true,
+		validate: true,
+		export: true
+	}
+}, {
+	profile: XSTATE_V6_PROFILE,
+	namespace: "@statelyai.xstate",
+	lineage: "@statelyai/xstate",
+	projection: XSTATE_V6_PROJECTION,
+	name: "XState v6 alpha",
+	formats: [...XSTATE_FORMATS],
+	authoring: XSTATE_AUTHORING,
+	code: { blocks: XSTATE_CODE_BLOCKS },
+	operations: {
+		simulate: true,
+		validate: true,
+		export: true
+	}
+}];
+const PROFILE_MANIFESTS = new Map([
+	...XSTATE_PROFILE_MANIFESTS,
+	LANGGRAPH_PROFILE_MANIFEST,
+	ARCHITECTURE_PROFILE_MANIFEST
+].map((manifest) => [manifest.profile, manifest]));
+const colorSchema = _enum([
+	"green",
+	"red",
+	"purple",
+	"blue",
+	"orange",
+	"yellow",
+	"pink",
+	"teal"
+]);
+const stateTypeSchema = _enum([
+	"normal",
+	"parallel",
+	"history",
+	"final"
+]).nullable();
+const actionLocationSchema = union([object({
+	nodeId: string(),
+	group: _enum(["entry", "exit"])
+}), object({
+	edgeId: string(),
+	group: literal("transition")
+})]);
+const createStatePatchSchema = object({
+	op: literal("createState"),
+	description: string().optional(),
+	id: string().optional(),
+	parentId: string(),
+	key: string(),
+	type: stateTypeSchema.optional(),
+	x: number().optional(),
+	y: number().optional(),
+	color: colorSchema.nullable().optional(),
+	initial: boolean().optional()
+});
+const updateStatePatchSchema = object({
+	op: literal("updateState"),
+	description: string().optional(),
+	stateId: string(),
+	key: string().optional(),
+	type: stateTypeSchema.optional(),
+	stateDescription: string().optional(),
+	initialId: string().nullable().optional(),
+	color: colorSchema.nullable().optional(),
+	meta: record(string(), unknown()).nullable().optional(),
+	history: _enum(["shallow", "deep"]).nullable().optional()
+});
+const deleteStatePatchSchema = object({
+	op: literal("deleteState"),
+	description: string().optional(),
+	stateId: string()
+});
+const guardSchema = object({
+	type: string(),
+	code: string().optional(),
+	params: record(string(), unknown()).optional()
+});
+const createTransitionPatchSchema = object({
+	op: literal("createTransition"),
+	description: string().optional(),
+	id: string().optional(),
+	sourceId: string(),
+	targetId: string(),
+	eventType: string(),
+	matches: record(string(), unknown()).optional(),
+	transitionType: _enum([
+		"normal",
+		"targetless",
+		"reenter"
+	]).optional(),
+	guard: guardSchema.optional(),
+	color: colorSchema.nullable().optional(),
+	transitionDescription: string().nullable().optional()
+});
+const updateTransitionPatchSchema = object({
+	op: literal("updateTransition"),
+	description: string().optional(),
+	transitionId: string(),
+	sourceId: string().optional(),
+	targetId: string().optional(),
+	eventType: string().optional(),
+	matches: record(string(), unknown()).optional(),
+	transitionType: _enum([
+		"normal",
+		"targetless",
+		"reenter"
+	]).optional(),
+	transitionDescription: string().nullable().optional(),
+	color: colorSchema.nullable().optional(),
+	meta: record(string(), unknown()).nullable().optional()
+});
+const deleteTransitionPatchSchema = object({
+	op: literal("deleteTransition"),
+	description: string().optional(),
+	transitionId: string()
+});
+const createActionPatchSchema = object({
+	op: literal("createAction"),
+	description: string().optional(),
+	location: actionLocationSchema,
+	action: object({
+		id: string().optional(),
+		type: string(),
+		params: record(string(), unknown()).optional()
+	}),
+	index: number().optional()
+});
+const updateActionPatchSchema = object({
+	op: literal("updateAction"),
+	description: string().optional(),
+	location: actionLocationSchema,
+	actionId: string(),
+	data: object({
+		type: string().optional(),
+		params: record(string(), unknown()).optional()
+	})
+});
+const deleteActionPatchSchema = object({
+	op: literal("deleteAction"),
+	description: string().optional(),
+	location: actionLocationSchema,
+	actionId: string()
+});
+const setGuardPatchSchema = object({
+	op: literal("setGuard"),
+	description: string().optional(),
+	edgeId: string(),
+	guard: guardSchema
+});
+const deleteGuardPatchSchema = object({
+	op: literal("deleteGuard"),
+	description: string().optional(),
+	edgeId: string()
+});
+const machinePatchSchema = discriminatedUnion("op", [
+	createStatePatchSchema,
+	updateStatePatchSchema,
+	deleteStatePatchSchema,
+	createTransitionPatchSchema,
+	updateTransitionPatchSchema,
+	deleteTransitionPatchSchema,
+	createActionPatchSchema,
+	updateActionPatchSchema,
+	deleteActionPatchSchema,
+	setGuardPatchSchema,
+	deleteGuardPatchSchema
+]);
+const validationLevelSchema = _enum([
+	"info",
+	"warning",
+	"error"
+]);
+const validationIssueKindSchema = _enum([
+	"correctness",
+	"reachability",
+	"optimization",
+	"maintainability",
+	"security"
+]);
+const validationIssueCodeSchema = _enum([
+	"parse_error",
+	"unsupported_format",
+	"empty_state_key",
+	"invalid_state_key",
+	"duplicate_state_key",
+	"history_initial",
+	"missing_initial",
+	"invalid_initial",
+	"unreachable_state",
+	"final_state_invokes",
+	"invalid_state_children",
+	"empty_parallel",
+	"single_child_compound",
+	"noop_transient_state",
+	"sole_default_choice",
+	"on_done_unreachable",
+	"duplicate_transition",
+	"invalid_delay",
+	"repeated_guard",
+	"transition_never_taken",
+	"missing_guard",
+	"redundant_transition",
+	"eventless_cycle",
+	"missing_delay_implementation",
+	"invalid_final_transition",
+	"invalid_history_transition",
+	"invalid_choice_event",
+	"parallel_region_transition",
+	"duplicate_source_name",
+	"undefined_action",
+	"undefined_guard",
+	"undefined_actor"
+]);
+const validationFixKindSchema = _enum([
+	"patch",
+	"rewrite",
+	"advice",
+	"proposedPatch"
+]);
+const validationFixSourceSchema = _enum(["deterministic", "llm"]);
+const validationIssueTargetSchema = object({
+	nodeIds: array(string()).optional(),
+	edgeIds: array(string()).optional(),
+	source: object({
+		path: string().optional(),
+		start: number().optional(),
+		end: number().optional()
+	}).optional()
+});
+const validationFixSchema = object({
+	kind: validationFixKindSchema,
+	source: validationFixSourceSchema,
+	title: string(),
+	patches: array(unknown()).optional(),
+	output: unknown().optional(),
+	diff: unknown().optional(),
+	confidence: number().optional(),
+	rationale: string().optional(),
+	rank: number().optional(),
+	postValidation: object({
+		ok: boolean(),
+		remainingIssueCodes: array(validationIssueCodeSchema)
+	}).optional()
+});
+const validationIssueSchema = object({
+	code: validationIssueCodeSchema,
+	kind: validationIssueKindSchema,
+	level: validationLevelSchema,
+	message: string(),
+	target: validationIssueTargetSchema,
+	metadata: record(string(), unknown()).optional(),
+	fixes: array(validationFixSchema).optional(),
+	source: _enum(["deterministic", "llm"]).optional(),
+	nodeIds: array(string()),
+	edgeIds: array(string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/js-yaml@4.2.0/node_modules/js-yaml/dist/js-yaml.mjs
+var import_typescript = /* @__PURE__ */ __toESM$1(require_typescript(), 1);
+/*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function isNothing(subject) {
+		return typeof subject === "undefined" || subject === null;
+	}
+	function isObject(subject) {
+		return typeof subject === "object" && subject !== null;
+	}
+	function toArray(sequence) {
+		if (Array.isArray(sequence)) return sequence;
+		else if (isNothing(sequence)) return [];
+		return [sequence];
+	}
+	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;
+	}
+	function repeat(string, count) {
+		let result = "";
+		for (let cycle = 0; cycle < count; cycle += 1) result += string;
+		return result;
+	}
+	function isNegativeZero(number) {
+		return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+	}
+	module.exports.isNothing = isNothing;
+	module.exports.isObject = isObject;
+	module.exports.toArray = toArray;
+	module.exports.repeat = repeat;
+	module.exports.isNegativeZero = isNegativeZero;
+	module.exports.extend = extend;
+}));
+var require_exception = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function formatError(exception, compact) {
+		let where = "";
+		const message = exception.reason || "(unknown reason)";
+		if (!exception.mark) return message;
+		if (exception.mark.name) where += "in \"" + exception.mark.name + "\" ";
+		where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
+		if (!compact && exception.mark.snippet) where += "\n\n" + exception.mark.snippet;
+		return message + " " + where;
+	}
+	function YAMLException(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 || "";
+	}
+	YAMLException.prototype = Object.create(Error.prototype);
+	YAMLException.prototype.constructor = YAMLException;
+	YAMLException.prototype.toString = function toString(compact) {
+		return this.name + ": " + formatError(this, compact);
+	};
+	module.exports = YAMLException;
+}));
+var require_snippet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	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
+		};
+	}
+	function padStart(string, max) {
+		return common.repeat(" ", max - string.length) + string;
+	}
+	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 line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
+			result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
+		}
+		const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+		result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+		result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
+		for (let i = 1; i <= options.linesAfter; i++) {
+			if (foundLineNo + i >= lineEnds.length) break;
+			const line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
+			result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+		}
+		return result.replace(/\n$/, "");
+	}
+	module.exports = makeSnippet;
+}));
+var require_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var YAMLException = require_exception();
+	var TYPE_CONSTRUCTOR_OPTIONS = [
+		"kind",
+		"multi",
+		"resolve",
+		"construct",
+		"instanceOf",
+		"predicate",
+		"represent",
+		"representName",
+		"defaultStyle",
+		"styleAliases"
+	];
+	var YAML_NODE_KINDS = [
+		"scalar",
+		"sequence",
+		"mapping"
+	];
+	function compileStyleAliases(map) {
+		const result = {};
+		if (map !== null) Object.keys(map).forEach(function(style) {
+			map[style].forEach(function(alias) {
+				result[String(alias)] = style;
+			});
+		});
+		return result;
+	}
+	function Type(tag, options) {
+		options = options || {};
+		Object.keys(options).forEach(function(name) {
+			if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new YAMLException("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 YAMLException("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type.");
+	}
+	module.exports = Type;
+}));
+var require_schema = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var YAMLException = require_exception();
+	var Type = require_type();
+	function compileList(schema, name) {
+		const result = [];
+		schema[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;
+	}
+	function compileMap() {
+		const result = {
+			scalar: {},
+			sequence: {},
+			mapping: {},
+			fallback: {},
+			multi: {
+				scalar: [],
+				sequence: [],
+				mapping: [],
+				fallback: []
+			}
+		};
+		function collectType(type) {
+			if (type.multi) {
+				result.multi[type.kind].push(type);
+				result.multi["fallback"].push(type);
+			} else result[type.kind][type.tag] = result["fallback"][type.tag] = type;
+		}
+		for (let index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
+		return result;
+	}
+	function Schema(definition) {
+		return this.extend(definition);
+	}
+	Schema.prototype.extend = function extend(definition) {
+		let implicit = [];
+		let explicit = [];
+		if (definition instanceof Type) 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 YAMLException("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+		implicit.forEach(function(type) {
+			if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+			if (type.loadKind && type.loadKind !== "scalar") throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+			if (type.multi) throw new YAMLException("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+		});
+		explicit.forEach(function(type) {
+			if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+		});
+		const result = Object.create(Schema.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;
+	};
+	module.exports = Schema;
+}));
+var require_str = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_type())("tag:yaml.org,2002:str", {
+		kind: "scalar",
+		construct: function(data) {
+			return data !== null ? data : "";
+		}
+	});
+}));
+var require_seq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_type())("tag:yaml.org,2002:seq", {
+		kind: "sequence",
+		construct: function(data) {
+			return data !== null ? data : [];
+		}
+	});
+}));
+var require_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_type())("tag:yaml.org,2002:map", {
+		kind: "mapping",
+		construct: function(data) {
+			return data !== null ? data : {};
+		}
+	});
+}));
+var require_failsafe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = new (require_schema())({ explicit: [
+		require_str(),
+		require_seq(),
+		require_map()
+	] });
+}));
+var require_null = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	function resolveYamlNull(data) {
+		if (data === null) return true;
+		const max = data.length;
+		return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
+	}
+	function constructYamlNull() {
+		return null;
+	}
+	function isNull(object) {
+		return object === null;
+	}
+	module.exports = new Type("tag:yaml.org,2002:null", {
+		kind: "scalar",
+		resolve: resolveYamlNull,
+		construct: constructYamlNull,
+		predicate: isNull,
+		represent: {
+			canonical: function() {
+				return "~";
+			},
+			lowercase: function() {
+				return "null";
+			},
+			uppercase: function() {
+				return "NULL";
+			},
+			camelcase: function() {
+				return "Null";
+			},
+			empty: function() {
+				return "";
+			}
+		},
+		defaultStyle: "lowercase"
+	});
+}));
+var require_bool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	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");
+	}
+	function constructYamlBoolean(data) {
+		return data === "true" || data === "True" || data === "TRUE";
+	}
+	function isBoolean(object) {
+		return Object.prototype.toString.call(object) === "[object Boolean]";
+	}
+	module.exports = new Type("tag:yaml.org,2002:bool", {
+		kind: "scalar",
+		resolve: resolveYamlBoolean,
+		construct: constructYamlBoolean,
+		predicate: isBoolean,
+		represent: {
+			lowercase: function(object) {
+				return object ? "true" : "false";
+			},
+			uppercase: function(object) {
+				return object ? "TRUE" : "FALSE";
+			},
+			camelcase: function(object) {
+				return object ? "True" : "False";
+			}
+		},
+		defaultStyle: "lowercase"
+	});
+}));
+var require_int = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var Type = require_type();
+	function isHexCode(c) {
+		return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+	}
+	function isOctCode(c) {
+		return c >= 48 && c <= 55;
+	}
+	function isDecCode(c) {
+		return c >= 48 && c <= 57;
+	}
+	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 && Number.isFinite(parseYamlInteger(data));
+			}
+			if (ch === "x") {
+				index++;
+				for (; index < max; index++) {
+					if (!isHexCode(data.charCodeAt(index))) return false;
+					hasDigits = true;
+				}
+				return hasDigits && Number.isFinite(parseYamlInteger(data));
+			}
+			if (ch === "o") {
+				index++;
+				for (; index < max; index++) {
+					if (!isOctCode(data.charCodeAt(index))) return false;
+					hasDigits = true;
+				}
+				return hasDigits && Number.isFinite(parseYamlInteger(data));
+			}
+		}
+		for (; index < max; index++) {
+			if (!isDecCode(data.charCodeAt(index))) return false;
+			hasDigits = true;
+		}
+		if (!hasDigits) return false;
+		return Number.isFinite(parseYamlInteger(data));
+	}
+	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);
+	}
+	function constructYamlInteger(data) {
+		return parseYamlInteger(data);
+	}
+	function isInteger(object) {
+		return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
+	}
+	module.exports = new Type("tag:yaml.org,2002:int", {
+		kind: "scalar",
+		resolve: resolveYamlInteger,
+		construct: constructYamlInteger,
+		predicate: isInteger,
+		represent: {
+			binary: function(obj) {
+				return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+			},
+			octal: function(obj) {
+				return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+			},
+			decimal: function(obj) {
+				return obj.toString(10);
+			},
+			hexadecimal: function(obj) {
+				return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+			}
+		},
+		defaultStyle: "decimal",
+		styleAliases: {
+			binary: [2, "bin"],
+			octal: [8, "oct"],
+			decimal: [10, "dec"],
+			hexadecimal: [16, "hex"]
+		}
+	});
+}));
+var require_float = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var Type = require_type();
+	var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+	var 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 (Number.isFinite(parseFloat(data, 10))) return true;
+		return YAML_FLOAT_SPECIAL_PATTERN.test(data);
+	}
+	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);
+	}
+	var 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 (common.isNegativeZero(object)) return "-0.0";
+		const res = object.toString(10);
+		return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+	}
+	function isFloat(object) {
+		return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
+	}
+	module.exports = new Type("tag:yaml.org,2002:float", {
+		kind: "scalar",
+		resolve: resolveYamlFloat,
+		construct: constructYamlFloat,
+		predicate: isFloat,
+		represent: representYamlFloat,
+		defaultStyle: "lowercase"
+	});
+}));
+var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_failsafe().extend({ implicit: [
+		require_null(),
+		require_bool(),
+		require_int(),
+		require_float()
+	] });
+}));
+var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_json();
+}));
+var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+	var 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;
+	}
+	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;
+	}
+	function representYamlTimestamp(object) {
+		return object.toISOString();
+	}
+	module.exports = new Type("tag:yaml.org,2002:timestamp", {
+		kind: "scalar",
+		resolve: resolveYamlTimestamp,
+		construct: constructYamlTimestamp,
+		instanceOf: Date,
+		represent: representYamlTimestamp
+	});
+}));
+var require_merge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	function resolveYamlMerge(data) {
+		return data === "<<" || data === null;
+	}
+	module.exports = new Type("tag:yaml.org,2002:merge", {
+		kind: "scalar",
+		resolve: resolveYamlMerge
+	});
+}));
+var require_binary = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+	function resolveYamlBinary(data) {
+		if (data === null) return false;
+		let bitlen = 0;
+		const max = data.length;
+		const map = BASE64_MAP;
+		for (let idx = 0; idx < max; idx++) {
+			const code = map.indexOf(data.charAt(idx));
+			if (code > 64) continue;
+			if (code < 0) return false;
+			bitlen += 6;
+		}
+		return bitlen % 8 === 0;
+	}
+	function constructYamlBinary(data) {
+		const input = data.replace(/[\r\n=]/g, "");
+		const max = input.length;
+		const map = 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 | map.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);
+	}
+	function representYamlBinary(object) {
+		let result = "";
+		let bits = 0;
+		const max = object.length;
+		const map = BASE64_MAP;
+		for (let idx = 0; idx < max; idx++) {
+			if (idx % 3 === 0 && idx) {
+				result += map[bits >> 18 & 63];
+				result += map[bits >> 12 & 63];
+				result += map[bits >> 6 & 63];
+				result += map[bits & 63];
+			}
+			bits = (bits << 8) + object[idx];
+		}
+		const tail = max % 3;
+		if (tail === 0) {
+			result += map[bits >> 18 & 63];
+			result += map[bits >> 12 & 63];
+			result += map[bits >> 6 & 63];
+			result += map[bits & 63];
+		} else if (tail === 2) {
+			result += map[bits >> 10 & 63];
+			result += map[bits >> 4 & 63];
+			result += map[bits << 2 & 63];
+			result += map[64];
+		} else if (tail === 1) {
+			result += map[bits >> 2 & 63];
+			result += map[bits << 4 & 63];
+			result += map[64];
+			result += map[64];
+		}
+		return result;
+	}
+	function isBinary(obj) {
+		return Object.prototype.toString.call(obj) === "[object Uint8Array]";
+	}
+	module.exports = new Type("tag:yaml.org,2002:binary", {
+		kind: "scalar",
+		resolve: resolveYamlBinary,
+		construct: constructYamlBinary,
+		predicate: isBinary,
+		represent: representYamlBinary
+	});
+}));
+var require_omap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	var _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;
+	}
+	function constructYamlOmap(data) {
+		return data !== null ? data : [];
+	}
+	module.exports = new Type("tag:yaml.org,2002:omap", {
+		kind: "sequence",
+		resolve: resolveYamlOmap,
+		construct: constructYamlOmap
+	});
+}));
+var require_pairs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var _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;
+	}
+	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;
+	}
+	module.exports = new Type("tag:yaml.org,2002:pairs", {
+		kind: "sequence",
+		resolve: resolveYamlPairs,
+		construct: constructYamlPairs
+	});
+}));
+var require_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Type = require_type();
+	var _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;
+	}
+	function constructYamlSet(data) {
+		return data !== null ? data : {};
+	}
+	module.exports = new Type("tag:yaml.org,2002:set", {
+		kind: "mapping",
+		resolve: resolveYamlSet,
+		construct: constructYamlSet
+	});
+}));
+var require_default = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_core().extend({
+		implicit: [require_timestamp(), require_merge()],
+		explicit: [
+			require_binary(),
+			require_omap(),
+			require_pairs(),
+			require_set()
+		]
+	});
+}));
+var require_loader = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var YAMLException = require_exception();
+	var makeSnippet = require_snippet();
+	var DEFAULT_SCHEMA = require_default();
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	var CONTEXT_FLOW_IN = 1;
+	var CONTEXT_FLOW_OUT = 2;
+	var CONTEXT_BLOCK_IN = 3;
+	var CONTEXT_BLOCK_OUT = 4;
+	var CHOMPING_CLIP = 1;
+	var CHOMPING_STRIP = 2;
+	var CHOMPING_KEEP = 3;
+	var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+	var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+	var PATTERN_FLOW_INDICATORS = /[,\[\]{}]/;
+	var PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
+	var PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
+	function _class(obj) {
+		return Object.prototype.toString.call(obj);
+	}
+	function isEol(c) {
+		return c === 10 || c === 13;
+	}
+	function isWhiteSpace(c) {
+		return c === 9 || c === 32;
+	}
+	function isWsOrEol(c) {
+		return c === 9 || c === 32 || c === 10 || c === 13;
+	}
+	function isFlowIndicator(c) {
+		return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+	}
+	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;
+	}
+	function escapedHexLen(c) {
+		if (c === 120) return 2;
+		if (c === 117) return 4;
+		if (c === 85) return 8;
+		return 0;
+	}
+	function fromDecimalCode(c) {
+		if (c >= 48 && c <= 57) return c - 48;
+		return -1;
+	}
+	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 "";
+		}
+	}
+	function charFromCodepoint(c) {
+		if (c <= 65535) return String.fromCharCode(c);
+		return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
+	}
+	function setProperty(object, key, value) {
+		if (key === "__proto__") Object.defineProperty(object, key, {
+			configurable: true,
+			enumerable: true,
+			writable: true,
+			value
+		});
+		else object[key] = value;
+	}
+	var simpleEscapeCheck = new Array(256);
+	var 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_SCHEMA;
+		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.maxMergeSeqLength = typeof options["maxMergeSeqLength"] === "number" ? options["maxMergeSeqLength"] : 20;
+		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.firstTabInLine = -1;
+		this.documents = [];
+		this.anchorMapTransactions = [];
+	}
+	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 YAMLException(message, mark);
+	}
+	function throwError(state, message) {
+		throw generateError(state, message);
+	}
+	function throwWarning(state, message) {
+		if (state.onWarning) state.onWarning.call(null, generateError(state, message));
+	}
+	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;
+	}
+	function beginAnchorTransaction(state) {
+		state.anchorMapTransactions.push(Object.create(null));
+	}
+	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];
+		}
+	}
+	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]];
+		}
+	}
+	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
+		};
+	}
+	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;
+	}
+	var directiveHandlers = {
+		YAML: 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");
+		},
+		TAG: 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;
+		}
+	};
+	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;
+		}
+	}
+	function mergeMappings(state, destination, source, overridableKeys) {
+		if (!common.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 (!_hasOwnProperty.call(destination, key)) {
+				setProperty(destination, key, source[key]);
+				overridableKeys[key] = true;
+			}
+		}
+	}
+	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)) {
+			if (valueNode.length > state.maxMergeSeqLength) throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")");
+			const seen = /* @__PURE__ */ new Set();
+			for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+				const src = valueNode[index];
+				if (seen.has(src)) continue;
+				seen.add(src);
+				mergeMappings(state, _result, src, 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;
+	}
+	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;
+	}
+	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;
+	}
+	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;
+	}
+	function writeFoldedLines(state, count) {
+		if (count === 1) state.result += " ";
+		else if (count > 1) state.result += common.repeat("\n", count - 1);
+	}
+	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;
+	}
+	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");
+	}
+	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");
+	}
+	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 = 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");
+	}
+	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 += common.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 += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+			} else if (atMoreIndented) {
+				atMoreIndented = false;
+				state.result += common.repeat("\n", emptyLines + 1);
+			} else if (emptyLines === 0) {
+				if (didReadContent) state.result += " ";
+			} else state.result += common.repeat("\n", emptyLines);
+			else state.result += common.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;
+	}
+	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;
+	}
+	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 = 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;
+	}
+	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;
+	}
+	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;
+	}
+	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;
+	}
+	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;
+	}
+	function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+		let allowBlockScalars;
+		let allowBlockCollections;
+		let indentStatus = 1;
+		let atNewLine = false;
+		let hasContent = false;
+		let propertyStart = null;
+		let type;
+		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) {
+				type = state.implicitTypes[typeIndex];
+				if (type.resolve(state.result)) {
+					state.result = type.construct(state.result);
+					state.tag = type.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)) type = state.typeMap[state.kind || "fallback"][state.tag];
+			else {
+				type = 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) {
+					type = typeList[typeIndex];
+					break;
+				}
+			}
+			if (!type) throwError(state, "unknown tag !<" + state.tag + ">");
+			if (state.result !== null && type.kind !== state.kind) throwError(state, "unacceptable node kind for !<" + state.tag + "> tag; it should be \"" + type.kind + "\", not \"" + state.kind + "\"");
+			if (!type.resolve(state.result, state.tag)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+			else {
+				state.result = type.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;
+	}
+	function readDocument(state) {
+		const documentStart = state.position;
+		let hasDirectives = false;
+		let ch;
+		state.version = null;
+		state.checkLineBreaks = state.legacy;
+		state.tagMap = Object.create(null);
+		state.anchorMap = 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");
+	}
+	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;
+	}
+	function loadAll(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]);
+	}
+	function load(input, options) {
+		const documents = loadDocuments(input, options);
+		if (documents.length === 0) return;
+		else if (documents.length === 1) return documents[0];
+		throw new YAMLException("expected a single document in the stream, but found more");
+	}
+	module.exports.loadAll = loadAll;
+	module.exports.load = load;
+}));
+var require_dumper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var common = require_common();
+	var YAMLException = require_exception();
+	var DEFAULT_SCHEMA = require_default();
+	var _toString = Object.prototype.toString;
+	var _hasOwnProperty = Object.prototype.hasOwnProperty;
+	var CHAR_BOM = 65279;
+	var CHAR_TAB = 9;
+	var CHAR_LINE_FEED = 10;
+	var CHAR_CARRIAGE_RETURN = 13;
+	var CHAR_SPACE = 32;
+	var CHAR_EXCLAMATION = 33;
+	var CHAR_DOUBLE_QUOTE = 34;
+	var CHAR_SHARP = 35;
+	var CHAR_PERCENT = 37;
+	var CHAR_AMPERSAND = 38;
+	var CHAR_SINGLE_QUOTE = 39;
+	var CHAR_ASTERISK = 42;
+	var CHAR_COMMA = 44;
+	var CHAR_MINUS = 45;
+	var CHAR_COLON = 58;
+	var CHAR_EQUALS = 61;
+	var CHAR_GREATER_THAN = 62;
+	var CHAR_QUESTION = 63;
+	var CHAR_COMMERCIAL_AT = 64;
+	var CHAR_LEFT_SQUARE_BRACKET = 91;
+	var CHAR_RIGHT_SQUARE_BRACKET = 93;
+	var CHAR_GRAVE_ACCENT = 96;
+	var CHAR_LEFT_CURLY_BRACKET = 123;
+	var CHAR_VERTICAL_LINE = 124;
+	var CHAR_RIGHT_CURLY_BRACKET = 125;
+	var 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";
+	var DEPRECATED_BOOLEANS_SYNTAX = [
+		"y",
+		"Y",
+		"yes",
+		"Yes",
+		"YES",
+		"on",
+		"On",
+		"ON",
+		"n",
+		"N",
+		"no",
+		"No",
+		"NO",
+		"off",
+		"Off",
+		"OFF"
+	];
+	var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+	function compileStyleMap(schema, map) {
+		if (map === null) return {};
+		const result = {};
+		const keys = Object.keys(map);
+		for (let index = 0, length = keys.length; index < length; index += 1) {
+			let tag = keys[index];
+			let style = String(map[tag]);
+			if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
+			const type = schema.compiledTypeMap["fallback"][tag];
+			if (type && _hasOwnProperty.call(type.styleAliases, style)) style = type.styleAliases[style];
+			result[tag] = style;
+		}
+		return result;
+	}
+	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 YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
+		return "\\" + handle + common.repeat("0", length - string.length) + string;
+	}
+	var QUOTING_TYPE_SINGLE = 1;
+	var QUOTING_TYPE_DOUBLE = 2;
+	function State(options) {
+		this.schema = options["schema"] || DEFAULT_SCHEMA;
+		this.indent = Math.max(1, options["indent"] || 2);
+		this.noArrayIndent = options["noArrayIndent"] || false;
+		this.skipInvalid = options["skipInvalid"] || false;
+		this.flowLevel = common.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;
+	}
+	function indentString(string, spaces) {
+		const ind = common.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;
+	}
+	function generateNextLine(state, level) {
+		return "\n" + common.repeat(" ", state.indent * level);
+	}
+	function testImplicitResolving(state, str) {
+		for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) if (state.implicitTypes[index].resolve(str)) return true;
+		return false;
+	}
+	function isWhitespace(c) {
+		return c === CHAR_SPACE || c === CHAR_TAB;
+	}
+	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;
+	}
+	function isNsCharOrWhitespace(c) {
+		return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+	}
+	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;
+	}
+	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;
+	}
+	function isPlainSafeLast(c) {
+		return !isWhitespace(c) && c !== CHAR_COLON;
+	}
+	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;
+	}
+	function needIndentIndicator(string) {
+		return /^\n* /.test(string);
+	}
+	var STYLE_PLAIN = 1;
+	var STYLE_SINGLE = 2;
+	var STYLE_LITERAL = 3;
+	var STYLE_FOLDED = 4;
+	var 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;
+	}
+	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(string) {
+				return testImplicitResolving(state, string);
+			}
+			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, lineWidth) + "\"";
+				default: throw new YAMLException("impossible error: invalid scalar style");
+			}
+		}();
+	}
+	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";
+	}
+	function dropEndingNewline(string) {
+		return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
+	}
+	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;
+	}
+	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);
+	}
+	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;
+	}
+	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 + "]";
+	}
+	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 || "[]";
+	}
+	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 + "}";
+	}
+	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 YAMLException("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 || "{}";
+	}
+	function detectType(state, object, explicit) {
+		const typeList = explicit ? state.explicitTypes : state.implicitTypes;
+		for (let index = 0, length = typeList.length; index < length; index += 1) {
+			const type = typeList[index];
+			if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
+				if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
+				else state.tag = type.tag;
+				else state.tag = "?";
+				if (type.represent) {
+					const style = state.styleMap[type.tag] || type.defaultStyle;
+					let _result;
+					if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
+					else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
+					else throw new YAMLException("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
+					state.dump = _result;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+	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 type = _toString.call(state.dump);
+		const inblock = block;
+		if (block) block = state.flowLevel < 0 || state.flowLevel > level;
+		const objectOrArray = type === "[object Object]" || type === "[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 (type === "[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 (type === "[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 (type === "[object String]") {
+				if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
+			} else if (type === "[object Undefined]") return false;
+			else {
+				if (state.skipInvalid) return false;
+				throw new YAMLException("unacceptable kind of an object to dump " + type);
+			}
+			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;
+	}
+	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);
+	}
+	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);
+				}
+			}
+		}
+	}
+	function dump(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 "";
+	}
+	module.exports.dump = dump;
+}));
+var import_js_yaml = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var loader = require_loader();
+	var dumper = require_dumper();
+	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.");
+		};
+	}
+	module.exports.Type = require_type();
+	module.exports.Schema = require_schema();
+	module.exports.FAILSAFE_SCHEMA = require_failsafe();
+	module.exports.JSON_SCHEMA = require_json();
+	module.exports.CORE_SCHEMA = require_core();
+	module.exports.DEFAULT_SCHEMA = require_default();
+	module.exports.load = loader.load;
+	module.exports.loadAll = loader.loadAll;
+	module.exports.dump = dumper.dump;
+	module.exports.YAMLException = require_exception();
+	module.exports.types = {
+		binary: require_binary(),
+		float: require_float(),
+		map: require_map(),
+		null: require_null(),
+		pairs: require_pairs(),
+		set: require_set(),
+		timestamp: require_timestamp(),
+		bool: require_bool(),
+		int: require_int(),
+		merge: require_merge(),
+		omap: require_omap(),
+		seq: require_seq(),
+		str: require_str()
+	};
+	module.exports.safeLoad = renamed("safeLoad", "load");
+	module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
+	module.exports.safeDump = renamed("safeDump", "dump");
+})))(), 1);
+var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
+var index_vite_proxy_tmp_default = import_js_yaml.default;
+
+//#endregion
+//#region ../graph-tools/dist/typescript.mjs
+function hasNoTypeScriptParseErrors(source) {
+	return (import_typescript.default.createSourceFile("profile-code.ts", source, import_typescript.default.ScriptTarget.Latest, false, import_typescript.default.ScriptKind.TS).parseDiagnostics?.length ?? 0) === 0;
+}
+/** Validates profile code blocks with the TypeScript parser. */
+function installTypeScriptProfileCodeSyntax() {
+	setProfileCodeSyntaxChecker(hasNoTypeScriptParseErrors);
+}
+/** Map from xstate action type to the import name */
+const BUILTIN_ACTION_IMPORTS = {
+	"xstate.raise": "raise",
+	"xstate.sendTo": "sendTo",
+	"xstate.cancel": "cancel",
+	"xstate.emit": "emit",
+	"xstate.spawnChild": "spawnChild",
+	"xstate.stopChild": "stopChild",
+	"xstate.log": "log",
+	"xstate.assign": "assign",
+	"xstate.choose": "enqueueActions"
+};
+const XSTATE_ACTOR_LOGIC_HELPERS = new Set([
+	"createMachine",
+	"createAsyncLogic",
+	"createCallbackLogic",
+	"createEventObservableLogic",
+	"createListenerLogic",
+	"createLogic",
+	"createObservableLogic",
+	"createSubscriptionLogic",
+	"fromPromise",
+	"fromCallback",
+	"fromObservable",
+	"fromEventObservable",
+	"fromTransition"
+]);
+const XSTATE_IMPLEMENTATION_HELPERS = new Set([
+	...Object.values(BUILTIN_ACTION_IMPORTS),
+	"enqueueActions",
+	"sendParent",
+	"forwardTo",
+	"stop",
+	"and",
+	"or",
+	"not",
+	"stateIn",
+	...XSTATE_ACTOR_LOGIC_HELPERS
+]);
+const machineFormatSchema = _enum([
+	"xstate",
+	"json",
+	"yaml",
+	"scxml",
+	"mermaid"
+]);
+const canonicalMachineProfileSchema = custom((value) => typeof value === "string" && /^@statelyai\/xstate@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value), "Expected an exact @statelyai/xstate profile reference.");
+const xstateSourceProfileSchema = union([
+	literal("auto"),
+	_enum(LEGACY_MACHINE_PROFILES),
+	canonicalMachineProfileSchema
+]);
+const machineInputSchema = object({
+	machine: union([record(string(), unknown()), string()]),
+	format: machineFormatSchema.optional(),
+	profile: xstateSourceProfileSchema.optional(),
+	xstateVersion: union([literal(5), literal(6)]).optional()
+});
+const graphSchema = record(string(), unknown());
+const convertMachineFormatInputSchema = object({
+	machine: union([record(string(), unknown()), string()]).optional(),
+	graph: graphSchema.optional(),
+	format: machineFormatSchema.optional(),
+	to: machineFormatSchema
+}).refine((value) => Boolean(value.machine) !== Boolean(value.graph), { message: "Provide exactly one of machine or graph." });
+const applyMachinePatchesInputSchema = object({
+	graph: graphSchema,
+	patches: array(machinePatchSchema),
+	outputFormat: machineFormatSchema.default("json")
+});
+const diffMachinesInputSchema = object({
+	left: machineInputSchema,
+	right: machineInputSchema,
+	includePatches: boolean().optional()
+});
+const generateMachinePathsInputSchema = machineInputSchema.extend({
+	targetPath: array(string()).optional(),
+	kind: _enum(["shortest", "simple"]).default("shortest"),
+	max: number().int().positive().optional()
+});
+const simulateMachineStepInputSchema = machineInputSchema.extend({
+	stateValue: unknown(),
+	event: object({ type: string() }).passthrough(),
+	guardState: record(string(), boolean()).optional()
+});
+const SOURCE_COVERAGE_META = "@statelyai.sourceCoverage";
+async function sourceHash(source) {
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(source));
+	return Array.from(new Uint8Array(digest), (n) => n.toString(16).padStart(2, "0")).join("");
+}
+function analyze(source) {
+	const analysis = getXStateSourceCoverageAnalysis(source);
+	const diagnostics = [...analysis.diagnostics];
+	const obligations = [];
+	const sites = /* @__PURE__ */ new Map();
+	const wrappers = /* @__PURE__ */ new Map();
+	const implicit = /* @__PURE__ */ new Map();
+	const identifiers = /* @__PURE__ */ new Set();
+	const collect = (node) => {
+		if (import_typescript.default.isIdentifier(node)) identifiers.add(node.text);
+		import_typescript.default.forEachChild(node, collect);
+	};
+	collect(analysis.file);
+	let controlName = "__xstateSourceCoverage";
+	while (identifiers.has(controlName)) controlName += "_";
+	for (const entry of analysis.entries) {
+		const scope = JSON.stringify([entry.machineIndex, entry.path]);
+		wrappers.set(entry.node, {
+			scope,
+			mode: entry.mode
+		});
+		const byId = /* @__PURE__ */ new Map();
+		for (const branch of entry.branches) {
+			const value = branch.result;
+			const origin = branch.origin ?? branch.fallthrough ?? entry.fn?.body ?? entry.node;
+			const siteId = entry.mode === "static" ? "static" : branch.shortCircuit === "and" ? `${origin.getStart()}-${origin.end}:false` : branch.origin ? `${origin.getStart()}-${origin.end}` : `${origin.end}:fallthrough`;
+			const id = `${scope}#${siteId}`;
+			const target = typeof value === "string" && entry.mode === "static" ? value : value?.target;
+			const targets = target === void 0 ? [] : Array.isArray(target) ? target : [target];
+			if (branch.unknown || isCodeExpression(value) || targets.some((item) => typeof item !== "string") || entry.mode === "function" && value !== void 0 && (!value || typeof value !== "object" || Array.isArray(value))) {
+				diagnostics.push({
+					code: "unresolved-outcome",
+					path: entry.path,
+					message: "A returned outcome or destination cannot be completely enumerated.",
+					start: origin.getStart(),
+					end: origin.end
+				});
+				continue;
+			}
+			const kind = targets.length ? "transition" : value === void 0 && !branch.actions.length && !branch.contextUpdates ? "refusal" : "targetless";
+			const predicates = branch.conds.map((condition) => condition.negated ? `!(${condition.text})` : condition.text);
+			const existing = byId.get(id);
+			if (existing) {
+				if (existing.kind !== kind || JSON.stringify(existing.targets) !== JSON.stringify(targets)) diagnostics.push({
+					code: "ambiguous-outcome-site",
+					path: entry.path,
+					message: "A shared return site resolves to different outcomes that cannot be distinguished by instrumentation.",
+					start: origin.getStart(),
+					end: origin.end
+				});
+				existing.predicates.push(predicates);
+				continue;
+			}
+			const position = analysis.file.getLineAndCharacterOfPosition(origin.getStart());
+			const obligation = {
+				id,
+				machineIndex: entry.machineIndex,
+				path: entry.path,
+				eventType: entry.eventType,
+				kind,
+				targets,
+				predicates: [predicates],
+				location: {
+					start: origin.getStart(),
+					end: origin.end,
+					line: position.line + 1,
+					column: position.character + 1
+				}
+			};
+			byId.set(id, obligation);
+			obligations.push(obligation);
+			if (entry.mode === "function") if (!branch.origin && (branch.fallthrough ?? entry.fn?.body)) implicit.set(branch.fallthrough ?? entry.fn.body, siteId);
+			else sites.set(origin, {
+				siteId,
+				kind: branch.shortCircuit === "and" ? "and" : import_typescript.default.isReturnStatement(origin) ? "empty-return" : "value"
+			});
+		}
+	}
+	const uniqueDiagnostics = [...new Map(diagnostics.map((d) => [`${d.code}:${d.path}:${d.start}:${d.end}`, d])).values()];
+	return {
+		...analysis,
+		obligations,
+		diagnostics: uniqueDiagnostics,
+		sites,
+		wrappers,
+		implicit,
+		controlName
+	};
+}
+/** Extracts all supported outcomes; unresolved syntax prevents completeness. */
+async function extractXStateSourceCoverage(source, options = {}) {
+	const analysis = analyze(source);
+	return {
+		schemaVersion: 1,
+		criterion: "transition-outcomes",
+		source: {
+			fileName: options.fileName ?? "machine.ts",
+			hash: await sourceHash(source),
+			algorithm: "SHA-256"
+		},
+		extractor: "stately-source-coverage/1",
+		complete: analysis.diagnostics.length === 0,
+		machineCount: analysis.machineCount,
+		obligations: analysis.obligations,
+		diagnostics: analysis.diagnostics
+	};
+}
+/**
+* Adds file-local instrumentation without evaluating source. The host imports
+* the returned control export and installs an observer during synchronous
+* transition calculation. No globals or shared process-wide recorder are used.
+*/
+async function instrumentXStateSourceCoverage(source, options = {}) {
+	const manifest = await extractXStateSourceCoverage(source, options);
+	const analysis = analyze(source);
+	if (!manifest.complete) throw Object.assign(/* @__PURE__ */ new Error("Complete source extraction is required before instrumentation."), { diagnostics: manifest.diagnostics });
+	if (analysis.entries.some((entry) => entry.mode === "static" && entry.branches.some((branch) => typeof branch.result === "string"))) throw new Error("Source instrumentation requires v6 object transitions; string transitions belong to v5.");
+	const name = analysis.controlName;
+	const prelude = `
+export const ${name} = {
+  observer: undefined as undefined | ((id: string) => void),
+  faults: 0,
+  ids: new Set(${JSON.stringify(manifest.obligations.map((obligation) => obligation.id))}),
+  scope: undefined as string | undefined,
+  hit<T>(site: string, value: T): T {
+    if (this.scope !== undefined) {
+      const id = this.scope + '#' + site;
+      if (this.ids.has(id)) {
+        try { this.observer?.(id); } catch { this.faults++; }
+      }
+    }
+    return value;
+  },
+  and<T, U>(site: string, left: T, right: () => U): T | U {
+    return left ? right() : this.hit(site, left);
+  },
+  wrap<T extends (...args: any[]) => any>(scope: string, fn: T): T {
+    const control = this;
+    return function(this: unknown, ...args: any[]) {
+      const previous = control.scope; control.scope = scope;
+      try { return fn.apply(this, args); } finally { control.scope = previous; }
+    } as T;
+  },
+  static(scope: string, value: any): any {
+    const config = typeof value === 'string' ? { target: value } : value;
+    return { ...config, [Symbol.for(${JSON.stringify(SOURCE_COVERAGE_META)})]: scope + '#static' };
+  }
+};`;
+	const control = import_typescript.default.factory.createIdentifier(name);
+	const invoke = (method, args) => import_typescript.default.factory.createCallExpression(import_typescript.default.factory.createPropertyAccessExpression(control, method), void 0, args);
+	const transformed = import_typescript.default.transform(analysis.file, [(context) => (root) => {
+		const visit = (original) => {
+			let node = import_typescript.default.visitEachChild(original, visit, context);
+			const site = analysis.sites.get(original);
+			if (site?.kind === "empty-return" && import_typescript.default.isReturnStatement(node)) node = import_typescript.default.factory.updateReturnStatement(node, invoke("hit", [import_typescript.default.factory.createStringLiteral(site.siteId), import_typescript.default.factory.createVoidZero()]));
+			else if (site?.kind === "and" && import_typescript.default.isBinaryExpression(node)) node = invoke("and", [
+				import_typescript.default.factory.createStringLiteral(site.siteId),
+				node.left,
+				import_typescript.default.factory.createArrowFunction(void 0, void 0, [], void 0, import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken), node.right)
+			]);
+			else if (site?.kind === "value" && import_typescript.default.isExpression(node)) node = invoke("hit", [import_typescript.default.factory.createStringLiteral(site.siteId), node]);
+			const fallthrough = analysis.implicit.get(original);
+			if (fallthrough && import_typescript.default.isBlock(node)) node = import_typescript.default.factory.updateBlock(node, [...node.statements, import_typescript.default.factory.createExpressionStatement(invoke("hit", [import_typescript.default.factory.createStringLiteral(fallthrough), import_typescript.default.factory.createVoidZero()]))]);
+			const wrapper = analysis.wrappers.get(original);
+			if (wrapper && import_typescript.default.isExpression(node)) node = invoke(wrapper.mode === "static" ? "static" : "wrap", [import_typescript.default.factory.createStringLiteral(wrapper.scope), node]);
+			return node;
+		};
+		return import_typescript.default.visitNode(root, visit);
+	}]);
+	try {
+		return {
+			manifest,
+			controlExport: name,
+			source: prelude + "\n" + import_typescript.default.createPrinter().printFile(transformed.transformed[0]),
+			metadataKey: SOURCE_COVERAGE_META
+		};
+	} finally {
+		transformed.dispose();
+	}
+}
+/** Produces a source-linked coverage graph that the existing Viz canvas can render. */
+async function createXStateSourceCoverageGraph(source, report, options = {}) {
+	const { extractXStateMachineConfigEntries, detectXStateSourceProfile } = await import("./xstateSource-JvwXWv6G-KnMMoZlG.mjs").then((n) => n.r).then((n) => n.c);
+	const { machineConfigToGraph } = await import("./machineGraph-DYtFKHlq-BpWpGU22.mjs").then((n) => n.i);
+	const manifest = await extractXStateSourceCoverage(source, options);
+	if (report && report.sourceHash !== manifest.source.hash) throw new Error("Coverage report source revision does not match this graph.");
+	const analysis = analyze(source);
+	const machineIndex = options.machineIndex ?? 0;
+	const config = extractXStateMachineConfigEntries(source, { includeNested: true }).find((entry) => entry.machineIndex === machineIndex)?.config;
+	if (!config) throw new Error(`Machine ${machineIndex} was not found.`);
+	const lookup = (path) => {
+		const keys = path.split("/").slice(1).map((key) => key.replaceAll("~1", "/").replaceAll("~0", "~"));
+		let parent = config;
+		for (const [index, key] of keys.entries()) {
+			if (index === keys.length - 1) return parent ? {
+				parent,
+				key
+			} : void 0;
+			if (key === "0" && !Array.isArray(parent)) continue;
+			parent = parent?.[key];
+		}
+	};
+	for (const entry of analysis.entries.filter((entry) => entry.machineIndex === machineIndex)) {
+		const slot = lookup(entry.path.endsWith("/to") ? entry.path.slice(0, -3) : entry.path);
+		if (!slot) continue;
+		const branches = entry.mode === "function" ? entry.branches.map((branch) => getXStateCoverageBranchProjection(branch, entry.fn)).filter(Boolean) : Array.isArray(slot.parent[slot.key]) ? slot.parent[slot.key] : [slot.parent[slot.key]];
+		const sourceBranches = entry.branches.filter((branch) => branch.result !== void 0 || branch.actions.length || branch.contextUpdates);
+		if (branches.length !== sourceBranches.length) continue;
+		const scope = JSON.stringify([entry.machineIndex, entry.path]);
+		slot.parent[slot.key] = branches.map((branch, index) => {
+			if (!branch) return branch;
+			const sourceBranch = sourceBranches[index];
+			const origin = sourceBranch.origin ?? sourceBranch.fallthrough ?? entry.fn?.body ?? entry.node;
+			const id = `${scope}#${entry.mode === "static" ? "static" : sourceBranch.shortCircuit === "and" ? `${origin.getStart()}-${origin.end}:false` : sourceBranch.origin ? `${origin.getStart()}-${origin.end}` : `${origin.end}:fallthrough`}`;
+			const object = typeof branch === "string" ? { target: branch } : branch;
+			return {
+				...object,
+				meta: {
+					...object.meta,
+					[SOURCE_COVERAGE_META]: id
+				}
+			};
+		});
+		if (!Array.isArray(branches) || branches.length === 1) slot.parent[slot.key] = slot.parent[slot.key][0];
+	}
+	const graph = machineConfigToGraph(config, { profile: options.profile ?? detectXStateSourceProfile(source) });
+	for (const edge of graph.edges) {
+		const id = edge.data.meta?.[SOURCE_COVERAGE_META];
+		if (typeof id !== "string" || !report) continue;
+		const covered = report.covered.includes(id);
+		edge.data.color = covered ? "#15803d" : "#b91c1c";
+		edge.data.meta = {
+			...edge.data.meta,
+			"@statelyai.coverage": {
+				outcomeId: id,
+				covered,
+				witnessCount: report.counts[id] ?? 0
+			}
+		};
+	}
+	graph.data = {
+		...graph.data,
+		sourceCoverage: {
+			sourceHash: manifest.source.hash,
+			extractionComplete: manifest.complete,
+			diagnostics: manifest.diagnostics,
+			refusals: manifest.obligations.filter((o) => o.machineIndex === machineIndex && o.kind === "refusal").map((o) => ({
+				...o,
+				covered: report?.covered.includes(o.id) ?? false
+			}))
+		}
+	};
+	return {
+		manifest,
+		graph
+	};
+}
+/** Boundary suggestions, not evidence: every candidate still needs execution. */
+function getXStateSourceCoverageEventCases(manifest, state, seeds) {
+	const cases = [...seeds];
+	for (const obligation of manifest.obligations) for (const conditions of obligation.predicates) for (const condition of conditions) {
+		const file = import_typescript.default.createSourceFile("predicate.ts", condition, import_typescript.default.ScriptTarget.Latest, true);
+		const literal = (node) => {
+			if (import_typescript.default.isNumericLiteral(node)) return Number(node.text);
+			if (import_typescript.default.isStringLiteral(node)) return node.text;
+			if (node.kind === import_typescript.default.SyntaxKind.TrueKeyword) return true;
+			if (node.kind === import_typescript.default.SyntaxKind.FalseKeyword) return false;
+			if (import_typescript.default.isPropertyAccessExpression(node) && import_typescript.default.isIdentifier(node.expression) && node.expression.text === "context") return state.context?.[node.name.text];
+		};
+		const visit = (node) => {
+			if (import_typescript.default.isBinaryExpression(node)) for (const [field, value] of [[node.left, node.right], [node.right, node.left]]) {
+				if (!import_typescript.default.isPropertyAccessExpression(field) || !import_typescript.default.isIdentifier(field.expression) || field.expression.text !== "event") continue;
+				const boundary = literal(value);
+				const values = typeof boundary === "number" ? [
+					boundary,
+					boundary - 1,
+					boundary + 1
+				] : typeof boundary === "boolean" ? [boundary, !boundary] : typeof boundary === "string" ? [boundary] : [];
+				for (const seed of seeds.filter((seed) => seed.type === obligation.eventType)) for (const value of values) cases.push({
+					...seed,
+					[field.name.text]: value
+				});
+			}
+			import_typescript.default.forEachChild(node, visit);
+		};
+		visit(file);
+	}
+	return [...new Map(cases.map((event) => [JSON.stringify(event), event])).values()];
+}
+/**
+* TypeScript-compiler-backed graph tools: XState code generation, XState
+* source parsing, profile detection, and machine format conversion.
+*
+* Kept out of the main entry so browser bundles only load the TypeScript
+* compiler when they need it. Loading this entry also validates profile code
+* blocks with the TypeScript parser.
+*/
+installTypeScriptProfileCodeSyntax();
+
+//#endregion
+export { createXStateSourceCoverageGraph, extractXStateSourceCoverage, getXStateSourceCoverageEventCases, instrumentXStateSourceCoverage };