@powerhousedao/codegen 6.0.0-dev.151 → 6.0.0-dev.153

package/dist/{templates-Bn7kq5sb.mjs → templates-Cu_xr8aR.mjs}

@@ -1,6 +1,1770 @@
 import { getActionInputName, getActionInputTypeNames, getActionType, getActionTypeName } from "./src/name-builders/index.mjs";
 import { camelCase, capitalCase, constantCase, kebabCase, pascalCase } from "change-case";
-import { css, html, js, json, md, ts, tsx, yaml } from "@tmpl/core";
+function isEOL(c) {
+	return c === 10 || c === 13;
+}
+function isWhiteSpace(c) {
+	return c === 9 || c === 32;
+}
+function isWhiteSpaceOrEOL(c) {
+	return isWhiteSpace(c) || isEOL(c);
+}
+function isFlowIndicator(c) {
+	return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/binary.js
+const BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+function resolveYamlBinary(data) {
+	if (data === null) return false;
+	let code;
+	let bitlen = 0;
+	const max = data.length;
+	const map = BASE64_MAP;
+	for (let idx = 0; idx < max; idx++) {
+		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;
+	const result = [];
+	let bits = 0;
+	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) {
+	const max = object.length;
+	const map = BASE64_MAP;
+	let result = "";
+	let bits = 0;
+	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 obj instanceof Uint8Array;
+}
+const binary = {
+	tag: "tag:yaml.org,2002:binary",
+	construct: constructYamlBinary,
+	kind: "scalar",
+	predicate: isBinary,
+	represent: representYamlBinary,
+	resolve: resolveYamlBinary
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/bool.js
+const YAML_TRUE_BOOLEANS = [
+	"true",
+	"True",
+	"TRUE"
+];
+const YAML_FALSE_BOOLEANS = [
+	"false",
+	"False",
+	"FALSE"
+];
+const YAML_BOOLEANS = [...YAML_TRUE_BOOLEANS, ...YAML_FALSE_BOOLEANS];
+const bool = {
+	tag: "tag:yaml.org,2002:bool",
+	kind: "scalar",
+	defaultStyle: "lowercase",
+	predicate: (value) => typeof value === "boolean" || value instanceof Boolean,
+	construct: (data) => YAML_TRUE_BOOLEANS.includes(data),
+	resolve: (data) => YAML_BOOLEANS.includes(data),
+	represent: {
+		lowercase: (object) => {
+			return (object instanceof Boolean ? object.valueOf() : object) ? "true" : "false";
+		},
+		uppercase: (object) => {
+			return (object instanceof Boolean ? object.valueOf() : object) ? "TRUE" : "FALSE";
+		},
+		camelcase: (object) => {
+			return (object instanceof Boolean ? object.valueOf() : object) ? "True" : "False";
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_utils.js
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+function isNegativeZero(i) {
+	return i === 0 && Number.NEGATIVE_INFINITY === 1 / i;
+}
+function isPlainObject(object) {
+	return Object.prototype.toString.call(object) === "[object Object]";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/float.js
+const YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat(data) {
+	if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") return false;
+	return true;
+}
+function constructYamlFloat(data) {
+	let value = data.replace(/_/g, "").toLowerCase();
+	const sign = value[0] === "-" ? -1 : 1;
+	if (value[0] && "+-".includes(value[0])) value = value.slice(1);
+	if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+	if (value === ".nan") return NaN;
+	return sign * parseFloat(value);
+}
+const SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+function representYamlFloat(object, style) {
+	const value = object instanceof Number ? object.valueOf() : object;
+	if (isNaN(value)) switch (style) {
+		case "lowercase": return ".nan";
+		case "uppercase": return ".NAN";
+		case "camelcase": return ".NaN";
+	}
+	else if (Number.POSITIVE_INFINITY === value) switch (style) {
+		case "lowercase": return ".inf";
+		case "uppercase": return ".INF";
+		case "camelcase": return ".Inf";
+	}
+	else if (Number.NEGATIVE_INFINITY === value) switch (style) {
+		case "lowercase": return "-.inf";
+		case "uppercase": return "-.INF";
+		case "camelcase": return "-.Inf";
+	}
+	else if (isNegativeZero(value)) return "-0.0";
+	const res = value.toString(10);
+	return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+}
+function isFloat(object) {
+	if (object instanceof Number) object = object.valueOf();
+	return typeof object === "number" && (object % 1 !== 0 || isNegativeZero(object));
+}
+const float = {
+	tag: "tag:yaml.org,2002:float",
+	construct: constructYamlFloat,
+	defaultStyle: "lowercase",
+	kind: "scalar",
+	predicate: isFloat,
+	represent: representYamlFloat,
+	resolve: resolveYamlFloat
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/int.js
+function isCharCodeInRange(c, lower, upper) {
+	return lower <= c && c <= upper;
+}
+function isHexCode(c) {
+	return isCharCodeInRange(c, 48, 57) || isCharCodeInRange(c, 65, 70) || isCharCodeInRange(c, 97, 102);
+}
+function isOctCode(c) {
+	return isCharCodeInRange(c, 48, 55);
+}
+function isDecCode(c) {
+	return isCharCodeInRange(c, 48, 57);
+}
+function resolveYamlInteger(data) {
+	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 === "_") continue;
+				if (ch !== "0" && ch !== "1") return false;
+				hasDigits = true;
+			}
+			return hasDigits && ch !== "_";
+		}
+		if (ch === "x") {
+			index++;
+			for (; index < max; index++) {
+				ch = data[index];
+				if (ch === "_") continue;
+				if (!isHexCode(data.charCodeAt(index))) return false;
+				hasDigits = true;
+			}
+			return hasDigits && ch !== "_";
+		}
+		for (; index < max; index++) {
+			ch = data[index];
+			if (ch === "_") continue;
+			if (!isOctCode(data.charCodeAt(index))) return false;
+			hasDigits = true;
+		}
+		return hasDigits && ch !== "_";
+	}
+	if (ch === "_") return false;
+	for (; index < max; index++) {
+		ch = data[index];
+		if (ch === "_") continue;
+		if (!isDecCode(data.charCodeAt(index))) return false;
+		hasDigits = true;
+	}
+	if (!hasDigits || ch === "_") return false;
+	return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+}
+function constructYamlInteger(data) {
+	let value = data;
+	if (value.includes("_")) value = value.replace(/_/g, "");
+	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, 16);
+		return sign * parseInt(value, 8);
+	}
+	return sign * parseInt(value, 10);
+}
+function isInteger(object) {
+	if (object instanceof Number) object = object.valueOf();
+	return typeof object === "number" && object % 1 === 0 && !isNegativeZero(object);
+}
+const int = {
+	tag: "tag:yaml.org,2002:int",
+	construct: constructYamlInteger,
+	defaultStyle: "decimal",
+	kind: "scalar",
+	predicate: isInteger,
+	represent: {
+		binary(object) {
+			const value = object instanceof Number ? object.valueOf() : object;
+			return value >= 0 ? `0b${value.toString(2)}` : `-0b${value.toString(2).slice(1)}`;
+		},
+		octal(object) {
+			const value = object instanceof Number ? object.valueOf() : object;
+			return value >= 0 ? `0${value.toString(8)}` : `-0${value.toString(8).slice(1)}`;
+		},
+		decimal(object) {
+			return (object instanceof Number ? object.valueOf() : object).toString(10);
+		},
+		hexadecimal(object) {
+			const value = object instanceof Number ? object.valueOf() : object;
+			return value >= 0 ? `0x${value.toString(16).toUpperCase()}` : `-0x${value.toString(16).toUpperCase().slice(1)}`;
+		}
+	},
+	resolve: resolveYamlInteger
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/map.js
+const map = {
+	tag: "tag:yaml.org,2002:map",
+	resolve() {
+		return true;
+	},
+	construct(data) {
+		return data !== null ? data : {};
+	},
+	kind: "mapping"
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/merge.js
+const merge = {
+	tag: "tag:yaml.org,2002:merge",
+	kind: "scalar",
+	resolve: (data) => data === "<<" || data === null,
+	construct: (data) => data
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/nil.js
+const nil = {
+	tag: "tag:yaml.org,2002:null",
+	kind: "scalar",
+	defaultStyle: "lowercase",
+	predicate: (object) => object === null,
+	construct: () => null,
+	resolve: (data) => {
+		return data === "~" || data === "null" || data === "Null" || data === "NULL";
+	},
+	represent: {
+		lowercase: () => "null",
+		uppercase: () => "NULL",
+		camelcase: () => "Null"
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/omap.js
+function resolveYamlOmap(data) {
+	const objectKeys = /* @__PURE__ */ new Set();
+	for (const object of data) {
+		if (!isPlainObject(object)) return false;
+		const keys = Object.keys(object);
+		if (keys.length !== 1) return false;
+		for (const key of keys) {
+			if (objectKeys.has(key)) return false;
+			objectKeys.add(key);
+		}
+	}
+	return true;
+}
+const omap = {
+	tag: "tag:yaml.org,2002:omap",
+	kind: "sequence",
+	resolve: resolveYamlOmap,
+	construct(data) {
+		return data;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/pairs.js
+function resolveYamlPairs(data) {
+	if (data === null) return true;
+	return data.every((it) => isPlainObject(it) && Object.keys(it).length === 1);
+}
+const pairs = {
+	tag: "tag:yaml.org,2002:pairs",
+	construct(data) {
+		return data?.flatMap(Object.entries) ?? [];
+	},
+	kind: "sequence",
+	resolve: resolveYamlPairs
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/regexp.js
+const REGEXP = /^\/(?<regexp>[\s\S]+)\/(?<modifiers>[gismuy]*)$/;
+const regexp = {
+	tag: "tag:yaml.org,2002:js/regexp",
+	kind: "scalar",
+	resolve(data) {
+		if (data === null || !data.length) return false;
+		if (data.charAt(0) === "/") {
+			const groups = data.match(REGEXP)?.groups;
+			if (!groups) return false;
+			const modifiers = groups.modifiers ?? "";
+			if (new Set(modifiers).size < modifiers.length) return false;
+		}
+		return true;
+	},
+	construct(data) {
+		const { regexp = data, modifiers = "" } = data.match(REGEXP)?.groups ?? {};
+		return new RegExp(regexp, modifiers);
+	},
+	predicate: (object) => object instanceof RegExp,
+	represent: (object) => object.toString()
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/seq.js
+const seq = {
+	tag: "tag:yaml.org,2002:seq",
+	kind: "sequence",
+	resolve: () => true,
+	construct: (data) => data !== null ? data : []
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/set.js
+const set = {
+	tag: "tag:yaml.org,2002:set",
+	kind: "mapping",
+	construct: (data) => data !== null ? data : {},
+	resolve: (data) => {
+		if (data === null) return true;
+		return Object.values(data).every((it) => it === null);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/str.js
+const str = {
+	tag: "tag:yaml.org,2002:str",
+	kind: "scalar",
+	resolve: () => true,
+	construct: (data) => data !== null ? data : ""
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/timestamp.js
+const YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+const YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp(data) {
+	if (data === null) return false;
+	if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+	if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+	return false;
+}
+function constructYamlTimestamp(data) {
+	let match = YAML_DATE_REGEXP.exec(data);
+	if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+	if (match === null) throw new Error("Cannot construct YAML timestamp: 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];
+	let fraction = 0;
+	if (match[7]) {
+		let partFraction = match[7].slice(0, 3);
+		while (partFraction.length < 3) partFraction += "0";
+		fraction = +partFraction;
+	}
+	let delta = null;
+	if (match[9] && match[10]) {
+		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(date) {
+	return date.toISOString();
+}
+const timestamp = {
+	tag: "tag:yaml.org,2002:timestamp",
+	construct: constructYamlTimestamp,
+	predicate(object) {
+		return object instanceof Date;
+	},
+	kind: "scalar",
+	represent: representYamlTimestamp,
+	resolve: resolveYamlTimestamp
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_type/undefined.js
+const undefinedType = {
+	tag: "tag:yaml.org,2002:js/undefined",
+	kind: "scalar",
+	resolve() {
+		return true;
+	},
+	construct() {},
+	predicate(object) {
+		return typeof object === "undefined";
+	},
+	represent() {
+		return "";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_schema.js
+function createTypeMap(implicitTypes, explicitTypes) {
+	const result = {
+		fallback: /* @__PURE__ */ new Map(),
+		mapping: /* @__PURE__ */ new Map(),
+		scalar: /* @__PURE__ */ new Map(),
+		sequence: /* @__PURE__ */ new Map()
+	};
+	const fallbackMap = result.fallback;
+	for (const type of [...implicitTypes, ...explicitTypes]) {
+		result[type.kind].set(type.tag, type);
+		fallbackMap.set(type.tag, type);
+	}
+	return result;
+}
+function createSchema({ explicitTypes = [], implicitTypes = [], include }) {
+	if (include) {
+		implicitTypes.push(...include.implicitTypes);
+		explicitTypes.push(...include.explicitTypes);
+	}
+	return {
+		implicitTypes,
+		explicitTypes,
+		typeMap: createTypeMap(implicitTypes, explicitTypes)
+	};
+}
+/**
+* Standard YAML's failsafe schema.
+*
+* @see {@link http://www.yaml.org/spec/1.2/spec.html#id2802346}
+*/ const FAILSAFE_SCHEMA = createSchema({ explicitTypes: [
+	str,
+	seq,
+	map
+] });
+/**
+* Standard YAML's JSON schema.
+*
+* @see {@link http://www.yaml.org/spec/1.2/spec.html#id2803231}
+*/ const JSON_SCHEMA = createSchema({
+	implicitTypes: [
+		nil,
+		bool,
+		int,
+		float
+	],
+	include: FAILSAFE_SCHEMA
+});
+/**
+* Standard YAML's core schema.
+*
+* @see {@link http://www.yaml.org/spec/1.2/spec.html#id2804923}
+*/ const CORE_SCHEMA = createSchema({ include: JSON_SCHEMA });
+/**
+* Default YAML schema. It is not described in the YAML specification.
+*/ const DEFAULT_SCHEMA = createSchema({
+	explicitTypes: [
+		binary,
+		omap,
+		pairs,
+		set
+	],
+	implicitTypes: [timestamp, merge],
+	include: CORE_SCHEMA
+});
+/***
+* Extends JS-YAML default schema with additional JavaScript types
+* It is not described in the YAML specification.
+* Functions are no longer supported for security reasons.
+*
+* @example
+* ```ts
+* import { parse } from "@std/yaml";
+*
+* const data = parse(
+*   `
+*   regexp:
+*     simple: !!js/regexp foobar
+*     modifiers: !!js/regexp /foobar/mi
+*   undefined: !!js/undefined ~
+* `,
+*   { schema: "extended" },
+* );
+* ```
+*/ const EXTENDED_SCHEMA = createSchema({
+	explicitTypes: [regexp, undefinedType],
+	include: DEFAULT_SCHEMA
+});
+const SCHEMA_MAP = new Map([
+	["core", CORE_SCHEMA],
+	["default", DEFAULT_SCHEMA],
+	["failsafe", FAILSAFE_SCHEMA],
+	["json", JSON_SCHEMA],
+	["extended", EXTENDED_SCHEMA]
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/_loader_state.js
+const CONTEXT_FLOW_IN = 1;
+const CONTEXT_FLOW_OUT = 2;
+const CONTEXT_BLOCK_IN = 3;
+const CONTEXT_BLOCK_OUT = 4;
+const CHOMPING_CLIP = 1;
+const CHOMPING_STRIP = 2;
+const CHOMPING_KEEP = 3;
+const PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+const PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+const PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+const PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+const PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+const ESCAPED_HEX_LENGTHS = new Map([
+	[120, 2],
+	[117, 4],
+	[85, 8]
+]);
+const SIMPLE_ESCAPE_SEQUENCES = new Map([
+	[48, "\0"],
+	[97, "\x07"],
+	[98, "\b"],
+	[116, "	"],
+	[9, "	"],
+	[110, "\n"],
+	[118, "\v"],
+	[102, "\f"],
+	[114, "\r"],
+	[101, "\x1B"],
+	[32, " "],
+	[34, "\""],
+	[47, "/"],
+	[92, "\\"],
+	[78, "…"],
+	[95, "\xA0"],
+	[76, "\u2028"],
+	[80, "\u2029"]
+]);
+/**
+* Converts a hexadecimal character code to its decimal value.
+*/ function hexCharCodeToNumber(charCode) {
+	if (48 <= charCode && charCode <= 57) return charCode - 48;
+	const lc = charCode | 32;
+	if (97 <= lc && lc <= 102) return lc - 97 + 10;
+	return -1;
+}
+/**
+* Converts a decimal character code to its decimal value.
+*/ function decimalCharCodeToNumber(charCode) {
+	if (48 <= charCode && charCode <= 57) return charCode - 48;
+	return -1;
+}
+/**
+* Converts a Unicode code point to a string.
+*/ function codepointToChar(codepoint) {
+	if (codepoint <= 65535) return String.fromCharCode(codepoint);
+	return String.fromCharCode((codepoint - 65536 >> 10) + 55296, (codepoint - 65536 & 1023) + 56320);
+}
+const INDENT = 4;
+const MAX_LENGTH = 75;
+const DELIMITERS = "\0\r\n…\u2028\u2029";
+function getSnippet(buffer, position) {
+	if (!buffer) return null;
+	let start = position;
+	let end = position;
+	let head = "";
+	let tail = "";
+	while (start > 0 && !DELIMITERS.includes(buffer.charAt(start - 1))) {
+		start--;
+		if (position - start > MAX_LENGTH / 2 - 1) {
+			head = " ... ";
+			start += 5;
+			break;
+		}
+	}
+	while (end < buffer.length && !DELIMITERS.includes(buffer.charAt(end))) {
+		end++;
+		if (end - position > MAX_LENGTH / 2 - 1) {
+			tail = " ... ";
+			end -= 5;
+			break;
+		}
+	}
+	const snippet = buffer.slice(start, end);
+	const indent = " ".repeat(INDENT);
+	const caretIndent = " ".repeat(INDENT + position - start + head.length);
+	return `${indent + head + snippet + tail}\n${caretIndent}^`;
+}
+function markToString(buffer, position, line, column) {
+	let where = `at line ${line + 1}, column ${column + 1}`;
+	const snippet = getSnippet(buffer, position);
+	if (snippet) where += `:\n${snippet}`;
+	return where;
+}
+function getIndentStatus(lineIndent, parentIndent) {
+	if (lineIndent > parentIndent) return 1;
+	if (lineIndent < parentIndent) return -1;
+	return 0;
+}
+function writeFoldedLines(count) {
+	if (count === 1) return " ";
+	if (count > 1) return "\n".repeat(count - 1);
+	return "";
+}
+var Scanner = class {
+	source;
+	#length;
+	position = 0;
+	constructor(source) {
+		source += "\0";
+		this.source = source;
+		this.#length = source.length;
+	}
+	peek(offset = 0) {
+		return this.source.charCodeAt(this.position + offset);
+	}
+	next() {
+		this.position += 1;
+	}
+	eof() {
+		return this.position >= this.#length - 1;
+	}
+};
+var LoaderState = class {
+	#scanner;
+	lineIndent = 0;
+	lineStart = 0;
+	line = 0;
+	onWarning;
+	allowDuplicateKeys;
+	implicitTypes;
+	typeMap;
+	checkLineBreaks = false;
+	tagMap = /* @__PURE__ */ new Map();
+	anchorMap = /* @__PURE__ */ new Map();
+	constructor(input, { schema = DEFAULT_SCHEMA, onWarning, allowDuplicateKeys = false }) {
+		this.#scanner = new Scanner(input);
+		this.onWarning = onWarning;
+		this.allowDuplicateKeys = allowDuplicateKeys;
+		this.implicitTypes = schema.implicitTypes;
+		this.typeMap = schema.typeMap;
+		this.readIndent();
+	}
+	skipWhitespaces() {
+		let ch = this.#scanner.peek();
+		while (isWhiteSpace(ch)) {
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		}
+	}
+	skipComment() {
+		let ch = this.#scanner.peek();
+		if (ch !== 35) return;
+		this.#scanner.next();
+		ch = this.#scanner.peek();
+		while (ch !== 0 && !isEOL(ch)) {
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		}
+	}
+	readIndent() {
+		let ch = this.#scanner.peek();
+		while (ch === 32) {
+			this.lineIndent += 1;
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		}
+	}
+	#createError(message) {
+		const mark = markToString(this.#scanner.source, this.#scanner.position, this.line, this.#scanner.position - this.lineStart);
+		return /* @__PURE__ */ new SyntaxError(`${message} ${mark}`);
+	}
+	dispatchWarning(message) {
+		const error = this.#createError(message);
+		this.onWarning?.(error);
+	}
+	yamlDirectiveHandler(args) {
+		if (args.length !== 1) throw this.#createError("Cannot handle YAML directive: YAML directive accepts exactly one argument");
+		const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+		if (match === null) throw this.#createError("Cannot handle YAML directive: ill-formed argument");
+		const major = parseInt(match[1], 10);
+		const minor = parseInt(match[2], 10);
+		if (major !== 1) throw this.#createError("Cannot handle YAML directive: unacceptable YAML version");
+		this.checkLineBreaks = minor < 2;
+		if (minor !== 1 && minor !== 2) this.dispatchWarning("Cannot handle YAML directive: unsupported YAML version");
+		return args[0] ?? null;
+	}
+	tagDirectiveHandler(args) {
+		if (args.length !== 2) throw this.#createError(`Cannot handle tag directive: directive accepts exactly two arguments, received ${args.length}`);
+		const handle = args[0];
+		const prefix = args[1];
+		if (!PATTERN_TAG_HANDLE.test(handle)) throw this.#createError(`Cannot handle tag directive: ill-formed handle (first argument) in "${handle}"`);
+		if (this.tagMap.has(handle)) throw this.#createError(`Cannot handle tag directive: previously declared suffix for "${handle}" tag handle`);
+		if (!PATTERN_TAG_URI.test(prefix)) throw this.#createError("Cannot handle tag directive: ill-formed tag prefix (second argument) of the TAG directive");
+		this.tagMap.set(handle, prefix);
+	}
+	captureSegment(start, end, checkJson) {
+		if (start < end) {
+			const result = this.#scanner.source.slice(start, end);
+			if (checkJson) for (let position = 0; position < result.length; position++) {
+				const character = result.charCodeAt(position);
+				if (!(character === 9 || 32 <= character && character <= 1114111)) throw this.#createError(`Expected valid JSON character: received "${character}"`);
+			}
+			else if (PATTERN_NON_PRINTABLE.test(result)) throw this.#createError("Stream contains non-printable characters");
+			return result;
+		}
+	}
+	readBlockSequence(tag, anchor, nodeIndent) {
+		let detected = false;
+		const result = [];
+		if (anchor !== null) this.anchorMap.set(anchor, result);
+		let ch = this.#scanner.peek();
+		while (ch !== 0) {
+			if (ch !== 45) break;
+			if (!isWhiteSpaceOrEOL(this.#scanner.peek(1))) break;
+			detected = true;
+			this.#scanner.next();
+			if (this.skipSeparationSpace(true, -1)) {
+				if (this.lineIndent <= nodeIndent) {
+					result.push(null);
+					ch = this.#scanner.peek();
+					continue;
+				}
+			}
+			const line = this.line;
+			const newState = this.composeNode({
+				parentIndent: nodeIndent,
+				nodeContext: CONTEXT_BLOCK_IN,
+				allowToSeek: false,
+				allowCompact: true
+			});
+			if (newState) result.push(newState.result);
+			this.skipSeparationSpace(true, -1);
+			ch = this.#scanner.peek();
+			if ((this.line === line || this.lineIndent > nodeIndent) && ch !== 0) throw this.#createError("Cannot read block sequence: bad indentation of a sequence entry");
+			else if (this.lineIndent < nodeIndent) break;
+		}
+		if (detected) return {
+			tag,
+			anchor,
+			kind: "sequence",
+			result
+		};
+	}
+	mergeMappings(destination, source, overridableKeys) {
+		if (!isObject(source)) throw this.#createError("Cannot merge mappings: the provided source object is unacceptable");
+		for (const [key, value] of Object.entries(source)) {
+			if (Object.hasOwn(destination, key)) continue;
+			Object.defineProperty(destination, key, {
+				value,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			overridableKeys.add(key);
+		}
+	}
+	storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
+		if (Array.isArray(keyNode)) {
+			keyNode = Array.prototype.slice.call(keyNode);
+			for (let index = 0; index < keyNode.length; index++) {
+				if (Array.isArray(keyNode[index])) throw this.#createError("Cannot store mapping pair: nested arrays are not supported inside keys");
+				if (typeof keyNode === "object" && isPlainObject(keyNode[index])) keyNode[index] = "[object Object]";
+			}
+		}
+		if (typeof keyNode === "object" && isPlainObject(keyNode)) keyNode = "[object Object]";
+		keyNode = String(keyNode);
+		if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) for (let index = 0; index < valueNode.length; index++) this.mergeMappings(result, valueNode[index], overridableKeys);
+		else this.mergeMappings(result, valueNode, overridableKeys);
+		else {
+			if (!this.allowDuplicateKeys && !overridableKeys.has(keyNode) && Object.hasOwn(result, keyNode)) {
+				this.line = startLine || this.line;
+				this.#scanner.position = startPos || this.#scanner.position;
+				throw this.#createError("Cannot store mapping pair: duplicated key");
+			}
+			Object.defineProperty(result, keyNode, {
+				value: valueNode,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			overridableKeys.delete(keyNode);
+		}
+		return result;
+	}
+	readLineBreak() {
+		const ch = this.#scanner.peek();
+		if (ch === 10) this.#scanner.next();
+		else if (ch === 13) {
+			this.#scanner.next();
+			if (this.#scanner.peek() === 10) this.#scanner.next();
+		} else throw this.#createError("Cannot read line: line break not found");
+		this.line += 1;
+		this.lineStart = this.#scanner.position;
+	}
+	skipSeparationSpace(allowComments, checkIndent) {
+		let lineBreaks = 0;
+		let ch = this.#scanner.peek();
+		while (ch !== 0) {
+			this.skipWhitespaces();
+			ch = this.#scanner.peek();
+			if (allowComments) {
+				this.skipComment();
+				ch = this.#scanner.peek();
+			}
+			if (isEOL(ch)) {
+				this.readLineBreak();
+				ch = this.#scanner.peek();
+				lineBreaks++;
+				this.lineIndent = 0;
+				this.readIndent();
+				ch = this.#scanner.peek();
+			} else break;
+		}
+		if (checkIndent !== -1 && lineBreaks !== 0 && this.lineIndent < checkIndent) this.dispatchWarning("deficient indentation");
+		return lineBreaks;
+	}
+	testDocumentSeparator() {
+		let ch = this.#scanner.peek();
+		if ((ch === 45 || ch === 46) && ch === this.#scanner.peek(1) && ch === this.#scanner.peek(2)) {
+			ch = this.#scanner.peek(3);
+			if (ch === 0 || isWhiteSpaceOrEOL(ch)) return true;
+		}
+		return false;
+	}
+	readPlainScalar(tag, anchor, nodeIndent, withinFlowCollection) {
+		let ch = this.#scanner.peek();
+		if (isWhiteSpaceOrEOL(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;
+		let following;
+		if (ch === 63 || ch === 45) {
+			following = this.#scanner.peek(1);
+			if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) return;
+		}
+		let result = "";
+		let captureEnd = this.#scanner.position;
+		let captureStart = this.#scanner.position;
+		let hasPendingContent = false;
+		let line = 0;
+		while (ch !== 0) {
+			if (ch === 58) {
+				following = this.#scanner.peek(1);
+				if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) break;
+			} else if (ch === 35) {
+				if (isWhiteSpaceOrEOL(this.#scanner.peek(-1))) break;
+			} else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) break;
+			else if (isEOL(ch)) {
+				line = this.line;
+				const lineStart = this.lineStart;
+				const lineIndent = this.lineIndent;
+				this.skipSeparationSpace(false, -1);
+				if (this.lineIndent >= nodeIndent) {
+					hasPendingContent = true;
+					ch = this.#scanner.peek();
+					continue;
+				} else {
+					this.#scanner.position = captureEnd;
+					this.line = line;
+					this.lineStart = lineStart;
+					this.lineIndent = lineIndent;
+					break;
+				}
+			}
+			if (hasPendingContent) {
+				const segment = this.captureSegment(captureStart, captureEnd, false);
+				if (segment) result += segment;
+				result += writeFoldedLines(this.line - line);
+				captureStart = captureEnd = this.#scanner.position;
+				hasPendingContent = false;
+			}
+			if (!isWhiteSpace(ch)) captureEnd = this.#scanner.position + 1;
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		}
+		const segment = this.captureSegment(captureStart, captureEnd, false);
+		if (segment) result += segment;
+		if (anchor !== null) this.anchorMap.set(anchor, result);
+		if (result) return {
+			tag,
+			anchor,
+			kind: "scalar",
+			result
+		};
+	}
+	readSingleQuotedScalar(tag, anchor, nodeIndent) {
+		let ch = this.#scanner.peek();
+		if (ch !== 39) return;
+		let result = "";
+		this.#scanner.next();
+		let captureStart = this.#scanner.position;
+		let captureEnd = this.#scanner.position;
+		ch = this.#scanner.peek();
+		while (ch !== 0) {
+			if (ch === 39) {
+				const segment = this.captureSegment(captureStart, this.#scanner.position, true);
+				if (segment) result += segment;
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+				if (ch === 39) {
+					captureStart = this.#scanner.position;
+					this.#scanner.next();
+					captureEnd = this.#scanner.position;
+				} else {
+					if (anchor !== null) this.anchorMap.set(anchor, result);
+					return {
+						tag,
+						anchor,
+						kind: "scalar",
+						result
+					};
+				}
+			} else if (isEOL(ch)) {
+				const segment = this.captureSegment(captureStart, captureEnd, true);
+				if (segment) result += segment;
+				result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+				captureStart = captureEnd = this.#scanner.position;
+			} else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) throw this.#createError("Unexpected end of the document within a single quoted scalar");
+			else {
+				this.#scanner.next();
+				captureEnd = this.#scanner.position;
+			}
+			ch = this.#scanner.peek();
+		}
+		throw this.#createError("Unexpected end of the stream within a single quoted scalar");
+	}
+	readDoubleQuotedScalar(tag, anchor, nodeIndent) {
+		let ch = this.#scanner.peek();
+		if (ch !== 34) return;
+		let result = "";
+		this.#scanner.next();
+		let captureEnd = this.#scanner.position;
+		let captureStart = this.#scanner.position;
+		let tmp;
+		ch = this.#scanner.peek();
+		while (ch !== 0) {
+			if (ch === 34) {
+				const segment = this.captureSegment(captureStart, this.#scanner.position, true);
+				if (segment) result += segment;
+				this.#scanner.next();
+				if (anchor !== null) this.anchorMap.set(anchor, result);
+				return {
+					tag,
+					anchor,
+					kind: "scalar",
+					result
+				};
+			}
+			if (ch === 92) {
+				const segment = this.captureSegment(captureStart, this.#scanner.position, true);
+				if (segment) result += segment;
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+				if (isEOL(ch)) this.skipSeparationSpace(false, nodeIndent);
+				else if (ch < 256 && SIMPLE_ESCAPE_SEQUENCES.has(ch)) {
+					result += SIMPLE_ESCAPE_SEQUENCES.get(ch);
+					this.#scanner.next();
+				} else if ((tmp = ESCAPED_HEX_LENGTHS.get(ch) ?? 0) > 0) {
+					let hexLength = tmp;
+					let hexResult = 0;
+					for (; hexLength > 0; hexLength--) {
+						this.#scanner.next();
+						ch = this.#scanner.peek();
+						if ((tmp = hexCharCodeToNumber(ch)) >= 0) hexResult = (hexResult << 4) + tmp;
+						else throw this.#createError("Cannot read double quoted scalar: expected hexadecimal character");
+					}
+					result += codepointToChar(hexResult);
+					this.#scanner.next();
+				} else throw this.#createError("Cannot read double quoted scalar: unknown escape sequence");
+				captureStart = captureEnd = this.#scanner.position;
+			} else if (isEOL(ch)) {
+				const segment = this.captureSegment(captureStart, captureEnd, true);
+				if (segment) result += segment;
+				result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+				captureStart = captureEnd = this.#scanner.position;
+			} else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) throw this.#createError("Unexpected end of the document within a double quoted scalar");
+			else {
+				this.#scanner.next();
+				captureEnd = this.#scanner.position;
+			}
+			ch = this.#scanner.peek();
+		}
+		throw this.#createError("Unexpected end of the stream within a double quoted scalar");
+	}
+	readFlowCollection(tag, anchor, nodeIndent) {
+		let ch = this.#scanner.peek();
+		let terminator;
+		let isMapping = true;
+		let result = {};
+		if (ch === 91) {
+			terminator = 93;
+			isMapping = false;
+			result = [];
+		} else if (ch === 123) terminator = 125;
+		else return;
+		if (anchor !== null) this.anchorMap.set(anchor, result);
+		this.#scanner.next();
+		ch = this.#scanner.peek();
+		let readNext = true;
+		let valueNode = null;
+		let keyNode = null;
+		let keyTag = null;
+		let isExplicitPair = false;
+		let isPair = false;
+		let following = 0;
+		let line = 0;
+		const overridableKeys = /* @__PURE__ */ new Set();
+		while (ch !== 0) {
+			this.skipSeparationSpace(true, nodeIndent);
+			ch = this.#scanner.peek();
+			if (ch === terminator) {
+				this.#scanner.next();
+				return {
+					tag,
+					anchor,
+					kind: isMapping ? "mapping" : "sequence",
+					result
+				};
+			}
+			if (!readNext) throw this.#createError("Cannot read flow collection: missing comma between flow collection entries");
+			keyTag = keyNode = valueNode = null;
+			isPair = isExplicitPair = false;
+			if (ch === 63) {
+				following = this.#scanner.peek(1);
+				if (isWhiteSpaceOrEOL(following)) {
+					isPair = isExplicitPair = true;
+					this.#scanner.next();
+					this.skipSeparationSpace(true, nodeIndent);
+				}
+			}
+			line = this.line;
+			const newState = this.composeNode({
+				parentIndent: nodeIndent,
+				nodeContext: CONTEXT_FLOW_IN,
+				allowToSeek: false,
+				allowCompact: true
+			});
+			if (newState) {
+				keyTag = newState.tag || null;
+				keyNode = newState.result;
+			}
+			this.skipSeparationSpace(true, nodeIndent);
+			ch = this.#scanner.peek();
+			if ((isExplicitPair || this.line === line) && ch === 58) {
+				isPair = true;
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+				this.skipSeparationSpace(true, nodeIndent);
+				const newState = this.composeNode({
+					parentIndent: nodeIndent,
+					nodeContext: CONTEXT_FLOW_IN,
+					allowToSeek: false,
+					allowCompact: true
+				});
+				if (newState) valueNode = newState.result;
+			}
+			if (isMapping) this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode);
+			else if (isPair) result.push(this.storeMappingPair({}, overridableKeys, keyTag, keyNode, valueNode));
+			else result.push(keyNode);
+			this.skipSeparationSpace(true, nodeIndent);
+			ch = this.#scanner.peek();
+			if (ch === 44) {
+				readNext = true;
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+			} else readNext = false;
+		}
+		throw this.#createError("Cannot read flow collection: unexpected end of the stream within a flow collection");
+	}
+	readBlockScalar(tag, anchor, nodeIndent) {
+		let chomping = CHOMPING_CLIP;
+		let didReadContent = false;
+		let detectedIndent = false;
+		let textIndent = nodeIndent;
+		let emptyLines = 0;
+		let atMoreIndented = false;
+		let ch = this.#scanner.peek();
+		let folding = false;
+		if (ch === 124) folding = false;
+		else if (ch === 62) folding = true;
+		else return;
+		let result = "";
+		let tmp = 0;
+		while (ch !== 0) {
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+			if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
+			else throw this.#createError("Cannot read block: chomping mode identifier repeated");
+			else if ((tmp = decimalCharCodeToNumber(ch)) >= 0) if (tmp === 0) throw this.#createError("Cannot read block: indentation width must be greater than 0");
+			else if (!detectedIndent) {
+				textIndent = nodeIndent + tmp - 1;
+				detectedIndent = true;
+			} else throw this.#createError("Cannot read block: indentation width identifier repeated");
+			else break;
+		}
+		if (isWhiteSpace(ch)) {
+			this.skipWhitespaces();
+			this.skipComment();
+			ch = this.#scanner.peek();
+		}
+		while (ch !== 0) {
+			this.readLineBreak();
+			this.lineIndent = 0;
+			ch = this.#scanner.peek();
+			while ((!detectedIndent || this.lineIndent < textIndent) && ch === 32) {
+				this.lineIndent++;
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+			}
+			if (!detectedIndent && this.lineIndent > textIndent) textIndent = this.lineIndent;
+			if (isEOL(ch)) {
+				emptyLines++;
+				continue;
+			}
+			if (this.lineIndent < textIndent) {
+				if (chomping === CHOMPING_KEEP) result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+				else if (chomping === CHOMPING_CLIP) {
+					if (didReadContent) result += "\n";
+				}
+				break;
+			}
+			if (folding) if (isWhiteSpace(ch)) {
+				atMoreIndented = true;
+				result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+			} else if (atMoreIndented) {
+				atMoreIndented = false;
+				result += "\n".repeat(emptyLines + 1);
+			} else if (emptyLines === 0) {
+				if (didReadContent) result += " ";
+			} else result += "\n".repeat(emptyLines);
+			else result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+			didReadContent = true;
+			detectedIndent = true;
+			emptyLines = 0;
+			const captureStart = this.#scanner.position;
+			while (!isEOL(ch) && ch !== 0) {
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+			}
+			const segment = this.captureSegment(captureStart, this.#scanner.position, false);
+			if (segment) result += segment;
+		}
+		if (anchor !== null) this.anchorMap.set(anchor, result);
+		return {
+			tag,
+			anchor,
+			kind: "scalar",
+			result
+		};
+	}
+	readBlockMapping(tag, anchor, nodeIndent, flowIndent) {
+		const result = {};
+		const overridableKeys = /* @__PURE__ */ new Set();
+		let allowCompact = false;
+		let line;
+		let pos;
+		let keyTag = null;
+		let keyNode = null;
+		let valueNode = null;
+		let atExplicitKey = false;
+		let detected = false;
+		if (anchor !== null) this.anchorMap.set(anchor, result);
+		let ch = this.#scanner.peek();
+		while (ch !== 0) {
+			const following = this.#scanner.peek(1);
+			line = this.line;
+			pos = this.#scanner.position;
+			if ((ch === 63 || ch === 58) && isWhiteSpaceOrEOL(following)) {
+				if (ch === 63) {
+					if (atExplicitKey) {
+						this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+						keyTag = null;
+						keyNode = null;
+						valueNode = null;
+					}
+					detected = true;
+					atExplicitKey = true;
+					allowCompact = true;
+				} else if (atExplicitKey) {
+					atExplicitKey = false;
+					allowCompact = true;
+				} else throw this.#createError("Cannot read block as explicit mapping pair is incomplete: a key node is missed or followed by a non-tabulated empty line");
+				this.#scanner.next();
+				ch = following;
+			} else {
+				const newState = this.composeNode({
+					parentIndent: flowIndent,
+					nodeContext: CONTEXT_FLOW_OUT,
+					allowToSeek: false,
+					allowCompact: true
+				});
+				if (!newState) break;
+				if (this.line === line) {
+					ch = this.#scanner.peek();
+					this.skipWhitespaces();
+					ch = this.#scanner.peek();
+					if (ch === 58) {
+						this.#scanner.next();
+						ch = this.#scanner.peek();
+						if (!isWhiteSpaceOrEOL(ch)) throw this.#createError("Cannot read block: a whitespace character is expected after the key-value separator within a block mapping");
+						if (atExplicitKey) {
+							this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+							keyTag = null;
+							keyNode = null;
+							valueNode = null;
+						}
+						detected = true;
+						atExplicitKey = false;
+						allowCompact = false;
+						keyTag = newState.tag;
+						keyNode = newState.result;
+					} else if (detected) throw this.#createError("Cannot read an implicit mapping pair: missing colon");
+					else {
+						const { kind, result } = newState;
+						return {
+							tag,
+							anchor,
+							kind,
+							result
+						};
+					}
+				} else if (detected) throw this.#createError("Cannot read a block mapping entry: a multiline key may not be an implicit key");
+				else {
+					const { kind, result } = newState;
+					return {
+						tag,
+						anchor,
+						kind,
+						result
+					};
+				}
+			}
+			if (this.line === line || this.lineIndent > nodeIndent) {
+				const newState = this.composeNode({
+					parentIndent: nodeIndent,
+					nodeContext: CONTEXT_BLOCK_OUT,
+					allowToSeek: true,
+					allowCompact
+				});
+				if (newState) if (atExplicitKey) keyNode = newState.result;
+				else valueNode = newState.result;
+				if (!atExplicitKey) {
+					this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, line, pos);
+					keyTag = keyNode = valueNode = null;
+				}
+				this.skipSeparationSpace(true, -1);
+				ch = this.#scanner.peek();
+			}
+			if (this.lineIndent > nodeIndent && ch !== 0) throw this.#createError("Cannot read block: bad indentation of a mapping entry");
+			else if (this.lineIndent < nodeIndent) break;
+		}
+		if (atExplicitKey) this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+		if (detected) return {
+			tag,
+			anchor,
+			kind: "mapping",
+			result
+		};
+	}
+	readTagProperty(tag) {
+		let isVerbatim = false;
+		let isNamed = false;
+		let tagHandle = "";
+		let tagName;
+		let ch = this.#scanner.peek();
+		if (ch !== 33) return;
+		if (tag !== null) throw this.#createError("Cannot read tag property: duplication of a tag property");
+		this.#scanner.next();
+		ch = this.#scanner.peek();
+		if (ch === 60) {
+			isVerbatim = true;
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		} else if (ch === 33) {
+			isNamed = true;
+			tagHandle = "!!";
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		} else tagHandle = "!";
+		let position = this.#scanner.position;
+		if (isVerbatim) {
+			do {
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+			} while (ch !== 0 && ch !== 62);
+			if (!this.#scanner.eof()) {
+				tagName = this.#scanner.source.slice(position, this.#scanner.position);
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+			} else throw this.#createError("Cannot read tag property: unexpected end of stream");
+		} else {
+			while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+				if (ch === 33) if (!isNamed) {
+					tagHandle = this.#scanner.source.slice(position - 1, this.#scanner.position + 1);
+					if (!PATTERN_TAG_HANDLE.test(tagHandle)) throw this.#createError("Cannot read tag property: named tag handle contains invalid characters");
+					isNamed = true;
+					position = this.#scanner.position + 1;
+				} else throw this.#createError("Cannot read tag property: tag suffix cannot contain an exclamation mark");
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+			}
+			tagName = this.#scanner.source.slice(position, this.#scanner.position);
+			if (PATTERN_FLOW_INDICATORS.test(tagName)) throw this.#createError("Cannot read tag property: tag suffix cannot contain flow indicator characters");
+		}
+		if (tagName && !PATTERN_TAG_URI.test(tagName)) throw this.#createError(`Cannot read tag property: invalid characters in tag name "${tagName}"`);
+		if (isVerbatim) return tagName;
+		else if (this.tagMap.has(tagHandle)) return this.tagMap.get(tagHandle) + tagName;
+		else if (tagHandle === "!") return `!${tagName}`;
+		else if (tagHandle === "!!") return `tag:yaml.org,2002:${tagName}`;
+		throw this.#createError(`Cannot read tag property: undeclared tag handle "${tagHandle}"`);
+	}
+	readAnchorProperty(anchor) {
+		let ch = this.#scanner.peek();
+		if (ch !== 38) return;
+		if (anchor !== null) throw this.#createError("Cannot read anchor property: duplicate anchor property");
+		this.#scanner.next();
+		ch = this.#scanner.peek();
+		const position = this.#scanner.position;
+		while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		}
+		if (this.#scanner.position === position) throw this.#createError("Cannot read anchor property: name of an anchor node must contain at least one character");
+		return this.#scanner.source.slice(position, this.#scanner.position);
+	}
+	readAlias() {
+		if (this.#scanner.peek() !== 42) return;
+		this.#scanner.next();
+		let ch = this.#scanner.peek();
+		const position = this.#scanner.position;
+		while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+		}
+		if (this.#scanner.position === position) throw this.#createError("Cannot read alias: alias name must contain at least one character");
+		const alias = this.#scanner.source.slice(position, this.#scanner.position);
+		if (!this.anchorMap.has(alias)) throw this.#createError(`Cannot read alias: unidentified alias "${alias}"`);
+		this.skipSeparationSpace(true, -1);
+		return this.anchorMap.get(alias);
+	}
+	resolveTag(state) {
+		switch (state.tag) {
+			case null:
+			case "!": return state;
+			case "?":
+				for (const type of this.implicitTypes) {
+					if (!type.resolve(state.result)) continue;
+					const result = type.construct(state.result);
+					state.result = result;
+					state.tag = type.tag;
+					const { anchor } = state;
+					if (anchor !== null) this.anchorMap.set(anchor, result);
+					return state;
+				}
+				return state;
+		}
+		const kind = state.kind ?? "fallback";
+		const type = this.typeMap[kind].get(state.tag);
+		if (!type) throw this.#createError(`Cannot resolve unknown tag !<${state.tag}>`);
+		if (state.result !== null && type.kind !== state.kind) throw this.#createError(`Unacceptable node kind for !<${state.tag}> tag: it should be "${type.kind}", not "${state.kind}"`);
+		if (!type.resolve(state.result)) throw this.#createError(`Cannot resolve a node with !<${state.tag}> explicit tag`);
+		const result = type.construct(state.result);
+		state.result = result;
+		const { anchor } = state;
+		if (anchor !== null) this.anchorMap.set(anchor, result);
+		return state;
+	}
+	composeNode({ parentIndent, nodeContext, allowToSeek, allowCompact }) {
+		let indentStatus = 1;
+		let atNewLine = false;
+		const allowBlockScalars = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+		let allowBlockCollections = allowBlockScalars;
+		const allowBlockStyles = allowBlockScalars;
+		if (allowToSeek) {
+			if (this.skipSeparationSpace(true, -1)) {
+				atNewLine = true;
+				indentStatus = getIndentStatus(this.lineIndent, parentIndent);
+			}
+		}
+		let tag = null;
+		let anchor = null;
+		if (indentStatus === 1) while (true) {
+			const newTag = this.readTagProperty(tag);
+			if (newTag) tag = newTag;
+			else {
+				const newAnchor = this.readAnchorProperty(anchor);
+				if (!newAnchor) break;
+				anchor = newAnchor;
+			}
+			if (this.skipSeparationSpace(true, -1)) {
+				atNewLine = true;
+				allowBlockCollections = allowBlockStyles;
+				indentStatus = getIndentStatus(this.lineIndent, parentIndent);
+			} else allowBlockCollections = false;
+		}
+		if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact;
+		if (indentStatus === 1) {
+			const flowIndent = CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext ? parentIndent : parentIndent + 1;
+			if (allowBlockCollections) {
+				const blockIndent = this.#scanner.position - this.lineStart;
+				const blockSequenceState = this.readBlockSequence(tag, anchor, blockIndent);
+				if (blockSequenceState) return this.resolveTag(blockSequenceState);
+				const blockMappingState = this.readBlockMapping(tag, anchor, blockIndent, flowIndent);
+				if (blockMappingState) return this.resolveTag(blockMappingState);
+			}
+			const flowCollectionState = this.readFlowCollection(tag, anchor, flowIndent);
+			if (flowCollectionState) return this.resolveTag(flowCollectionState);
+			if (allowBlockScalars) {
+				const blockScalarState = this.readBlockScalar(tag, anchor, flowIndent);
+				if (blockScalarState) return this.resolveTag(blockScalarState);
+			}
+			const singleQuoteState = this.readSingleQuotedScalar(tag, anchor, flowIndent);
+			if (singleQuoteState) return this.resolveTag(singleQuoteState);
+			const doubleQuoteState = this.readDoubleQuotedScalar(tag, anchor, flowIndent);
+			if (doubleQuoteState) return this.resolveTag(doubleQuoteState);
+			const alias = this.readAlias();
+			if (alias) {
+				if (tag !== null || anchor !== null) throw this.#createError("Cannot compose node: alias node should not have any properties");
+				return this.resolveTag({
+					tag,
+					anchor,
+					kind: null,
+					result: alias
+				});
+			}
+			const plainScalarState = this.readPlainScalar(tag, anchor, flowIndent, CONTEXT_FLOW_IN === nodeContext);
+			if (plainScalarState) {
+				plainScalarState.tag ??= "?";
+				return this.resolveTag(plainScalarState);
+			}
+		} else if (indentStatus === 0 && CONTEXT_BLOCK_OUT === nodeContext && allowBlockCollections) {
+			const blockIndent = this.#scanner.position - this.lineStart;
+			const newState = this.readBlockSequence(tag, anchor, blockIndent);
+			if (newState) return this.resolveTag(newState);
+		}
+		const newState = this.resolveTag({
+			tag,
+			anchor,
+			kind: null,
+			result: null
+		});
+		if (newState.tag !== null || newState.anchor !== null) return newState;
+	}
+	readDirectives() {
+		let hasDirectives = false;
+		let version = null;
+		let ch = this.#scanner.peek();
+		while (ch !== 0) {
+			this.skipSeparationSpace(true, -1);
+			ch = this.#scanner.peek();
+			if (this.lineIndent > 0 || ch !== 37) break;
+			hasDirectives = true;
+			this.#scanner.next();
+			ch = this.#scanner.peek();
+			let position = this.#scanner.position;
+			while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+				this.#scanner.next();
+				ch = this.#scanner.peek();
+			}
+			const directiveName = this.#scanner.source.slice(position, this.#scanner.position);
+			const directiveArgs = [];
+			if (directiveName.length < 1) throw this.#createError("Cannot read document: directive name length must be greater than zero");
+			while (ch !== 0) {
+				this.skipWhitespaces();
+				this.skipComment();
+				ch = this.#scanner.peek();
+				if (isEOL(ch)) break;
+				position = this.#scanner.position;
+				while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+					this.#scanner.next();
+					ch = this.#scanner.peek();
+				}
+				directiveArgs.push(this.#scanner.source.slice(position, this.#scanner.position));
+			}
+			if (ch !== 0) this.readLineBreak();
+			switch (directiveName) {
+				case "YAML":
+					if (version !== null) throw this.#createError("Cannot handle YAML directive: duplication of %YAML directive");
+					version = this.yamlDirectiveHandler(directiveArgs);
+					break;
+				case "TAG":
+					this.tagDirectiveHandler(directiveArgs);
+					break;
+				default:
+					this.dispatchWarning(`unknown document directive "${directiveName}"`);
+					break;
+			}
+			ch = this.#scanner.peek();
+		}
+		return hasDirectives;
+	}
+	readDocument() {
+		const documentStart = this.#scanner.position;
+		this.checkLineBreaks = false;
+		this.tagMap = /* @__PURE__ */ new Map();
+		this.anchorMap = /* @__PURE__ */ new Map();
+		const hasDirectives = this.readDirectives();
+		this.skipSeparationSpace(true, -1);
+		let result = null;
+		if (this.lineIndent === 0 && this.#scanner.peek() === 45 && this.#scanner.peek(1) === 45 && this.#scanner.peek(2) === 45) {
+			this.#scanner.position += 3;
+			this.skipSeparationSpace(true, -1);
+		} else if (hasDirectives) throw this.#createError("Cannot read document: directives end mark is expected");
+		const newState = this.composeNode({
+			parentIndent: this.lineIndent - 1,
+			nodeContext: CONTEXT_BLOCK_OUT,
+			allowToSeek: false,
+			allowCompact: true
+		});
+		if (newState) result = newState.result;
+		this.skipSeparationSpace(true, -1);
+		if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.#scanner.source.slice(documentStart, this.#scanner.position))) this.dispatchWarning("non-ASCII line breaks are interpreted as content");
+		if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) {
+			if (this.#scanner.peek() === 46) {
+				this.#scanner.position += 3;
+				this.skipSeparationSpace(true, -1);
+			}
+		} else if (!this.#scanner.eof()) throw this.#createError("Cannot read document: end of the stream or a document separator is expected");
+		return result;
+	}
+	*readDocuments() {
+		while (!this.#scanner.eof()) yield this.readDocument();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+std__yaml@1.0.12/node_modules/@jsr/std__yaml/parse.js
+function sanitizeInput(input) {
+	input = String(input);
+	if (input.length > 0) {
+		if (!isEOL(input.charCodeAt(input.length - 1))) input += "\n";
+		if (input.charCodeAt(0) === 65279) input = input.slice(1);
+	}
+	return input;
+}
+/**
+* Parse and return a YAML string as a parsed YAML document object.
+*
+* Note: This does not support functions. Untrusted data is safe to parse.
+*
+* @example Usage
+* ```ts
+* import { parse } from "@std/yaml/parse";
+* import { assertEquals } from "@std/assert";
+*
+* const data = parse(`
+* id: 1
+* name: Alice
+* `);
+*
+* assertEquals(data, { id: 1, name: "Alice" });
+* ```
+*
+* @throws {SyntaxError} Throws error on invalid YAML.
+* @param content YAML string to parse.
+* @param options Parsing options.
+* @returns Parsed document.
+*/ function parse(content, options = {}) {
+	content = sanitizeInput(content);
+	const documentGenerator = new LoaderState(content, {
+		...options,
+		schema: SCHEMA_MAP.get(options.schema)
+	}).readDocuments();
+	const document = documentGenerator.next().value;
+	if (!documentGenerator.next().done) throw new SyntaxError("Found more than 1 document in the stream: expected a single document");
+	return document ?? null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jsr+tmpl__core@0.6.3/node_modules/@jsr/tmpl__core/mod.js
+/**
+* Core module for @tmpl/core
+*
+* This module exports the core functionality of the @tmpl/core library.
+*/ var _computedKey = Symbol.for("Deno.customInspect");
+var TemplateClass = class TemplateClass extends String {
+	type;
+	raw;
+	data;
+	error;
+	parser;
+	constructor(type, template, substitutions, parser, options) {
+		const substTemplateRaw = [];
+		for (let i = 0; i < template.raw.length; i++) substTemplateRaw.push(template.raw[i].replace(/\\([`$])/g, "$1"));
+		const raw = String.raw({ raw: substTemplateRaw }, ...substitutions);
+		let str = raw.toString();
+		if (typeof options?.indent === "number") if (options.indent > 0) {
+			const indent = " ".repeat(options.indent);
+			str = str.replace(/^(?!\s*$)/gm, indent);
+		} else str = str.replace(/^\s+/gm, (match) => {
+			return match.slice(0, match.length + options.indent);
+		});
+		if (options?.indent === false) {
+			const lines = str.split("\n");
+			const indent = (lines.find((line) => line.trim() !== "") || "").match(/^\s+/)?.[0]?.length || 0;
+			str = lines.map((line) => line.slice(indent)).join("\n");
+		}
+		super(str);
+		this.type = type;
+		this.raw = raw;
+		this.parser = parser;
+	}
+	[_computedKey]() {
+		return this.valueOf();
+	}
+	indent(value) {
+		return new TemplateClass(this.type, { raw: [this.raw] }, [], void 0, { indent: value });
+	}
+	noindent() {
+		return this.indent(false);
+	}
+	throw() {
+		if (this.error) throw this.error;
+		return this;
+	}
+	parse(parser) {
+		this.parser = parser ?? this.parser;
+		try {
+			this.data = this.parser?.(this.raw);
+		} catch (error) {
+			this.error = error;
+		}
+		return this;
+	}
+};
+/**
+* Generic template function for any file extension
+*
+* @param extension The file extension (without the dot)
+* @returns A template tag function for the specified extension
+*/ function tag(type, parser, options) {
+	return (template, ...substitutions) => new TemplateClass(type, template, substitutions, parser, options);
+}
+const html = tag("html");
+const css = tag("css");
+const js = tag("js");
+const ts = tag("ts");
+tag("jsx");
+const tsx = tag("tsx");
+const json = tag("json", JSON.parse);
+tag("xml");
+const yaml = tag("yaml", parse);
+tag("toml");
+tag("ini");
+tag("csv");
+const md = tag("md");
+tag("tex");
+tag("rst");
+tag("sql");
+tag("graphql");
+tag("sh");
+tag("ps1");
+tag("bat");
+tag("py");
+tag("rb");
+tag("go");
+tag("rs");
+tag("c");
+tag("cpp");
+tag("cs");
+tag("java");
+tag("php");
+tag("swift");
+tag("kt");
+tag("scala");
+tag("dart");
+tag("lua");
+tag("pl");
+tag("r");
+tag("elm");
+tag("fs");
+tag("clj");
+tag("hs");
+tag("dockerfile");
+tag("makefile");
+tag("mk");
+tag("svg");
+tag("diff");
+tag("proto");
+tag("sol");
+//#endregion
 //#region src/templates/app/components/CreateDocument.ts
 const createDocumentFileTemplate = tsx`
 import type { DocumentModelModule } from "document-model";
@@ -4608,6 +6372,6 @@ function camel(name) {
 	return p.charAt(0).toLowerCase() + p.slice(1);
 }
 //#endregion
-export { tsConfigTemplate as $, documentModelHooksFileTemplate as A, claudeSettingsLocalTemplate as At, getModuleExportType as B, appDriveContentsFileTemplate as Bt, makeActionsImports as C, documentModelsIndexTemplate as Ct, documentModelSrcIndexFileTemplate as D, dockerfileTemplate as Dt, documentModelSrcUtilsTemplate as E, nginxConfTemplate as Et, documentModelPhFactoriesFileTemplate as F, folderTreeFileTemplate as Ft, documentModelGenControllerFileTemplate as G, documentModelDocumentTypeTemplate as H, documentModelOperationsModuleOperationsFileTemplate as I, appFoldersFileTemplate as It, documentEditorModuleFileTemplate as J, documentModelGenActionsFileTemplate as K, documentModelOperationsModuleErrorFileTemplate as L, appFilesFileTemplate as Lt, documentModelGenTypesTemplate as M, appEditorFileTemplate as Mt, documentModelSchemaIndexTemplate as N, appConfigFileTemplate as Nt, documentModelModuleFileTemplate as O, connectEntrypointTemplate as Ot, documentModelGenReducerFileTemplate as P, driveExplorerNavigationBreadcrumbsFileTemplate as Pt, viteConfigTemplate as Q, documentModelOperationsModuleCreatorsFileTemplate as R, emptyStateFileTemplate as Rt, makeActionImportNames as S, editorsTemplate as St, documentModelTestFileTemplate as T, switchboardEntrypointTemplate as Tt, documentModelDocumentSchemaFileTemplate as U, documentModelGenIndexFileTemplate as V, createDocumentFileTemplate as Vt, documentModelGenCreatorsFileTemplate as W, docsFromCliHelpTemplate as X, documentEditorEditorFileTemplate as Y, vitestConfigTemplate as Z, analyticsFactoryTemplate as _, gitIgnoreTemplate as _t, subgraphLibFileTemplate as a, buildPowerhouseConfigTemplate as at, upgradeManifestTemplate as b, eslintConfigTemplate as bt, relationalDbProcessorTemplate as c, exportsTemplate as ct, relationalDbFactoryTemplate as d, mcpTemplate as dt, tsconfigPathsTemplate as et, processorsIndexTemplate as f, mainTsxTemplate as ft, analyticsIndexTemplate as g, indexHtmlTemplate as gt, analyticsProcessorTemplate as h, legacyIndexHtmlTemplate as ht, customSubgraphSchemaTemplate as i, ManifestTemplate as it, documentModelGenUtilsTemplate as j, agentsTemplate as jt, documentModelIndexTemplate as k, cursorMcpTemplate as kt, relationalDbMigrationsTemplate as l, packageJsonTemplate as lt, factoryBuildersTemplate as m, indexTsTemplate as mt, documentModelSubgraphSchemaTemplate as n, styleTemplate as nt, subgraphIndexFileTemplate as o, packageJsonExportsTemplate as ot, processorsFactoryTemplate as p, licenseTemplate as pt, documentModelRootActionsFileTemplate as q, customSubgraphResolversTemplate as r, readmeTemplate as rt, relationalDbSchemaTemplate as s, packageJsonScriptsTemplate as st, documentModelSubgraphResolversTemplate as t, subgraphsIndexTemplate as tt, relationalDbIndexTemplate as u, npmrcTemplate as ut, documentModelUtilsTemplate as v, syncAndPublishWorkflowTemplate as vt, makeTestCaseForAction as w, documentModelsTemplate as wt, documentModelOperationsModuleTestFileTemplate as x, editorsIndexTemplate as xt, upgradeTransitionTemplate as y, geminiSettingsTemplate as yt, documentModelOperationModuleActionsFileTemplate as z, driveExplorerFileTemplate as zt };
+export { tsConfigTemplate as $, documentModelHooksFileTemplate as A, claudeSettingsLocalTemplate as At, getModuleExportType as B, appDriveContentsFileTemplate as Bt, makeActionsImports as C, documentModelsIndexTemplate as Ct, documentModelSrcIndexFileTemplate as D, dockerfileTemplate as Dt, documentModelSrcUtilsTemplate as E, nginxConfTemplate as Et, documentModelPhFactoriesFileTemplate as F, folderTreeFileTemplate as Ft, documentModelGenControllerFileTemplate as G, documentModelDocumentTypeTemplate as H, ts as Ht, documentModelOperationsModuleOperationsFileTemplate as I, appFoldersFileTemplate as It, documentEditorModuleFileTemplate as J, documentModelGenActionsFileTemplate as K, documentModelOperationsModuleErrorFileTemplate as L, appFilesFileTemplate as Lt, documentModelGenTypesTemplate as M, appEditorFileTemplate as Mt, documentModelSchemaIndexTemplate as N, appConfigFileTemplate as Nt, documentModelModuleFileTemplate as O, connectEntrypointTemplate as Ot, documentModelGenReducerFileTemplate as P, driveExplorerNavigationBreadcrumbsFileTemplate as Pt, viteConfigTemplate as Q, documentModelOperationsModuleCreatorsFileTemplate as R, emptyStateFileTemplate as Rt, makeActionImportNames as S, editorsTemplate as St, documentModelTestFileTemplate as T, switchboardEntrypointTemplate as Tt, documentModelDocumentSchemaFileTemplate as U, documentModelGenIndexFileTemplate as V, createDocumentFileTemplate as Vt, documentModelGenCreatorsFileTemplate as W, docsFromCliHelpTemplate as X, documentEditorEditorFileTemplate as Y, vitestConfigTemplate as Z, analyticsFactoryTemplate as _, gitIgnoreTemplate as _t, subgraphLibFileTemplate as a, buildPowerhouseConfigTemplate as at, upgradeManifestTemplate as b, eslintConfigTemplate as bt, relationalDbProcessorTemplate as c, exportsTemplate as ct, relationalDbFactoryTemplate as d, mcpTemplate as dt, tsconfigPathsTemplate as et, processorsIndexTemplate as f, mainTsxTemplate as ft, analyticsIndexTemplate as g, indexHtmlTemplate as gt, analyticsProcessorTemplate as h, legacyIndexHtmlTemplate as ht, customSubgraphSchemaTemplate as i, ManifestTemplate as it, documentModelGenUtilsTemplate as j, agentsTemplate as jt, documentModelIndexTemplate as k, cursorMcpTemplate as kt, relationalDbMigrationsTemplate as l, packageJsonTemplate as lt, factoryBuildersTemplate as m, indexTsTemplate as mt, documentModelSubgraphSchemaTemplate as n, styleTemplate as nt, subgraphIndexFileTemplate as o, packageJsonExportsTemplate as ot, processorsFactoryTemplate as p, licenseTemplate as pt, documentModelRootActionsFileTemplate as q, customSubgraphResolversTemplate as r, readmeTemplate as rt, relationalDbSchemaTemplate as s, packageJsonScriptsTemplate as st, documentModelSubgraphResolversTemplate as t, subgraphsIndexTemplate as tt, relationalDbIndexTemplate as u, npmrcTemplate as ut, documentModelUtilsTemplate as v, syncAndPublishWorkflowTemplate as vt, makeTestCaseForAction as w, documentModelsTemplate as wt, documentModelOperationsModuleTestFileTemplate as x, editorsIndexTemplate as xt, upgradeTransitionTemplate as y, geminiSettingsTemplate as yt, documentModelOperationModuleActionsFileTemplate as z, driveExplorerFileTemplate as zt };
 
-//# sourceMappingURL=templates-Bn7kq5sb.mjs.map
+//# sourceMappingURL=templates-Cu_xr8aR.mjs.map