import { n as __esmMin } from "./rolldown-runtime-CE-6LUnI.js";
//#region ../../node_modules/.pnpm/prettier@3.9.6/node_modules/prettier/plugins/estree.mjs
function ec(e) {
	return Array.isArray(e) && e.length > 0;
}
function B(e) {
	let t = new Set(e);
	return (r) => t.has(r?.type);
}
function rc(e) {
	return this[e < 0 ? this.length + e : e];
}
function Z(e, t, r) {
	if (!e.has(t)) {
		let n = r(t);
		e.set(t, n);
	}
	return e.get(t);
}
function oc(e) {
	let t = [];
	return e.this && t.push(e.this), t.push(...e.params), e.rest && t.push(e.rest), t;
}
function ee(e) {
	return Z(ic, e, oc);
}
function _i(e, t) {
	let { node: r } = e, n = 0, o = () => t(e, n++);
	r.this && e.call(o, "this"), e.each(o, "params"), r.rest && e.call(o, "rest");
}
function Ni(e) {
	if (e.rest) return !0;
	return w(0, ee(e), -1)?.type === "RestElement";
}
function zt({ node: e, parent: t }) {
	return e?.type !== "EmptyStatement" ? !1 : t.type === "IfStatement" ? t.consequent === e || t.alternate === e : t.type === "DoWhileStatement" || t.type === "ForInStatement" || t.type === "ForOfStatement" || t.type === "ForStatement" || t.type === "LabeledStatement" || t.type === "WithStatement" || t.type === "WhileStatement" ? t.body === e : !1;
}
function $e(e) {
	return e.method && e.kind === "init" || e.kind === "get" || e.kind === "set";
}
function It(e) {
	return e.range?.[1] ?? e.end;
}
function b(e) {
	let t = e.range?.[0] ?? e.start, r = (e.declaration?.decorators ?? e.decorators)?.[0];
	return r ? Math.min(b(r), t) : t;
}
function S(e) {
	let { type: t } = e;
	return t === "IfStatement" ? S(e.alternate ?? e.consequent) : t === "ForInStatement" || t === "ForOfStatement" || t === "ForStatement" || t === "LabeledStatement" || t === "WithStatement" || t === "WhileStatement" ? S(e.body) : cc.get(t)?.(e) ?? It(e);
}
function kt(e, t) {
	let r = b(e);
	return xo(r) && r === b(t);
}
function lc(e, t) {
	let r = S(e);
	return xo(r) && r === S(t);
}
function Ao(e, t) {
	return kt(e, t) && lc(e, t);
}
function ye(e) {
	return e.extra?.raw ?? e.raw;
}
function Ji(e) {
	return e.type === "BigIntLiteral" || e.type === "Literal" && !!e.bigint;
}
function Gi(e) {
	return e.type === "BooleanLiteral" || e.type === "Literal" && typeof e.value == "boolean";
}
function Ee(e) {
	return e.type === "NumericLiteral" || e.type === "Literal" && typeof e.value == "number";
}
function Xr(e) {
	return e.type === "RegExpLiteral" || e.type === "Literal" && !!e.regex;
}
function q(e) {
	return e?.type === "StringLiteral" || e?.type === "Literal" && typeof e.value == "string";
}
function Ir(e) {
	if (e.type !== "ImportSpecifier" && e.type !== "ExportSpecifier") return !1;
	let { local: t, [e.type === "ImportSpecifier" ? "imported" : "exported"]: r } = e;
	return t.type !== r.type || !Ao(t, r) ? !1 : q(t) ? t.value === r.value && ye(t) === ye(r) : t.type === "Identifier" ? t.name === r.name : !1;
}
function Ec(e, t) {
	return mc(e) || fc(e, t) || Dc(e, t) ? !1 : e.type === "EmptyStatement" ? zt({
		node: e,
		parent: t[0]
	}) : !(yc(e, t) || e.type === "TSTypeAnnotation" && t[0].type === "TSPropertySignature");
}
function dc(e) {
	let t = e.type || e.kind || "(unknown type)", r = String(e.name || e.id && (typeof e.id == "object" ? e.id.name : e.id) || e.key && (typeof e.key == "object" ? e.key.name : e.key) || e.value && (typeof e.value == "object" ? "" : String(e.value)) || e.operator || "");
	return r.length > 20 && (r = r.slice(0, 19) + "…"), t + (r ? " " + r : "");
}
function To(e, t) {
	(e.comments ?? (e.comments = [])).push(t), t.printed = !1, t.nodeDescription = dc(e);
}
function K(e, t) {
	t.leading = !0, t.trailing = !1, To(e, t);
}
function Te(e, t, r) {
	t.leading = !1, t.trailing = !1, r && (t.marker = r), To(e, t);
}
function X(e, t) {
	t.leading = !1, t.trailing = !0, To(e, t);
}
function Kr(e) {
	return (t, r, n) => {
		if (r === !1) return !1;
		let o = !!n?.backwards, { length: i } = t, s = r;
		for (; s >= 0 && s < i;) {
			let u = t.charAt(s);
			if (e instanceof RegExp) {
				if (!e.test(u)) return s;
			} else if (!e.includes(u)) return s;
			o ? s-- : s++;
		}
		return s === -1 || s === i ? s : !1;
	};
}
function Cc(e, t) {
	if (t === !1) return !1;
	if (e.charAt(t) === "/" && e.charAt(t + 1) === "*") {
		for (let r = t + 2; r < e.length; ++r) if (e.charAt(r) === "*" && e.charAt(r + 1) === "/") return r + 2;
	}
	return t;
}
function Fc(e, t, r) {
	if (t === !1) return !1;
	let n = !!r?.backwards, o = e.charAt(t);
	if (n) {
		if (e.charAt(t - 1) === "\r" && o === `
`) return t - 2;
		if (Qi(o)) return t - 1;
	} else {
		if (o === "\r" && e.charAt(t + 1) === `
`) return t + 2;
		if (Qi(o)) return t + 1;
	}
	return t;
}
function xc(e, t) {
	return t === !1 ? !1 : e.charAt(t) === "/" && e.charAt(t + 1) === "/" ? $i(e, t) : t;
}
function Ac(e, t) {
	let r = null, n = t;
	for (; n !== r;) r = n, n = at(e, n), n = tr(e, n), n = rr(e, n), n = pt(e, n);
	return n;
}
function Tc(e, t) {
	let r = Wt(e, t);
	return r === !1 ? "" : e.charAt(r);
}
function gc(e, t, r = {}) {
	let n = at(e, r.backwards ? t - 1 : t, r);
	return n !== pt(e, n, r);
}
function hc(e, t, r) {
	for (let n = t; n < r; ++n) if (e.charAt(n) === `
`) return !0;
	return !1;
}
function Bc(e) {
	let t;
	return e.type === "ImportExpression" || e.type === "TSImportType" ? (t = [e.source], e.options && t.push(e.options)) : e.type === "TSExternalModuleReference" ? t = [e.expression] : t = e.arguments, t;
}
function se(e) {
	return Z(Sc, e, Bc);
}
function kr(e, t) {
	let { node: r } = e;
	r.type === "ImportExpression" || r.type === "TSImportType" ? (e.call(() => t(e, 0), "source"), r.options && e.call(() => t(e, 1), "options")) : r.type === "TSExternalModuleReference" ? e.call(() => t(e, 0), "expression") : e.each(t, "arguments");
}
function go(e, t) {
	if (e.type === "ImportExpression" || e.type === "TSImportType") {
		if (t === 0 || t === (e.options ? -2 : -1)) return ["source"];
		if (e.options && (t === 1 || t === -1)) return ["options"];
		throw new RangeError("Invalid argument index");
	}
	if (e.type === "TSExternalModuleReference") {
		if (t === 0 || t === -1) return ["expression"];
	} else if (t < 0 && (t = e.arguments.length + t), t >= 0 && t < e.arguments.length) return ["arguments", t];
	throw new RangeError("Invalid argument index");
}
function Ic(e) {
	return V(0, e, /[^\n]/g, " ");
}
function kc(e, t) {
	for (let r of t) {
		let n = b(r), o = S(r);
		e = e.slice(0, n) + Zi(e.slice(n, o)) + e.slice(o);
	}
	return e;
}
function ce(e) {
	let t = e[zi];
	return Z(wc, t, (r) => kc(e.originalText, r));
}
function es(e, t) {
	let r = S(e) - 1;
	if (t.originalText[r] === ")") return r;
}
function Lc(e, t) {
	if (es(e, t) === void 0) return;
	let n = ce(t), o = S(e.typeArguments ?? e.callee), i = n.indexOf("(", o);
	if (i !== -1) return i;
}
function ts(e, t, r) {
	let n = es(e, r);
	if (n === void 0 || S(t) > n) return !1;
	let o = Lc(e, r);
	return o === void 0 ? !1 : b(t) > o;
}
function Ge(e) {
	return e?.type === "ObjectProperty" || e?.type === "Property" && !$e(e);
}
function yt(e) {
	return e.value.trim() === "prettier-ignore" && !e.unignore;
}
function nr(e) {
	return Z(Oc, e, (t) => le(t) && t.value[0] === "*" && /@(?:type|satisfies)\b/.test(t.value));
}
function $r({ comment: e, enclosingNode: t, followingNode: r, options: n }) {
	if ((t?.type === "ForInStatement" || t?.type === "ForOfStatement" || t?.type === "ForStatement") && r && r === t.body) {
		let o = ce(n).lastIndexOf(")", b(r));
		if (b(e) > o) return K(r, e), !0;
	}
	return !1;
}
function Qr(e, t) {
	e.type === "BlockStatement" ? or(e, t) : K(e, t);
}
function or(e, t) {
	let r = (e.body || e.properties).find(({ type: n }) => n !== "EmptyStatement");
	r ? K(r, t) : Te(e, t);
}
function zr({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: o, options: i }) {
	return r?.type !== "IfStatement" || !n ? !1 : Je(o, S(e)) === ")" ? (X(t, e), !0) : n === r.consequent ? (K(n, e), !0) : t === r.consequent && n === r.alternate ? Mc({
		comment: e,
		precedingNode: t,
		enclosingNode: r,
		followingNode: n,
		text: o,
		options: i
	}) : !1;
}
function Mc({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: o, options: i }) {
	let s = ce(i).indexOf("else", S(r.consequent));
	return b(e) >= s ? (K(n, e), !0) : !(t.type === "BlockStatement") && wr(e, o) && !te(o, S(t), b(e)) ? (X(t, e), !0) : (Te(r, e), !0);
}
function Zr({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: o }) {
	return r?.type === "SwitchStatement" && r.cases.length === 0 && !n && t === r.discriminant && Je(o, S(e)) === "}" ? (Te(r, e), !0) : !1;
}
function en({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: o }) {
	return (r?.type === "WhileStatement" || r?.type === "WithStatement") && n ? Je(o, S(e)) === ")" ? (X(t, e), !0) : r.body === n ? (K(n, e), !0) : !1 : !1;
}
function So(e, { comment: t, text: r, options: n }) {
	if (pe(e) && ho(t, r) && !yt(t)) {
		let i = ce(n).slice(S(t), b(e));
		return /^[ \t]*$/.test(i);
	}
	return !1;
}
function Bo(e, t) {
	return K(So(e, t) ? e.types[0] : e, t.comment), !0;
}
function _c(e) {
	return [
		bo,
		fs,
		is,
		ps,
		Rc,
		zr,
		en,
		Zr,
		os,
		ss,
		$r,
		Hc,
		Xc,
		Po,
		ls,
		Kc,
		us,
		cs,
		Wc,
		rl,
		Io,
		ko,
		ys
	].some((t) => t(e));
}
function Nc(e) {
	return [
		bo,
		vc,
		ps,
		is,
		ls,
		zr,
		en,
		Zr,
		os,
		ss,
		$r,
		cs,
		Yc,
		Vc,
		Po,
		ms,
		el,
		tl,
		nl,
		Io,
		sl,
		Ds,
		ol,
		ko
	].some((t) => t(e));
}
function jc(e) {
	return [
		bo,
		fs,
		zr,
		en,
		Zr,
		$r,
		us,
		Po,
		ms,
		Io,
		Uc,
		Gc,
		zc,
		Ds,
		ko,
		ys
	].some((t) => t(e));
}
function vc({ comment: e, followingNode: t }) {
	return t && nr(e) ? (K(t, e), !0) : !1;
}
function os({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
	return r?.type !== "TryStatement" && r?.type !== "CatchClause" || !n ? !1 : r.type === "CatchClause" && t ? (X(t, e), !0) : n.type === "BlockStatement" ? (or(n, e), !0) : n.type === "TryStatement" ? (Qr(n.finalizer, e), !0) : n.type === "CatchClause" ? (Qr(n.body, e), !0) : !1;
}
function Rc({ comment: e, enclosingNode: t, followingNode: r }) {
	return N(t) && r?.type === "Identifier" ? (K(t, e), !0) : !1;
}
function Wc({ comment: e, enclosingNode: t, followingNode: r, options: n }) {
	return !n.experimentalTernaries || !(t?.type === "ConditionalExpression" || Qe(t)) ? !1 : r?.type === "ConditionalExpression" || Qe(r) ? (Te(t, e), !0) : !1;
}
function is({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: o, options: i }) {
	let s = t && !te(o, S(t), b(e));
	return (!t || !s) && (r?.type === "ConditionalExpression" || Qe(r)) && n ? i.experimentalTernaries && r.alternate === n && !(le(e) && !te(i.originalText, b(e), S(e))) ? (Te(r, e), !0) : (K(n, e), !0) : !1;
}
function ss({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
	if (Jc(r)) {
		let { decorators: o } = r;
		if (j(o) && n?.type !== "Decorator") return X(w(0, o, -1), e), !0;
		if (r.body && n === r.body) return or(r.body, e), !0;
		if (n) {
			let { superClass: i } = r;
			if (i && n === i && t && (t === r.id || t === r.typeParameters)) return X(t, e), !0;
			for (let s of [
				"implements",
				"extends",
				"mixins"
			]) if (r[s] && n === r[s][0]) return t && (t === r.id || t === r.typeParameters || t === i) ? X(t, e) : Te(r, e, s), !0;
		}
	}
	return !1;
}
function us({ placement: e, comment: t, precedingNode: r, enclosingNode: n, followingNode: o, text: i }) {
	return n && r && Je(i, S(t)) === "(" && (n.type === "Property" || n.type === "TSDeclareMethod" || n.type === "TSAbstractMethodDefinition") && r.type === "Identifier" && n.key === r && Je(i, S(r)) !== ":" ? (X(r, t), !0) : rs(n) && !o && e === "remaining" ? (X(Je(i, S(t)) === "(" ? r : n, t), !0) : r?.type === "Decorator" && rs(n) && (Le(t) || e === "ownLine") ? (X(r, t), !0) : !1;
}
function Gc({ comment: e, precedingNode: t, enclosingNode: r, text: n }) {
	return Je(n, S(e)) !== "(" ? !1 : t && as(r) ? (X(t, e), !0) : !1;
}
function Uc({ comment: e, enclosingNode: t, text: r }) {
	if (t?.type !== "ArrowFunctionExpression") return !1;
	let n = Wt(r, S(e));
	return n !== !1 && r.slice(n, n + 2) === "=>" ? (Te(t, e, "commentBeforeArrow"), !0) : !1;
}
function ns(e, t, r) {
	if (b(t) >= S(e)) return !1;
	if (S(t) <= b(e)) return !1;
	let u = ce(r);
	return u.slice(0, b(t)).trimEnd().endsWith("(") && u.slice(S(t)).trimStart().startsWith(")");
}
function bo({ comment: e, enclosingNode: t, options: r }) {
	if (!t) return !1;
	if (Dt(t) && se(t).length === 0 && ns(t, e, r)) return Te(t, e), !0;
	let n = Es(t) || qc(t) || t.type === "HookTypeAnnotation" ? t : t.type === "MethodDefinition" || t.type === "TSAbstractMethodDefinition" || t.type === "Property" && $e(t) ? t.value : void 0;
	return n && ee(n).length === 0 && ns(n, e, r) ? (Te(n, e), !0) : !1;
}
function ps({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: o }) {
	return t?.type === "FunctionTypeParam" && r?.type === "FunctionTypeAnnotation" && n?.type !== "FunctionTypeParam" ? (X(t, e), !0) : t?.type === "ComponentTypeParameter" && (r?.type === "DeclareComponent" || r?.type === "ComponentTypeAnnotation") && n?.type !== "ComponentTypeParameter" ? (X(t, e), !0) : (t?.type === "Identifier" || t?.type === "AssignmentPattern" || t?.type === "ObjectPattern" || t?.type === "ArrayPattern" || t?.type === "RestElement" || t?.type === "TSParameterProperty") && (Es(r) || (r?.type === "TSAbstractMethodDefinition" || r?.type === "MethodDefinition") && r.value.type === "TSEmptyBodyFunctionExpression") && Je(o, S(e)) === ")" ? (X(t, e), !0) : (t?.type === "ComponentParameter" || t?.type === "RestElement") && (r?.type === "ComponentDeclaration" || r?.type === "DeclareComponent") && Je(o, S(e)) === ")" ? (X(t, e), !0) : !le(e) && n?.type === "BlockStatement" && as(r) && (r.type === "MethodDefinition" ? r.value.body : r.body) === n && Wt(o, S(e)) === b(n) ? (or(n, e), !0) : !1;
}
function cs({ comment: e, enclosingNode: t }) {
	return t?.type === "LabeledStatement" ? (K(t, e), !0) : !1;
}
function Yc({ comment: e, precedingNode: t, enclosingNode: r, options: n }) {
	return Tt(r) && r.callee === t && r.arguments.length > 0 && ts(r, e, n) ? (K(r.arguments[0], e), !0) : !1;
}
function Hc({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
	return pe(r) ? (yt(e) && (n.prettierIgnore = !0, e.unignore = !0), t ? (X(t, e), !0) : !1) : (pe(n) && yt(e) && (n.types[0].prettierIgnore = !0, e.unignore = !0), !1);
}
function Xc({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
	return r && r.type === "MatchOrPattern" ? (yt(e) && (n.prettierIgnore = !0, e.unignore = !0), t ? (X(t, e), !0) : !1) : (n && n.type === "MatchOrPattern" && yt(e) && (n.types[0].prettierIgnore = !0, e.unignore = !0), !1);
}
function Vc({ comment: e, enclosingNode: t }) {
	return Ge(t) ? (K(t, e), !0) : !1;
}
function Po({ comment: e, enclosingNode: t, ast: r, isLastComment: n }) {
	return r?.body?.length === 0 ? (n ? Te(r, e) : K(r, e), !0) : t?.type === "Program" && t.body.length === 0 && !j(t.directives) ? (n ? Te(t, e) : K(t, e), !0) : !1;
}
function ls({ comment: e, precedingNode: t, enclosingNode: r, text: n }) {
	if (r?.type === "ImportSpecifier" || r?.type === "ExportSpecifier") return K(r, e), !0;
	let o = t?.type === "ImportSpecifier" && r?.type === "ImportDeclaration", i = t?.type === "ExportSpecifier" && r?.type === "ExportNamedDeclaration";
	return (o || i) && J(n, S(e)) ? (X(t, e), !0) : !1;
}
function Kc({ comment: e, enclosingNode: t }) {
	return t?.type === "AssignmentPattern" ? (K(t, e), !0) : !1;
}
function ms(e) {
	let { comment: t, enclosingNode: r, followingNode: n, options: o, placement: i } = e;
	if ($c(r) && n && i === "endOfLine" && (Qc(n) || le(t))) return Bo(n, e);
	if (Vr(r) && n) {
		let s = r.id, u = ce(o).indexOf("=", S(s));
		if (b(t) >= u) return Bo(n, e);
	}
	return !1;
}
function zc({ comment: e, enclosingNode: t, precedingNode: r, followingNode: n, text: o }) {
	return !n && (t?.type === "TSMethodSignature" || t?.type === "TSDeclareFunction" || t?.type === "TSAbstractMethodDefinition") && (!r || r !== t.returnType) && Je(o, S(e)) === ";" ? (X(t, e), !0) : !1;
}
function fs({ comment: e, enclosingNode: t, followingNode: r }) {
	if (yt(e) && t?.type === "TSMappedType" && r === t.key) return t.prettierIgnore = !0, e.unignore = !0, !0;
}
function Zc(e, t, r) {
	let n = ce(r).indexOf("[", b(e));
	return S(t) < n;
}
function Io({ comment: e, enclosingNode: t, options: r }) {
	if (t?.type === "TSMappedType" && Zc(t, e, r)) return Te(t, e), !0;
}
function el({ comment: e, enclosingNode: t, followingNode: r }) {
	return !t || t.type !== "SwitchCase" || t.test || !r || r !== t.consequent[0] ? !1 : (r.type === "BlockStatement" && Le(e) ? or(r, e) : Te(t, e), !0);
}
function tl({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
	return pe(t) && (Yi(r) && !n || At(r) || pe(r)) ? (X(w(0, t.types, -1), e), !0) : !1;
}
function rl({ comment: e, enclosingNode: t, precedingNode: r, followingNode: n }) {
	if ((t?.type === "ObjectPattern" || t?.type === "ArrayPattern") && n?.type === "TSTypeAnnotation") return r ? X(r, e) : Te(t, e), !0;
}
function nl({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: o }) {
	return !n && r?.type === "UnaryExpression" && (t?.type === "LogicalExpression" || t?.type === "BinaryExpression") && te(o, b(r.argument), b(t.right)) && wr(e, o) && !te(o, b(t.right), b(e)) ? (X(t.right, e), !0) : !1;
}
function ol({ enclosingNode: e, followingNode: t, comment: r }) {
	if (e && (e.type === "TSPropertySignature" || e.type === "ObjectTypeProperty") && (pe(t) || At(t))) return K(t, r), !0;
}
function ko({ enclosingNode: e, precedingNode: t, followingNode: r, comment: n, text: o }) {
	if (de(e) && t === e.expression && !wr(n, o)) return r ? K(r, n) : X(e, n), !0;
}
function il(e, t, r) {
	let n = ce(r).lastIndexOf("=>", b(t.body));
	return S(e) < n;
}
function sl({ comment: e, enclosingNode: t, followingNode: r, precedingNode: n, options: o }) {
	return t?.type !== "ArrowFunctionExpression" || !r || !n || il(e, t, o) ? !1 : (Qr(r, e), !0);
}
function Ds({ comment: e, enclosingNode: t, precedingNode: r, followingNode: n }) {
	if (!n && t && r) {
		if (t.type === "ExpressionStatement" && t.expression === r) return X(t, e), !0;
		let o = r.type === "SequenceExpression", i = r.type === "AssignmentExpression";
		if ((o || i) && (t.type === "ArrowFunctionExpression" && t.body === r || t.type === "VariableDeclarator" && t.init === r || t.type === "ReturnStatement" && t.argument === r || t.type === "AssignmentExpression" && t.right === r)) return X(o ? w(0, r.expressions, -1) : r.right, e), !0;
	}
	return !1;
}
function ys(e) {
	let { followingNode: t, comment: r } = e;
	return So(t, e) ? (K(t.types[0], r), !0) : !1;
}
function al(e, { parser: t }) {
	if (t === "flow" || t === "hermes" || t === "babel-flow") return e = V(0, e, /[\s(]/g, ""), e === "" || e === "/*" || e === "/*::";
}
function x(e, t, r) {
	if (!j(e?.comments)) return !1;
	let n = Fs(t, r);
	return n ? e.comments.some(n) : !0;
}
function re(e, t, r) {
	if (!Array.isArray(e?.comments)) return [];
	let n = Fs(t, r);
	return n ? e.comments.filter(n) : e.comments;
}
function Lt(e) {
	return e?.prettierIgnore || x(e, g.PrettierIgnore);
}
function tn(e) {
	let { node: t } = e;
	return (t.type === "FunctionExpression" || t.type === "ArrowFunctionExpression") && (e.key === "callee" && M(e.parent) || e.key === "tag" && e.parent.type === "TaggedTemplateExpression");
}
function ir(e) {
	return pl.get(e);
}
function Lr(e, t) {
	return !(ir(t) !== ir(e) || e === "**" || xs[e] && xs[t] || t === "%" && rn[e] || e === "%" && rn[t] || t !== e && rn[t] && rn[e] || nn[e] && nn[t]);
}
function As(e) {
	return !!nn[e] || e === "|" || e === "^" || e === "&";
}
function Ts(e) {
	return e.type === "LogicalExpression" && e.operator === "??";
}
function Ce(e, t) {
	switch (e.type) {
		case "BinaryExpression":
		case "LogicalExpression":
		case "AssignmentExpression":
		case "NGPipeExpression": return Ce(e.left, t);
		case "MemberExpression":
		case "OptionalMemberExpression": return Ce(e.object, t);
		case "TaggedTemplateExpression": return e.tag.type === "FunctionExpression" ? !1 : Ce(e.tag, t);
		case "CallExpression":
		case "OptionalCallExpression": return e.callee.type === "FunctionExpression" ? !1 : Ce(e.callee, t);
		case "ConditionalExpression": return Ce(e.test, t);
		case "UpdateExpression": return !e.prefix && Ce(e.argument, t);
		case "BindExpression": return e.object && Ce(e.object, t);
		case "SequenceExpression": return Ce(e.expressions[0], t);
		case "ChainExpression":
		case "TSNonNullExpression":
		case "TSSatisfiesExpression":
		case "TSAsExpression":
		case "AsExpression":
		case "AsConstExpression":
		case "SatisfiesExpression": return Ce(e.expression, t);
		default: return t(e);
	}
}
function cl(e) {
	let { key: t, parent: r } = e;
	return t === "expression" && r.type === "TSNonNullExpression" || t === "object" && r.type === "MemberExpression" && !r.optional || t === "callee" && r.type === "CallExpression" && !r.optional || t === "callee" && r.type === "NewExpression" || t === "tag" && r.type === "TaggedTemplateExpression";
}
function ml(e) {
	let { node: t } = e, r = t;
	for (; r.type === "TSNonNullExpression";) if (r = r.expression, gs(r)) return !1;
	return ll(r) ? gs(t) ? !0 : !(e.key === "expression" && e.parent.type === "TSNonNullExpression") : !1;
}
function hs(e) {
	return (e.node.type === "ChainExpression" || ml(e)) && cl(e);
}
function Ss(e) {
	let { node: t } = e;
	if (t.type !== "Identifier") return !1;
	if (t.extra?.parenthesized && /^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/.test(t.name)) return !0;
	let { key: r, parent: n } = e;
	if (r === "left" && (t.name === "async" && !n.await || t.name === "let") && n.type === "ForOfStatement") return !0;
	if (t.name === "let") {
		let o = e.findAncestor((i) => i.type === "ForOfStatement" || i.type === "ForInStatement")?.left;
		if (o && Ce(o, (i) => i === t)) return !0;
	}
	if (r === "object" && t.name === "let" && n.type === "MemberExpression" && n.computed && !n.optional) {
		let o = e.findAncestor((s) => s.type === "ExpressionStatement" || s.type === "ForStatement" || s.type === "ForInStatement"), i = o ? o.type === "ExpressionStatement" ? o.expression : o.type === "ForStatement" ? o.init : o.left : void 0;
		if (i && Ce(i, (s) => s === t)) return !0;
	}
	if (r === "expression") switch (t.name) {
		case "await":
		case "interface":
		case "module":
		case "using":
		case "yield":
		case "let":
		case "component":
		case "hook":
		case "type": {
			let o = e.findAncestor((i) => !de(i));
			if (o !== n && o.type === "ExpressionStatement") return !0;
		}
	}
	return !1;
}
function fl(e) {
	return e !== null && typeof e == "object";
}
function* Dl(e, t) {
	let { getVisitorKeys: r, filter: n = () => !0 } = t, o = (i) => on(i) && n(i);
	for (let i of r(e)) {
		let s = e[i];
		if (Array.isArray(s)) for (let u of s) o(u) && (yield u);
		else o(s) && (yield s);
	}
}
function* yl(e, t) {
	let r = [e];
	for (let n = 0; n < r.length; n++) {
		let o = r[n];
		for (let i of Dl(o, t)) yield i, r.push(i);
	}
}
function Bs(e, { getVisitorKeys: t, predicate: r }) {
	for (let n of yl(e, { getVisitorKeys: t })) if (r(n)) return !0;
	return !1;
}
function Mr(e) {
	if (Or !== null && typeof Or.property) {
		let t = Or;
		return Or = Mr.prototype = null, t;
	}
	return Or = Mr.prototype = e ?? Object.create(null), new Mr();
}
function wo(e) {
	return Mr(e);
}
function dl(e, t = "type") {
	wo(e);
	function r(n) {
		let o = n[t], i = e[o];
		if (!Array.isArray(i)) throw Object.assign(/* @__PURE__ */ new Error(`Missing visitor keys for '${o}'.`), { node: n });
		return i;
	}
	return r;
}
function _r(e, t) {
	return t(e) || Bs(e, {
		getVisitorKeys: un,
		predicate: t
	});
}
function sr(e) {
	return e.type === "AssignmentExpression" || e.type === "BinaryExpression" || e.type === "LogicalExpression" || e.type === "NGPipeExpression" || e.type === "ConditionalExpression" || M(e) || N(e) || e.type === "SequenceExpression" || e.type === "TaggedTemplateExpression" || e.type === "BindExpression" || e.type === "UpdateExpression" && !e.prefix || de(e) || We(e);
}
function Ps(e) {
	return e.expressions ? e.expressions[0] : e.left ?? e.test ?? e.callee ?? e.object ?? e.tag ?? e.argument ?? e.expression;
}
function an(e) {
	if (e.expressions) return ["expressions", 0];
	if (e.left) return ["left"];
	if (e.test) return ["test"];
	if (e.object) return ["object"];
	if (e.callee) return ["callee"];
	if (e.tag) return ["tag"];
	if (e.argument) return ["argument"];
	if (e.expression) return ["expression"];
	throw new Error("Unexpected node has no left side.");
}
function Oe(e, t) {
	return H(t) ? Lt(t) : x(t, g.Leading, (r) => J(e, S(r)));
}
function Fl(e, t) {
	if (Oe(t.originalText, e) || x(e, g.Leading, (r) => te(t.originalText, b(r), S(r))) && !H(e)) return !0;
	if (sr(e)) {
		let r = e, n;
		for (; n = Ps(r);) if (r = n, Oe(t.originalText, r)) return !0;
	}
	return !1;
}
function pn(e, t) {
	return Z(xl, e, (r) => Fl(r, t));
}
function Pe(e) {
	for (; We(e);) e = e.expression;
	return e;
}
function Is(e, t, r) {
	let { node: n, key: o, parent: i } = e;
	switch (i.type) {
		case "ReturnStatement":
		case "ThrowStatement":
			if (Al(e, t)) return !1;
			break;
		case "ParenthesizedExpression": return !1;
		case "ClassDeclaration":
		case "ClassExpression":
			if (o === "superClass") {
				let s = Pe(n);
				if (s.type === "ArrowFunctionExpression" || s.type === "AssignmentExpression" || s.type === "AwaitExpression" || s.type === "BinaryExpression" || s.type === "ConditionalExpression" || s.type === "LogicalExpression" || s.type === "NewExpression" || s.type === "ObjectExpression" || s.type === "SequenceExpression" || s.type === "TaggedTemplateExpression" || s.type === "UnaryExpression" || s.type === "UpdateExpression" || s.type === "YieldExpression" || s.type === "ClassExpression" && j(s.decorators)) return !0;
			}
			break;
		case "ExportDefaultDeclaration":
			if (ks(e, t, r)) return !0;
			break;
		case "Decorator":
			if (o === "expression" && !Tl(n)) return !0;
			break;
		case "TypeAnnotation":
			if (e.match(void 0, void 0, (s, u) => u === "returnType" && s.type === "ArrowFunctionExpression") && !(n.type === "NullableTypeAnnotation" && e.call(() => r(e, t), "typeAnnotation")) && gl(n)) return !0;
			break;
		case "VariableDeclarator":
			if (o === "init" && e.match(void 0, void 0, (s, u) => u === "declarations" && s.type === "VariableDeclaration", (s, u) => u === "left" && s.type === "ForInStatement")) return !0;
			break;
		case "TSInstantiationExpression":
			if (o === "expression" && (n.type === "AwaitExpression" || n.type === "YieldExpression")) return !0;
			break;
	}
}
function Al(e, t) {
	let { key: r, parent: n } = e;
	if (!(r === "argument" && ut(n))) return !1;
	let { node: o } = e;
	return !!((o.type === "SequenceExpression" || o.type === "AssignmentExpression") && pn(o, t));
}
function ks(e, t, r) {
	let { node: n, parent: o } = e;
	return n.type === "FunctionExpression" || n.type === "ClassExpression" ? o.type === "ExportDefaultDeclaration" || !r(e, t) : !sr(n) || o.type !== "ExportDefaultDeclaration" && r(e, t) ? !1 : e.call(() => ks(e, t, r), ...an(n));
}
function Tl(e) {
	return e.type === "ChainExpression" && (e = e.expression), Lo(e) || M(e) && !e.optional && Lo(e.callee);
}
function Lo(e) {
	return e.type === "Identifier" ? !0 : N(e) ? !e.computed && !e.optional && e.property.type === "Identifier" && Lo(e.object) : !1;
}
function gl(e) {
	return _r(e, (t) => t.type === "ObjectTypeAnnotation" && _r(t, (r) => r.type === "FunctionTypeAnnotation"));
}
function ws(e, t) {
	if (e.isRoot) return !1;
	let { node: r, key: n, parent: o } = e;
	if (t.__isInHtmlInterpolation && !t.bracketSpacing && Bl(r) && Nr(e)) return !0;
	if (hl(r)) return !1;
	if (r.type === "Identifier") return Ss(e);
	if (r.type === "ObjectExpression" || r.type === "FunctionExpression" || r.type === "ClassExpression" || r.type === "DoExpression") {
		let s = e.findAncestor((u) => u.type === "ExpressionStatement")?.expression;
		if (s && Ce(s, (u) => u === r)) return !0;
	}
	if (r.type === "ObjectExpression") {
		let s = e.findAncestor((u) => u.type === "ArrowFunctionExpression")?.body;
		if (s && s.type !== "SequenceExpression" && s.type !== "AssignmentExpression" && Ce(s, (u) => u === r)) return !0;
	}
	let i = Is(e, t, ws);
	if (typeof i == "boolean") return i;
	switch (r.type) {
		case "UpdateExpression": if (o.type === "UnaryExpression") return r.prefix && (r.operator === "++" && o.operator === "+" || r.operator === "--" && o.operator === "-");
		case "UnaryExpression": switch (o.type) {
			case "UnaryExpression": return r.operator === o.operator && (r.operator === "+" || r.operator === "-");
			case "BindExpression": return !0;
			case "MemberExpression":
			case "OptionalMemberExpression": return n === "object";
			case "TaggedTemplateExpression": return !0;
			case "NewExpression":
			case "CallExpression":
			case "OptionalCallExpression": return n === "callee";
			case "BinaryExpression": return n === "left" && r.type === "UnaryExpression" && (o.operator === "in" || o.operator === "instanceof") ? !0 : n === "left" && o.operator === "**";
			case "TSNonNullExpression": return !0;
			default: return !1;
		}
		case "BinaryExpression":
			if (o.type === "UpdateExpression" || r.operator === "in" && Sl(e)) return !0;
			if (r.operator === "|>" && r.extra?.parenthesized) {
				let s = e.grandparent;
				if (s.type === "BinaryExpression" && s.operator === "|>") return !0;
			}
		case "TSTypeAssertion":
		case "TSAsExpression":
		case "TSSatisfiesExpression":
		case "AsExpression":
		case "AsConstExpression":
		case "SatisfiesExpression":
		case "LogicalExpression":
			switch (o.type) {
				case "TSAsExpression":
				case "TSSatisfiesExpression":
				case "AsExpression":
				case "AsConstExpression":
				case "SatisfiesExpression": return !de(r);
				case "ConditionalExpression": return de(r) || Ts(r);
				case "CallExpression":
				case "NewExpression":
				case "OptionalCallExpression": return n === "callee";
				case "ClassExpression":
				case "ClassDeclaration": return n === "superClass";
				case "TSTypeAssertion":
				case "TaggedTemplateExpression":
				case "JSXSpreadAttribute":
				case "SpreadElement":
				case "BindExpression":
				case "AwaitExpression":
				case "TSNonNullExpression":
				case "UpdateExpression": return !0;
				case "UnaryExpression":
					if (!x(r)) return !0;
					break;
				case "MemberExpression":
				case "OptionalMemberExpression": return n === "object";
				case "AssignmentExpression":
				case "AssignmentPattern": return n === "left" && (r.type === "TSTypeAssertion" || de(r));
				case "LogicalExpression": if (r.type === "LogicalExpression") return o.operator !== r.operator;
				case "BinaryExpression": {
					let { operator: s, type: u } = r;
					if (!s && u !== "TSTypeAssertion") return !0;
					let a = ir(s), c = o.operator, f = ir(c);
					return !!(f > a || n === "right" && f === a || f === a && !Lr(c, s) || f < a && s === "%" && (c === "+" || c === "-") || As(c));
				}
				default: return !1;
			}
			break;
		case "SequenceExpression": return o.type !== "ForStatement";
		case "YieldExpression": if (o.type === "AwaitExpression" || o.type === "TSTypeAssertion") return !0;
		case "AwaitExpression": switch (o.type) {
			case "TaggedTemplateExpression":
			case "UnaryExpression":
			case "LogicalExpression":
			case "SpreadElement":
			case "TSAsExpression":
			case "TSSatisfiesExpression":
			case "TSNonNullExpression":
			case "AsExpression":
			case "AsConstExpression":
			case "SatisfiesExpression":
			case "BindExpression": return !0;
			case "MemberExpression":
			case "OptionalMemberExpression": return n === "object";
			case "NewExpression":
			case "CallExpression":
			case "OptionalCallExpression": return n === "callee";
			case "ConditionalExpression": return n === "test";
			case "BinaryExpression": return !(!r.argument && o.operator === "|>");
			default: return !1;
		}
		case "TSFunctionType": if (e.match((s) => s.type === "TSFunctionType", (s, u) => u === "typeAnnotation" && s.type === "TSTypeAnnotation", (s, u) => u === "returnType" && s.type === "ArrowFunctionExpression")) return !0;
		case "TSConditionalType":
		case "TSConstructorType":
		case "ConditionalTypeAnnotation":
			if (n === "extendsType" && Qe(r) && o.type === r.type || n === "constraint" && r.type === "TSConditionalType" && o.type === "TSTypeParameter" || n === "typeAnnotation" && r.type === "ConditionalTypeAnnotation" && o.type === "TypeAnnotation" && e.grandparent.type === "TypeParameter" && e.grandparent.bound === o && e.grandparent.usesExtendsBound || n === "checkType" && Qe(o)) return !0;
			if (n === "extendsType" && o.type === "TSConditionalType") {
				let { typeAnnotation: s } = r.returnType || r.typeAnnotation;
				if (s.type === "TSTypePredicate" && s.typeAnnotation && (s = s.typeAnnotation.typeAnnotation), s.type === "TSInferType" && s.typeParameter.constraint) return !0;
			}
		case "TSUnionType":
		case "TSIntersectionType": if (pe(o) || At(o)) return !0;
		case "TSInferType": if (r.type === "TSInferType") {
			if (o.type === "TSRestType") return !1;
			if (n === "types" && (o.type === "TSUnionType" || o.type === "TSIntersectionType") && r.typeParameter.type === "TSTypeParameter" && r.typeParameter.constraint) return !0;
		}
		case "TSTypeOperator": return o.type === "TSArrayType" || o.type === "TSOptionalType" || o.type === "TSRestType" || n === "objectType" && o.type === "TSIndexedAccessType" || o.type === "TSTypeOperator" || o.type === "TSTypeAnnotation" && e.grandparent.type.startsWith("TSJSDoc");
		case "TSTypeQuery": return n === "objectType" && o.type === "TSIndexedAccessType" || n === "elementType" && o.type === "TSArrayType";
		case "TypeOperator": return o.type === "ArrayTypeAnnotation" || o.type === "NullableTypeAnnotation" || n === "objectType" && (o.type === "IndexedAccessType" || o.type === "OptionalIndexedAccessType") || o.type === "TypeOperator";
		case "TypeofTypeAnnotation":
		case "KeyofTypeAnnotation": return n === "objectType" && (o.type === "IndexedAccessType" || o.type === "OptionalIndexedAccessType") || n === "elementType" && o.type === "ArrayTypeAnnotation";
		case "ArrayTypeAnnotation": return o.type === "NullableTypeAnnotation";
		case "IntersectionTypeAnnotation":
		case "UnionTypeAnnotation": return o.type === "TypeOperator" || o.type === "KeyofTypeAnnotation" || o.type === "ArrayTypeAnnotation" || o.type === "NullableTypeAnnotation" || o.type === "IntersectionTypeAnnotation" || o.type === "UnionTypeAnnotation" || n === "objectType" && (o.type === "IndexedAccessType" || o.type === "OptionalIndexedAccessType");
		case "InferTypeAnnotation":
		case "NullableTypeAnnotation":
			if (o.type === "ArrayTypeAnnotation" || n === "objectType" && (o.type === "IndexedAccessType" || o.type === "OptionalIndexedAccessType")) return !0;
			break;
		case "ComponentTypeAnnotation":
		case "FunctionTypeAnnotation": {
			if (r.type === "ComponentTypeAnnotation" && (r.rendersType === null || r.rendersType === void 0)) return !1;
			if (e.match(void 0, (u, a) => a === "typeAnnotation" && u.type === "TypeAnnotation", (u, a) => a === "returnType" && u.type === "ArrowFunctionExpression") || e.match(void 0, (u, a) => a === "typeAnnotation" && u.type === "NullableTypeAnnotation", (u, a) => a === "typeAnnotation" && u.type === "TypeAnnotation", (u, a) => a === "returnType" && u.type === "ArrowFunctionExpression") || e.match(void 0, (u, a) => a === "typeAnnotation" && u.type === "TypePredicate", (u, a) => a === "typeAnnotation" && u.type === "TypeAnnotation", (u, a) => a === "returnType" && u.type === "ArrowFunctionExpression")) return !0;
			let s = o.type === "NullableTypeAnnotation" ? e.grandparent : o;
			return s.type === "UnionTypeAnnotation" || s.type === "IntersectionTypeAnnotation" || s.type === "ArrayTypeAnnotation" || n === "objectType" && (s.type === "IndexedAccessType" || s.type === "OptionalIndexedAccessType") || n === "checkType" && o.type === "ConditionalTypeAnnotation" || n === "extendsType" && o.type === "ConditionalTypeAnnotation" && r.returnType?.type === "InferTypeAnnotation" && r.returnType.typeParameter.bound || s.type === "NullableTypeAnnotation" || o.type === "FunctionTypeParam" && o.name === null && ee(r).some((u) => u.typeAnnotation?.type === "NullableTypeAnnotation");
		}
		case "OptionalIndexedAccessType": return n === "objectType" && o.type === "IndexedAccessType";
		case "StringLiteral":
		case "NumericLiteral":
		case "Literal":
			if (typeof r.value == "string" && o.type === "ExpressionStatement" && typeof o.directive != "string") {
				let s = e.grandparent;
				return s.type === "Program" || s.type === "BlockStatement";
			}
			return n === "object" && N(o) && Ee(r);
		case "AssignmentExpression": return !((n === "init" || n === "update") && o.type === "ForStatement" || n === "expression" && r.left.type !== "ObjectPattern" && o.type === "ExpressionStatement" || n === "key" && o.type === "TSPropertySignature" || o.type === "AssignmentExpression" || n === "expressions" && o.type === "SequenceExpression" && e.match(void 0, void 0, (s, u) => (u === "init" || u === "update") && s.type === "ForStatement") || n === "value" && o.type === "Property" && e.match(void 0, void 0, (s, u) => u === "properties" && s.type === "ObjectPattern") || o.type === "NGChainedExpression" || n === "node" && o.type === "JsExpressionRoot");
		case "ConditionalExpression": switch (o.type) {
			case "TaggedTemplateExpression":
			case "UnaryExpression":
			case "SpreadElement":
			case "BinaryExpression":
			case "LogicalExpression":
			case "NGPipeExpression":
			case "AwaitExpression":
			case "JSXSpreadAttribute":
			case "TSTypeAssertion":
			case "TypeCastExpression":
			case "TSAsExpression":
			case "TSSatisfiesExpression":
			case "AsExpression":
			case "AsConstExpression":
			case "SatisfiesExpression":
			case "TSNonNullExpression": return !0;
			case "NewExpression":
			case "CallExpression":
			case "OptionalCallExpression": return n === "callee";
			case "ConditionalExpression": return t.experimentalTernaries ? !1 : n === "test";
			case "MemberExpression":
			case "OptionalMemberExpression": return n === "object";
			default: return !1;
		}
		case "FunctionExpression": switch (o.type) {
			case "NewExpression":
			case "CallExpression":
			case "OptionalCallExpression": return n === "callee";
			case "TaggedTemplateExpression": return !0;
			case "ExportDefaultDeclaration": return n === "declaration";
			default: return !1;
		}
		case "ArrowFunctionExpression": switch (o.type) {
			case "BinaryExpression": return o.operator !== "|>" || r.extra?.parenthesized;
			case "NewExpression":
			case "CallExpression":
			case "OptionalCallExpression": return n === "callee";
			case "MemberExpression":
			case "OptionalMemberExpression": return n === "object";
			case "TSAsExpression":
			case "TSSatisfiesExpression":
			case "AsExpression":
			case "AsConstExpression":
			case "SatisfiesExpression":
			case "TSNonNullExpression":
			case "BindExpression":
			case "TaggedTemplateExpression":
			case "UnaryExpression":
			case "LogicalExpression":
			case "AwaitExpression":
			case "TSTypeAssertion":
			case "MatchExpressionCase": return !0;
			case "TSInstantiationExpression": return n === "expression";
			case "ConditionalExpression": return n === "test";
			default: return !1;
		}
		case "ClassExpression": switch (o.type) {
			case "NewExpression": return n === "callee";
			case "ExportDefaultDeclaration": return n === "declaration";
			default: return !1;
		}
		case "OptionalMemberExpression":
		case "OptionalCallExpression":
		case "ChainExpression":
		case "TSNonNullExpression": if (hs(e)) return !0;
		case "CallExpression":
		case "MemberExpression":
		case "TaggedTemplateExpression":
		case "ImportExpression":
			if (n === "callee" && (o.type === "BindExpression" || o.type === "NewExpression")) {
				let s = r;
				for (; s;) switch (s.type) {
					case "CallExpression":
					case "ImportExpression": return !0;
					case "MemberExpression":
					case "OptionalMemberExpression":
					case "BindExpression":
						s = s.object;
						break;
					case "TaggedTemplateExpression":
						s = s.tag;
						break;
					case "TSNonNullExpression":
						s = s.expression;
						break;
					default: return !1;
				}
			}
			return !1;
		case "BindExpression": return n === "callee" && (o.type === "BindExpression" || o.type === "NewExpression") || n === "object" && N(o);
		case "NGPipeExpression": return !(o.type === "NGRoot" || o.type === "NGMicrosyntaxExpression" || o.type === "ObjectProperty" && !r.extra?.parenthesized || Y(o) || n === "arguments" && M(o) || n === "right" && o.type === "NGPipeExpression" || n === "property" && o.type === "MemberExpression" || o.type === "AssignmentExpression");
		case "JSXFragment":
		case "JSXElement": return n === "callee" || n === "left" && o.type === "BinaryExpression" && o.operator === "<" || !Y(o) && o.type !== "ArrowFunctionExpression" && o.type !== "AssignmentExpression" && o.type !== "AssignmentPattern" && o.type !== "BinaryExpression" && o.type !== "ConditionalExpression" && o.type !== "ExpressionStatement" && o.type !== "JsExpressionRoot" && o.type !== "JSXAttribute" && o.type !== "JSXElement" && o.type !== "JSXExpressionContainer" && o.type !== "JSXFragment" && o.type !== "LogicalExpression" && !Tt(o) && !Ge(o) && !ut(o) && o.type !== "TypeCastExpression" && o.type !== "VariableDeclarator" && o.type !== "YieldExpression" && o.type !== "MatchExpressionCase" && !(n === "declaration" && o.type === "ExportDefaultDeclaration");
		case "TSInstantiationExpression": return n === "object" && N(o);
		case "MatchOrPattern": return o.type === "MatchAsPattern";
	}
	return !1;
}
function Sl(e) {
	let t = 0, { node: r } = e;
	for (; r;) {
		let n = e.getParentNode(t++);
		if (n?.type === "ForStatement" && n.init === r) return !0;
		r = n;
	}
	return !1;
}
function Bl(e) {
	return ie(e);
}
function Nr(e) {
	let { parent: t, key: r } = e;
	switch (t.type) {
		case "NGPipeExpression":
			if (r === "arguments" && e.isLast) return e.callParent(Nr);
			break;
		case "ObjectProperty":
			if (r === "value") return e.callParent(() => e.key === "properties" && e.isLast);
			break;
		case "BinaryExpression":
		case "LogicalExpression":
			if (r === "right") return e.callParent(Nr);
			break;
		case "ConditionalExpression":
			if (r === "alternate") return e.callParent(Nr);
			break;
		case "UnaryExpression":
			if (t.prefix && e.callParent(Nr)) return !0;
			break;
	}
	return !1;
}
function bl(e) {
	if (typeof e == "string") return ze;
	if (Array.isArray(e)) return Me;
	if (!e) return;
	let { type: t } = e;
	if (cn.has(t)) return t;
}
function Il(e) {
	let t = e === null ? "null" : typeof e;
	if (t !== "string" && t !== "object") return `Unexpected doc '${t}', 
Expected it to be 'string' or 'object'.`;
	if (Xe(e)) throw new Error("doc is valid.");
	let r = Object.prototype.toString.call(e);
	if (r !== "[object Object]") return `Unexpected doc '${r}'.`;
	let n = Pl([...cn].map((o) => `'${o}'`));
	return `Unexpected doc.type '${e.type}'.
Expected it to be ${n}.`;
}
function kl(e, t, r, n) {
	let o = [e];
	for (; o.length > 0;) {
		let i = o.pop();
		if (i === Ls) {
			r(o.pop());
			continue;
		}
		r && o.push(i, Ls);
		let s = Xe(i);
		if (!s) throw new Ot(i);
		if (t?.(i) !== !1) switch (s) {
			case Me:
			case Ue: {
				let u = s === Me ? i : i.parts;
				for (let c = u.length - 1; c >= 0; --c) o.push(u[c]);
				break;
			}
			case _e:
				o.push(i.flatContents, i.breakContents);
				break;
			case ge:
				if (n && i.expandedStates) for (let u = i.expandedStates.length, a = u - 1; a >= 0; --a) o.push(i.expandedStates[a]);
				else o.push(i.contents);
				break;
			case et:
			case Ze:
			case tt:
			case Ne:
			case rt:
				o.push(i.contents);
				break;
			case ze:
			case ct:
			case lt:
			case He:
			case Fe:
			case qe: break;
			default: throw new Ot(i);
		}
	}
}
function gt(e, t) {
	if (typeof e == "string") return t(e);
	let r = /* @__PURE__ */ new Map();
	return n(e);
	function n(i) {
		return Z(r, i, o);
	}
	function o(i) {
		switch (Xe(i)) {
			case Me: return t(i.map(n));
			case Ue: return t({
				...i,
				parts: i.parts.map(n)
			});
			case _e: return t({
				...i,
				breakContents: n(i.breakContents),
				flatContents: n(i.flatContents)
			});
			case ge: {
				let { expandedStates: s, contents: u } = i;
				return s ? (s = s.map(n), u = s[0]) : u = n(u), t({
					...i,
					contents: u,
					expandedStates: s
				});
			}
			case et:
			case Ze:
			case tt:
			case Ne:
			case rt: return t({
				...i,
				contents: n(i.contents)
			});
			case ze:
			case ct:
			case lt:
			case He:
			case Fe:
			case qe: return t(i);
			default: throw new Ot(i);
		}
	}
}
function Ms(e, t, r) {
	let n = r, o = !1;
	function i(s) {
		if (o) return !1;
		let u = t(s);
		u !== void 0 && (o = !0, n = u);
	}
	return ln(e, i), n;
}
function wl(e) {
	if (e.type === ge && e.break || e.type === Fe && e.hard || e.type === qe) return !0;
}
function ue(e) {
	return Ms(e, wl, !1);
}
function Os(e) {
	if (e.length > 0) {
		let t = w(0, e, -1);
		!t.expandedStates && !t.break && (t.break = "propagated");
	}
	return null;
}
function _s(e) {
	let t = /* @__PURE__ */ new Set(), r = [];
	function n(i) {
		if (i.type === qe && Os(r), i.type === ge) {
			if (r.push(i), t.has(i)) return !1;
			t.add(i);
		}
	}
	function o(i) {
		i.type === ge && r.pop().break && Os(r);
	}
	ln(e, n, o, !0);
}
function Ll(e) {
	return e.type === Fe && !e.hard ? e.soft ? "" : " " : e.type === _e ? e.flatContents : e;
}
function Jt(e) {
	return gt(e, Ll);
}
function Ol(e) {
	switch (Xe(e)) {
		case Ue: {
			let { parts: t } = e;
			if (t.every((r) => r === "")) return "";
			if (t.length === 1) return t[0];
			break;
		}
		case ge:
			if (!e.contents && !e.id && !e.break && !e.expandedStates) return "";
			if (e.contents.type === ge && e.contents.id === e.id && e.contents.break === e.break && e.contents.expandedStates === e.expandedStates) return e.contents;
			break;
		case et:
		case Ze:
		case tt:
		case rt:
			if (!e.contents) return "";
			break;
		case _e:
			if (!e.flatContents && !e.breakContents) return "";
			break;
		case Me: {
			let t = [];
			for (let r of e) {
				if (!r) continue;
				let [n, ...o] = Array.isArray(r) ? r : [r];
				typeof n == "string" && typeof w(0, t, -1) == "string" ? t[t.length - 1] += n : t.push(n), t.push(...o);
			}
			return t.length === 0 ? "" : t.length === 1 ? t[0] : t;
		}
		case ze:
		case ct:
		case lt:
		case He:
		case Fe:
		case Ne:
		case qe: break;
		default: throw new Ot(e);
	}
	return e;
}
function ur(e) {
	return gt(e, (t) => Ol(t));
}
function Ve(e, t = ar) {
	return gt(e, (r) => typeof r == "string" ? L(t, r.split(`
`)) : r);
}
function Ml(e) {
	if (e.type === Fe) return !0;
}
function Ns(e) {
	return Ms(e, Ml, !1);
}
function mn(e, t) {
	return e.type === Ne ? {
		...e,
		contents: t(e.contents)
	} : t(e);
}
function js(e) {
	let t = !0;
	return ln(e, (r) => {
		switch (Xe(r)) {
			case ze: if (r === "") break;
			case lt:
			case He:
			case Fe:
			case qe: return t = !1, !1;
		}
	}), t;
}
function m(e) {
	return he(e), {
		type: Ze,
		contents: e
	};
}
function Se(e, t) {
	return Rs(e), he(t), {
		type: et,
		contents: t,
		n: e
	};
}
function Ws(e) {
	return Se(Number.NEGATIVE_INFINITY, e);
}
function Js(e) {
	return Se({ type: "root" }, e);
}
function Dn(e) {
	return Se(-1, e);
}
function Gs(e, t, r) {
	he(e);
	let n = e;
	if (t > 0) {
		for (let o = 0; o < Math.floor(t / r); ++o) n = m(n);
		n = Se(t % r, n), n = Se(Number.NEGATIVE_INFINITY, n);
	}
	return n;
}
function yn(e) {
	return vs(e), {
		type: Ue,
		parts: e
	};
}
function p(e, t = {}) {
	return he(e), fn(t.expandedStates, !0), {
		type: ge,
		id: t.id,
		contents: e,
		break: !!t.shouldBreak,
		expandedStates: t.expandedStates
	};
}
function mt(e, t) {
	return p(e[0], {
		...t,
		expandedStates: e
	});
}
function O(e, t = "", r = {}) {
	return he(e), t !== "" && he(t), {
		type: _e,
		breakContents: e,
		flatContents: t,
		groupId: r.groupId
	};
}
function ht(e, t) {
	return he(e), {
		type: tt,
		contents: e,
		groupId: t.groupId,
		negate: t.negate
	};
}
function L(e, t) {
	he(e), fn(t);
	let r = [];
	for (let n = 0; n < t.length; n++) n !== 0 && r.push(e), r.push(t[n]);
	return r;
}
function Et(e, t) {
	return he(t), e ? {
		type: Ne,
		label: e,
		contents: t
	} : t;
}
function _o(e) {
	return he(e), {
		type: rt,
		contents: e
	};
}
function Us(e) {
	return e === Nl ? vl : e === jl ? Rl : Jl;
}
function ql(e) {
	let t = e[0], r = e[1];
	for (let n = 0; n < e.length; n += 2) {
		let o = e[n], i = e[n + 1];
		if ($s >= o && $s <= i) return [o, i];
		i - o > r - t && (t = o, r = i);
	}
	return [t, r];
}
function Xl(e) {
	if (!e) return 0;
	if (!Hl.test(e)) return e.length;
	let t = 0;
	e = e.replace(qs(), (r) => (t += Qs(r) ? 1 : 2, ""));
	for (let r of e) {
		let n = r.codePointAt(0);
		n <= 31 || n >= 127 && n <= 159 || n >= 768 && n <= 879 || n >= 65024 && n <= 65039 || (t += vo(n) || Ro(n) ? 2 : 1);
	}
	return t;
}
function zs(e, t, r) {
	let n = t.type === 1 ? e.queue.slice(0, -1) : [...e.queue, t], o = "", i = 0, s = 0, u = 0;
	for (let E of n) switch (E.type) {
		case 0:
			f(), r.useTabs ? a(1) : c(r.tabWidth);
			break;
		case 3: {
			let { string: P } = E;
			f(), o += P, i += P.length;
			break;
		}
		case 2: {
			let { width: P } = E;
			s += 1, u += P;
			break;
		}
		default: throw new Error(`Unexpected indent comment '${E.type}'.`);
	}
	return F(), {
		...e,
		value: o,
		length: i,
		queue: n
	};
	function a(E) {
		o += "	".repeat(E), i += r.tabWidth * E;
	}
	function c(E) {
		o += " ".repeat(E), i += E;
	}
	function f() {
		r.useTabs ? y() : F();
	}
	function y() {
		s > 0 && a(s), A();
	}
	function F() {
		u > 0 && c(u), A();
	}
	function A() {
		s = 0, u = 0;
	}
}
function Zs(e, t, r) {
	if (!t) return e;
	if (t.type === "root") return {
		...e,
		root: e
	};
	if (t === Number.NEGATIVE_INFINITY) return e.root;
	let n;
	return typeof t == "number" ? t < 0 ? n = Kl : n = {
		type: 2,
		width: t
	} : n = {
		type: 3,
		string: t
	}, zs(e, n, r);
}
function eu(e, t) {
	return zs(e, Vl, t);
}
function $l(e) {
	let t = 0;
	for (let r = e.length - 1; r >= 0; r--) {
		let n = e[r];
		if (n === " " || n === "	") t++;
		else break;
	}
	return t;
}
function En(e) {
	let t = $l(e);
	return {
		text: t === 0 ? e : e.slice(0, e.length - t),
		count: t
	};
}
function dn(e, t, r, n, o, i) {
	if (r === Number.POSITIVE_INFINITY) return !0;
	let s = t.length, u = !1, a = [e], c = "";
	for (; r >= 0;) {
		if (a.length === 0) {
			if (s === 0) return !0;
			a.push(t[--s]);
			continue;
		}
		let { mode: f, doc: y } = a.pop(), F = Xe(y);
		switch (F) {
			case ze:
				y && (u && (c += " ", r -= 1, u = !1), c += y, r -= dt(y));
				break;
			case Me:
			case Ue: {
				let A = F === Me ? y : y.parts, E = y[Go] ?? 0;
				for (let P = A.length - 1; P >= E; P--) a.push({
					mode: f,
					doc: A[P]
				});
				break;
			}
			case Ze:
			case et:
			case tt:
			case Ne:
				a.push({
					mode: f,
					doc: y.contents
				});
				break;
			case lt: {
				let { text: A, count: E } = En(c);
				c = A, r += E;
				break;
			}
			case ge: {
				if (i && y.break) return !1;
				let A = y.break ? nt : f, E = y.expandedStates && A === nt ? w(0, y.expandedStates, -1) : y.contents;
				a.push({
					mode: A,
					doc: E
				});
				break;
			}
			case _e: {
				let E = (y.groupId ? o[y.groupId] || Ct : f) === nt ? y.breakContents : y.flatContents;
				E && a.push({
					mode: f,
					doc: E
				});
				break;
			}
			case Fe:
				if (f === nt || y.hard) return !0;
				y.soft || (u = !0);
				break;
			case rt:
				n = !0;
				break;
			case He:
				if (n) return !1;
				break;
		}
	}
	return !1;
}
function Uo(e, t) {
	let r = Object.create(null), n = t.printWidth, o = Us(t.endOfLine), i = 0, s = [{
		indent: Wo,
		mode: nt,
		doc: e
	}], u = !1, a = [], c = new tu();
	for (_s(e); s.length > 0;) {
		let { indent: E, mode: P, doc: C } = s.pop();
		switch (Xe(C)) {
			case ze: {
				let I = o !== `
` ? V(0, C, `
`, o) : C;
				I && (c.write(I), s.length > 0 && (i += dt(I)));
				break;
			}
			case Me:
				for (let I = C.length - 1; I >= 0; I--) s.push({
					indent: E,
					mode: P,
					doc: C[I]
				});
				break;
			case ct:
				c.markPosition();
				break;
			case Ze:
				s.push({
					indent: eu(E, t),
					mode: P,
					doc: C.contents
				});
				break;
			case et:
				s.push({
					indent: Zs(E, C.n, t),
					mode: P,
					doc: C.contents
				});
				break;
			case lt:
				i -= c.trim();
				break;
			case ge: {
				let I = (function() {
					if (P === Ct && !u) return {
						indent: E,
						mode: C.break ? nt : Ct,
						doc: C.contents
					};
					u = !1;
					let h = n - i, v = a.length > 0, U = {
						indent: E,
						mode: Ct,
						doc: C.contents
					};
					if (!C.break && dn(U, s, h, v, r)) return U;
					if (!C.expandedStates) return {
						indent: E,
						mode: nt,
						doc: C.contents
					};
					if (!C.break) for (let ae = 1; ae < C.expandedStates.length - 1; ae++) {
						let fe = {
							indent: E,
							mode: Ct,
							doc: C.expandedStates[ae]
						};
						if (dn(fe, s, h, v, r)) return fe;
					}
					return {
						indent: E,
						mode: nt,
						doc: w(0, C.expandedStates, -1)
					};
				})();
				s.push(I), C.id && (r[C.id] = I.mode);
				break;
			}
			case Ue: {
				let I = n - i, k = C[Go] ?? 0, { parts: h } = C, v = h.length - k;
				if (v === 0) break;
				let U = h[k + 0], ae = h[k + 1], fe = {
					indent: E,
					mode: Ct,
					doc: U
				}, z = {
					indent: E,
					mode: nt,
					doc: U
				}, xe = dn(fe, [], I, a.length > 0, r, !0);
				if (v === 1) {
					xe ? s.push(fe) : s.push(z);
					break;
				}
				let De = {
					indent: E,
					mode: Ct,
					doc: ae
				}, xt = {
					indent: E,
					mode: nt,
					doc: ae
				};
				if (v === 2) {
					xe ? s.push(De, fe) : s.push(xt, z);
					break;
				}
				let bt = h[k + 2], _ = {
					indent: E,
					mode: P,
					doc: {
						...C,
						[Go]: k + 2
					}
				}, we = dn({
					indent: E,
					mode: Ct,
					doc: [
						U,
						ae,
						bt
					]
				}, [], I, a.length > 0, r, !0);
				s.push(_), we ? s.push(De, fe) : xe ? s.push(xt, fe) : s.push(xt, z);
				break;
			}
			case _e:
			case tt: {
				let I = C.groupId ? r[C.groupId] : P;
				if (I === nt) {
					let k = C.type === _e ? C.breakContents : C.negate ? C.contents : m(C.contents);
					k && s.push({
						indent: E,
						mode: P,
						doc: k
					});
				}
				if (I === Ct) {
					let k = C.type === _e ? C.flatContents : C.negate ? m(C.contents) : C.contents;
					k && s.push({
						indent: E,
						mode: P,
						doc: k
					});
				}
				break;
			}
			case rt:
				a.push({
					indent: E,
					mode: P,
					doc: C.contents
				});
				break;
			case He:
				a.length > 0 && s.push({
					indent: E,
					mode: P,
					doc: Mo
				});
				break;
			case Fe:
				switch (P) {
					case Ct:
						if (!C.hard) {
							C.soft || (c.write(" "), i += 1);
							break;
						}
						u = !0;
					case nt:
						if (a.length > 0) {
							s.push({
								indent: E,
								mode: P,
								doc: C
							}, ...a.reverse()), a.length = 0;
							break;
						}
						C.literal ? (c.write(o), i = 0, E.root && (E.root.value && c.write(E.root.value), i = E.root.length)) : (c.trim(), c.write(o + E.value), i = E.length);
						break;
				}
				break;
			case Ne:
				s.push({
					indent: E,
					mode: P,
					doc: C.contents
				});
				break;
			case qe: break;
			default: throw new Ot(C);
		}
		s.length === 0 && a.length > 0 && (s.push(...a.reverse()), a.length = 0);
	}
	let { text: f, positions: y } = c.finish();
	if (y.length !== 2) return { formatted: f };
	let [F, A] = y;
	return {
		formatted: f,
		cursorNodeStart: F,
		cursorNodeText: f.slice(F, A)
	};
}
function pr(e) {
	return (e.type === "ObjectTypeProperty" || e.type === "ObjectTypeInternalSlot") && !e.static && !e.method && e.kind !== "get" && e.kind !== "set" && e.value.type === "FunctionTypeAnnotation";
}
function Ql(e, t) {
	let r = null, n = t;
	for (; n !== r;) r = n, n = Ki(e, n), n = tr(e, n), n = at(e, n);
	return n = rr(e, n), n = pt(e, n), n !== !1 && J(e, n);
}
function Zl({ type: e }) {
	return e.startsWith("TS") && e.endsWith("Keyword");
}
function cr(e) {
	return Fn(e) || Cn(e) || ru(e) || e.type === "GenericTypeAnnotation" && !e.typeParameters || e.type === "TSTypeReference" && !e.typeArguments;
}
function nu(e) {
	return (e.type === "TypeAnnotation" || e.type === "TSTypeAnnotation") && e.typeAnnotation.type === "FunctionTypeAnnotation" && !e.static && !kt(e, e.typeAnnotation);
}
function em(e, t) {
	let r = t.split(".");
	for (let n = r.length - 1; n >= 0; n--) {
		let o = r[n];
		if (n === 0) return e.type === "Identifier" && e.name === o;
		if (n === 1 && e.type === "MetaProperty" && e.property.type === "Identifier" && e.property.name === o) {
			e = e.meta;
			continue;
		}
		if (e.type === "MemberExpression" && !e.optional && !e.computed && e.property.type === "Identifier" && e.property.name === o) {
			e = e.object;
			continue;
		}
		return !1;
	}
}
function lr(e, t) {
	return t.some((r) => em(e, r));
}
function rm(e) {
	return lr(e, tm);
}
function nm(e) {
	return e.type === "Identifier" && (e.name === "beforeEach" || e.name === "beforeAll" || e.name === "afterEach" || e.name === "afterAll");
}
function qo(e) {
	return M(e) && e.callee.type === "Identifier" && [
		"async",
		"inject",
		"fakeAsync",
		"waitForAsync"
	].includes(e.callee.name);
}
function om(e) {
	return e.type === "FunctionExpression" || e.type === "ArrowFunctionExpression" && e.body.type === "BlockStatement";
}
function Ut(e, t) {
	if (e?.type !== "CallExpression" || e.optional) return !1;
	let r = se(e);
	if (r.length === 1) {
		if (qo(e) && Ut(t)) return wt(r[0]);
		if (nm(e.callee)) return qo(r[0]);
	} else if ((r.length === 2 || r.length === 3) && (r[0].type === "TemplateLiteral" || q(r[0])) && rm(e.callee)) return r[2] && !Ee(r[2]) ? !1 : (r.length === 2 ? wt(r[1]) : om(r[1]) && ee(r[1]).length <= 1) || qo(r[1]);
	return !1;
}
function im(e, t) {
	let r = t - 1;
	r = at(e, r, { backwards: !0 }), r = pt(e, r, { backwards: !0 }), r = at(e, r, { backwards: !0 });
	let n = pt(e, r, { backwards: !0 });
	return r !== n;
}
function Ho(e, t) {
	let r = e.node;
	return r.printed = !0, t.printer.printComment(e, t);
}
function sm(e, t) {
	let r = e.node, n = [Ho(e, t)], { printer: o, originalText: i, locStart: s, locEnd: u } = t;
	if (o.isBlockComment?.(r)) {
		let f = " ";
		J(i, u(r)) && (J(i, s(r), { backwards: !0 }) ? f = d : f = T), n.push(f);
	} else n.push(d);
	let c = pt(i, at(i, u(r)));
	return c !== !1 && J(i, c) && n.push(d), n;
}
function um(e, t, r) {
	let n = e.node, o = Ho(e, t), { printer: i, originalText: s, locStart: u } = t, a = i.isBlockComment?.(n);
	if (r?.hasLineSuffix && !r?.isBlock || J(s, u(n), { backwards: !0 })) return {
		doc: _o([
			d,
			xn(s, u(n)) ? d : "",
			o
		]),
		isBlock: a,
		hasLineSuffix: !0
	};
	return !a || r?.hasLineSuffix ? {
		doc: [_o([" ", o]), je],
		isBlock: a,
		hasLineSuffix: !0
	} : {
		doc: [" ", o],
		isBlock: a,
		hasLineSuffix: !1
	};
}
function W(e, t, r = {}) {
	let { indent: n = !1, marker: o, filter: i = Yo } = r, s = new Set(e.node?.comments?.filter((c) => !(c.leading || c.trailing || c.marker !== o || !i(c))));
	if (s.size === 0) return "";
	let a = L(d, e.map(({ node: c }) => s.has(c) ? Ho(e, t) : "", "comments").filter(Boolean));
	return n ? m([d, a]) : a;
}
function An(e, t, r) {
	let n = t[Symbol.for("printedComments")], o = r?.filter ?? Yo, i = new Set(e.node?.comments?.filter((s) => !n?.has(s) && s.leading && o(s)));
	return i.size === 0 ? "" : e.map(({ node: s }) => i.has(s) ? sm(e, t) : "", "comments").filter(Boolean);
}
function ou(e, t, r) {
	let n = e.node?.comments, o = new Set(n?.filter((f) => f.trailing)), i = t[Symbol.for("printedComments")], s = r?.filter ?? Yo, u = new Set(n?.filter((f) => o.has(f) && !i?.has(f) && s(f)));
	if (u.size === 0) return "";
	let a = [], c;
	return e.each(({ node: f }) => {
		o.has(f) && (c = um(e, t, c), u.has(f) && a.push(c.doc));
	}, "comments"), a;
}
function Tn(e, t, r) {
	return {
		leading: An(e, t, r),
		trailing: ou(e, t, r)
	};
}
function Q(e, t, r, n) {
	let o = An(e, r, n), i = ou(e, r, n);
	return o || i ? mn(t, (s) => [
		o,
		s,
		i
	]) : t;
}
function gn(e, t = "es5") {
	return e.trailingComma === "es5" && t === "es5" || e.trailingComma === "all" && (t === "all" || t === "es5");
}
function $(e) {
	let { node: t } = e;
	return !t.optional || t.type === "Identifier" && t === e.parent.key ? "" : M(t) || N(t) && t.computed || t.type === "OptionalIndexedAccessType" ? "?." : "?";
}
function hn(e) {
	return e.node.definite || e.match(void 0, (t, r) => r === "id" && t.type === "VariableDeclarator" && t.definite) ? "!" : "";
}
function ne(e) {
	return pm(e) ? "declare " : "";
}
function mr({ node: e }) {
	return e.abstract || cm(e) ? "abstract " : "";
}
function qt(e) {
	return e.accessibility ? e.accessibility + " " : "";
}
function lm(e) {
	return x(e) || !iu(e) ? !1 : (e = e.argument, e = iu(e) ? e.argument : e, e.type === "LogicalExpression");
}
function fr(e, t, r) {
	let { node: n } = e, o = n.type === "WithStatement" ? "object" : "test", i = r(o);
	return lm(n[o]) ? i : p([m([D, i]), D]);
}
function Mt(e, t, r) {
	let { node: n } = e;
	return x(n, g.Dangling, r) ? [m([D, W(e, t, { filter: r })]), x(n, g.Dangling | g.Line, r) ? d : D] : "";
}
function Ie(e, t = "es5") {
	return gn(e, t) ? O(",") : "";
}
function R(e) {
	return e.semi ? ";" : "";
}
function Ke(e, t, r, n, o) {
	let i = e.node, s = ee(i), u = o && i.typeParameters ? r("typeParameters") : "";
	if (s.length === 0) return [
		u,
		"(",
		Mt(e, t, mm),
		")"
	];
	let { parent: a } = e, c = Ut(a), f = su(i), y = [];
	if (_i(e, (E, P) => {
		let C = P === s.length - 1;
		C && i.rest && y.push("..."), y.push(r()), !C && (y.push(","), c || f ? y.push(" ") : me(s[P], t) ? y.push(d, d) : y.push(T));
	}), n && !Dm(e)) {
		if (ue(u) || ue(y)) throw new St();
		return p([
			Jt(u),
			"(",
			Jt(y),
			")"
		]);
	}
	let F = s.every((E) => !j(E.decorators));
	return f && F ? [
		u,
		"(",
		...y,
		")"
	] : c ? [
		u,
		"(",
		...y,
		")"
	] : (pr(a) || nu(a) || a.type === "TypeAlias" || a.type === "UnionTypeAnnotation" || a.type === "IntersectionTypeAnnotation" || a.type === "FunctionTypeAnnotation" && a.returnType === i) && s.length === 1 && s[0].name === null && i.this !== s[0] && s[0].typeAnnotation && i.typeParameters === null && cr(s[0].typeAnnotation) && !i.rest ? t.arrowParens === "always" || i.type === "HookTypeAnnotation" ? [
		"(",
		...y,
		")"
	] : y : [
		u,
		"(",
		m([D, ...y]),
		!Ni(i) && e.root.type !== "NGRoot" ? Ie(t, "all") : "",
		D,
		")"
	];
}
function su(e) {
	if (!e) return !1;
	let t = ee(e);
	if (t.length !== 1) return !1;
	let [r] = t;
	return !x(r) && (r.type === "ObjectPattern" || r.type === "ArrayPattern" || r.type === "Identifier" && r.typeAnnotation && (r.typeAnnotation.type === "TypeAnnotation" || r.typeAnnotation.type === "TSTypeAnnotation") && Ye(r.typeAnnotation.typeAnnotation) || r.type === "FunctionTypeParam" && Ye(r.typeAnnotation) && r !== e.rest || r.type === "AssignmentPattern" && (r.left.type === "ObjectPattern" || r.left.type === "ArrayPattern") && (r.right.type === "Identifier" || ie(r.right) && r.right.properties.length === 0 || Y(r.right) && r.right.elements.length === 0));
}
function fm(e) {
	let t;
	return e.returnType ? (t = e.returnType, t.typeAnnotation && (t = t.typeAnnotation)) : e.typeAnnotation && (t = e.typeAnnotation), t;
}
function Bt(e, t) {
	let r = fm(e);
	if (!r) return !1;
	let n = e.typeParameters?.params;
	if (n) {
		if (n.length > 1) return !1;
		if (n.length === 1) {
			let o = n[0];
			if (o.constraint || o.default) return !1;
		}
	}
	return ee(e).length === 1 && (Ye(r) || ue(t));
}
function Dm(e) {
	return e.match((t) => t.type === "ArrowFunctionExpression" && t.body.type === "BlockStatement", (t, r) => {
		if (t.type === "CallExpression" && r === "arguments" && t.arguments.length === 1 && t.callee.type === "CallExpression") {
			let n = t.callee.callee;
			return n.type === "Identifier" || n.type === "MemberExpression" && !n.computed && n.object.type === "Identifier" && n.property.type === "Identifier";
		}
		return !1;
	}, (t, r) => t.type === "VariableDeclarator" && r === "init" || t.type === "ExportDefaultDeclaration" && r === "declaration" || t.type === "TSExportAssignment" && r === "expression" || t.type === "AssignmentExpression" && r === "right" && t.left.type === "MemberExpression" && t.left.object.type === "Identifier" && t.left.object.name === "module" && t.left.property.type === "Identifier" && t.left.property.name === "exports", (t) => t.type !== "VariableDeclaration" || t.kind === "const" && t.declarations.length === 1);
}
function uu(e) {
	let t = ee(e);
	return t.length > 1 && t.some((r) => r.type === "TSParameterProperty");
}
function Yt(e, t) {
	return (t === "params" || t === "this" || t === "rest") && su(e);
}
function dm(e) {
	return e.length === 1 ? e : e.toLowerCase().replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(?=\d)/, "$1$2").replace(/^([+-]?[\d.]+)e[+-]?0+$/, "$1").replace(/^([+-])?\./, "$10.").replace(/(\.\d+?)0+(?=e|$)/, "$1").replace(/\.(?=e|$)/, "");
}
function Sn(e, t) {
	let { preferred: r, alternate: n } = t === !0 || t === "'" ? Cm : Fm, { length: o } = e, i = 0, s = 0;
	for (let u = 0; u < o; u++) {
		let a = e.charCodeAt(u);
		a === r.codePoint ? i++ : a === n.codePoint && s++;
	}
	return (i > s ? n : r).character;
}
function Am(e, t) {
	let r = t === "\"" ? "'" : "\"";
	return t + V(0, e, xm, (o, i, s) => i ? i === r ? r : o : s === t ? "\\" + s : s) + t;
}
function Tm(e, t) {
	Re(/^(?<quote>["']).*\k<quote>$/s.test(e));
	let r = e.slice(1, -1), n;
	return t.parser === "json" || t.parser === "jsonc" || t.parser === "json-stringify" || t.parser === "json5" && t.quoteProps === "preserve" && !t.singleQuote ? n = "\"" : t.__isInHtmlAttribute ? n = "'" : n = Sn(r, t.singleQuote), e.charAt(0) === n ? e : mu(r, n);
}
function Eu(e) {
	return /^(?:\d+|\d+\.\d+)$/.test(e);
}
function hm(e, t) {
	let r = vr(e);
	if (r.type === "Identifier") return !0;
	if (!Ee(r) || gm(t)) return !1;
	let n = _t(ye(r));
	return String(r.value) === n && Eu(n);
}
function du(e, t) {
	let { parser: r } = t;
	if (r === "json" || r === "jsonc") return !1;
	let n = vr(e);
	if (!q(n)) return !1;
	let { value: o } = n;
	return ot(ye(n), t).slice(1, -1) !== o || e.type === "TSMethodSignature" && o === "new" ? !1 : !!(!(r === "babel-ts" && e.type === "ClassProperty" || (r === "typescript" || r === "oxc-ts" || r === "yuku-ts") && e.type === "PropertyDefinition") && au(o) || (r === "babel" || r === "acorn" || r === "oxc" || r === "yuku" || r === "espree" || r === "meriyah" || r === "__babel_estree") && e.type !== "ImportAttribute" && Eu(o) && String(Number(o)) === o);
}
function Cu(e, t) {
	return Z(Sm, e.parent, () => e.siblings.some((r) => {
		if (yu(r)) return !1;
		return q(vr(r)) && !du(r, t);
	}));
}
function Bm(e, t) {
	return (t.parser === "json" || t.parser === "jsonc" || t.quoteProps === "consistent" && Cu(e, t)) && hm(e.node, t);
}
function bm(e, t) {
	return (t.quoteProps === "as-needed" || t.quoteProps === "consistent" && !Cu(e, t)) && du(e.node, t);
}
function ve(e, t, r) {
	let { node: n } = e, o = Du(n);
	if (yu(n)) return [
		"[",
		r(o),
		"]"
	];
	if (Bm(e, t)) {
		let i = vr(n), s = ot(JSON.stringify(i.type === "Identifier" ? i.name : String(i.value)), t);
		return e.call(() => Q(e, s, t), o);
	}
	if (bm(e, t)) {
		let { value: i } = vr(n), s = /^\d/.test(i) ? _t(i) : i;
		return e.call(() => Q(e, s, t), o);
	}
	return r(o);
}
function Vo(e) {
	return e.key === "elementTypes" && Zt(e.parent) && e.parent.elementTypes.length > 1;
}
function Ht(e) {
	let { types: t } = e;
	if (t.some((n) => x(n))) return !1;
	let r = t.find((n) => Im(n));
	return r ? t.every((n) => n === r || Pm(n)) : !1;
}
function Bn(e) {
	let { key: t, node: r, parent: n } = e;
	return !(Ht(r) || t === "types" && pe(n) || t === "types" && At(n) || Vo(e));
}
function bn(e, t, r, n) {
	let { node: o } = e;
	if (Ht(o)) return L(" | ", e.map(r, "types"));
	let i = p(e.map(({ isFirst: s }) => {
		let u = s ? O("| ") : [T, "| "], a = r();
		return x(e.node, g.Leading) ? [u, Se(2, Q(e, a, t))] : [u, Q(e, Se(2, a), t)];
	}, "types"));
	return Bn(e) && (i = Q(e, i, t)), oe(e, t) ? p([m([D, i]), D]) : Vo(e) ? p([
		m([O(["(", D]), i]),
		D,
		O(")")
	]) : n?.assignmentLayout === "break-after-operator" || !km(e) ? i : p(m([D, i]));
}
function km(e) {
	let { key: t, parent: r } = e;
	return !(t === "typeAnnotation" && r.type === "TSTypeAssertion" || t === "elementTypes" && Zt(r) || (t === "trueType" || t === "falseType") && Qe(r) || t === "params" && Hi(r) || t === "typeAnnotation" && r.type === "FunctionTypeParam" && !r.name && e.grandparent.this !== r || e.match(void 0, (n, o) => o === "typeAnnotation" && n.type === "FunctionTypeParam", (n, o) => o === "params" && n.type === "FunctionTypeAnnotation", (n, o) => o === "value" && n.type === "ObjectTypeProperty" && pr(n)));
}
function Fu(e) {
	return cr(e) || Ye(e) ? !0 : pe(e) ? Ht(e) : !1;
}
function G(e, t, r = "typeAnnotation") {
	let { node: { [r]: n } } = e;
	if (!n) return "";
	let o = !1;
	if (n.type === "TSTypeAnnotation" || n.type === "TypeAnnotation") {
		let i = e.call(xu, r);
		(i === "=>" || i === ":" && x(n, g.Leading)) && (o = !0), wm.add(n);
	}
	return o ? [" ", t(r)] : t(r);
}
function Pn(e, t, r) {
	let n = xu(e);
	return n ? [
		n,
		" ",
		r("typeAnnotation")
	] : r("typeAnnotation");
}
function Dr(e, t, r, n) {
	if (Lm(e)) return In(e, t, r);
	let { node: o } = e, i = !1;
	if (o.type === "FunctionExpression" && n?.expandLastArg) {
		let { parent: y } = e;
		M(y) && (se(y).length > 1 || ee(o).every((F) => F.type === "Identifier" && !F.typeAnnotation)) && (i = !0);
	}
	let s = Ke(e, t, r, i), u = wn(e, r), a = Bt(o, u), f = o.type === "HookDeclaration" ? "hook" : "function";
	return [
		ne(e),
		o.async ? "async " : "",
		f,
		o.generator ? "*" : "",
		" ",
		o.id ? r("id") : "",
		r("typeParameters"),
		p([a ? p(s) : s, u]),
		o.body ? " " : "",
		r("body"),
		o.declare || !o.body ? R(t) : ""
	];
}
function Rr(e, t, r) {
	let { node: n } = e, { kind: o } = n, i = n.value || n, s = [];
	return !o || o === "init" || o === "method" || o === "constructor" ? i.async && s.push("async ") : (Re(o === "get" || o === "set"), s.push(o, " ")), i.generator && s.push("*"), s.push(ve(e, t, r), n.optional ? "?" : "", n === i ? In(e, t, r) : r("value")), s;
}
function In(e, t, r) {
	let { node: n } = e, o = Ke(e, t, r), i = wn(e, r), s = uu(n), u = Bt(n, i), a = [r("typeParameters"), p([s ? p(o, { shouldBreak: !0 }) : u ? p(o) : o, i])];
	return n.body ? a.push(" ", r("body")) : a.push(R(t)), a;
}
function Om(e) {
	let t = ee(e);
	return t.length === 1 && !e.typeParameters && !x(e, g.Dangling) && t[0].type === "Identifier" && !t[0].typeAnnotation && !x(t[0]) && !t[0].optional && !e.predicate && !e.returnType;
}
function kn(e, t) {
	if (t.arrowParens === "always") return !1;
	if (t.arrowParens === "avoid") {
		let { node: r } = e;
		return Om(r);
	}
	return !1;
}
function wn(e, t) {
	let { node: r } = e, o = [G(e, t, "returnType")];
	return r.predicate && o.push(t("predicate")), o;
}
function yr(e, t) {
	if (t.semi) return !1;
	let { node: r } = e;
	if (r.type !== "ExpressionStatement" || $o(e, t) || zo(e, t) || Qo(e, t)) return !1;
	let { key: n, parent: o } = e;
	return !!((n === "body" && (o.type === "Program" || o.type === "BlockStatement" || o.type === "StaticBlock" || o.type === "TSModuleBlock") || n === "consequent" && o.type === "SwitchCase") && e.call(() => Au(e, t), "expression"));
}
function Au(e, t) {
	let { node: r } = e;
	switch (r.type) {
		case "ParenthesizedExpression":
		case "TypeCastExpression":
		case "TSTypeAssertion":
		case "ArrayExpression":
		case "ArrayPattern":
		case "TemplateLiteral":
		case "TemplateElement":
		case "RegExpLiteral": return !0;
		case "ArrowFunctionExpression":
			if (!kn(e, t)) return !0;
			break;
		case "UnaryExpression": {
			let { prefix: n, operator: o } = r;
			if (n && (o === "+" || o === "-")) return !0;
			break;
		}
		case "BindExpression":
			if (!r.object) return !0;
			break;
		case "Literal":
			if (r.regex) return !0;
			break;
		default: if (H(r)) return !0;
	}
	return oe(e, t) ? !0 : sr(r) ? e.call(() => Au(e, t), ...an(r)) : !1;
}
function $o(e, t) {
	return (t.parentParser === "markdown" || t.parentParser === "mdx") && Ko(e) && H(e.node.expression);
}
function Qo(e, t) {
	return t.__isHtmlInlineEventHandler && Ko(e);
}
function zo(e, t) {
	return (t.parser === "__vue_event_binding" || t.parser === "__vue_ts_event_binding") && Ko(e);
}
function Ln(e, t) {
	if (!yr(e, t)) return !1;
	let r = w(0, re(e.node, g.Leading), -1);
	return !!(r && nr(r));
}
function _m(e, t) {
	let { key: r, parent: n } = e;
	if (r === "types" && pe(n) || r === "argument" && n.type === "JSXSpreadAttribute" || r === "expression" && n.type === "JSXSpreadChild" || r === "superClass" && (n.type === "ClassDeclaration" || n.type === "ClassExpression") || (r === "id" || r === "typeParameters") && Mm(n) || r === "patterns" && n.type === "MatchOrPattern" || tn(e)) return !0;
	let { node: o } = e;
	return Lt(o) ? !1 : o.type === "ExpressionStatement" ? Ln(e, t) : pe(o) ? Bn(e) : !!H(o);
}
function Nm(e, t, r = 0) {
	let n = 0;
	for (let o = r; o < e.length; ++o) e[o] === "	" ? n = n + t - n % t : n++;
	return n;
}
function jm(e, t) {
	let r = e.lastIndexOf(`
`);
	return r === -1 ? 0 : gu(e.slice(r + 1).match(/^[\t ]*/)[0], t);
}
function On(e, t, r) {
	if (Gm(e)) {
		let i = vm(e, t, r);
		if (i) return i;
	}
	let n = Nt(e, t, r);
	return [
		Be,
		"`",
		...e.map(({ isLast: i, index: s }) => [r(), i ? "" : n[s]], "quasis"),
		"`"
	];
}
function Bu(e, t, r) {
	let n = r("quasi"), { node: o } = e, i = "", s = re(o.quasi, g.Leading)[0];
	return s && (te(t.originalText, S(o.typeArguments ?? o.tag), b(s)) ? i = D : i = " "), Et(n.label && {
		tagged: !0,
		...n.label
	}, [
		r("tag"),
		r("typeArguments"),
		i,
		Be,
		n
	]);
}
function vm(e, t, r) {
	let { node: n } = e, o = n.quasis[0].value.raw.trim().split(/\s*\|\s*/);
	if (o.length > 1 || o.some((i) => i.length > 0)) {
		t.__inJestEach = !0;
		let i = Nt(e, t, r);
		t.__inJestEach = !1;
		let s = i.map((y) => Uo(y, {
			...t,
			printWidth: Number.POSITIVE_INFINITY,
			endOfLine: "lf"
		}).formatted), u = [{
			hasLineBreak: !1,
			cells: []
		}];
		for (let y = 1; y < n.quasis.length; y++) {
			let F = w(0, u, -1), A = s[y - 1];
			F.cells.push(A), A.includes(`
`) && (F.hasLineBreak = !0), n.quasis[y].value.raw.includes(`
`) && u.push({
				hasLineBreak: !1,
				cells: []
			});
		}
		let a = Math.max(o.length, ...u.map((y) => y.cells.length)), c = Array.from({ length: a }, () => 0), f = [{ cells: o }, ...u.filter((y) => y.cells.length > 0)];
		for (let y of f) if (!y.hasLineBreak) for (let [F, A] of y.cells.entries()) c[F] = Math.max(c[F], dt(A));
		return [
			Be,
			"`",
			m([d, L(d, f.map((y) => L(" | ", y.cells.map((F, A) => y.hasLineBreak ? F : F + " ".repeat(c[A] - dt(F))))))]),
			d,
			"`"
		];
	}
}
function Wm(e, t) {
	let { parent: r, index: n } = e;
	return Z(Rm, r, (i) => {
		let { tabWidth: s } = t, u = 0;
		return i.quasis.map((c) => {
			let f = c.value.raw, y = f.includes(`
`) ? hu(f, s) : u;
			return u = y, {
				indentSize: y,
				previousQuasiText: f
			};
		});
	})[n];
}
function Jm(e, t, r) {
	let { node: n, index: o } = e, i = r(), { quasis: u } = e.parent, a = S(u[o]), c = b(u[o + 1]), f = te(t.originalText, a, c);
	if (!f) {
		let A = Uo(i, {
			...t,
			printWidth: Number.POSITIVE_INFINITY
		}).formatted;
		A.includes(`
`) ? f = !0 : i = A;
	}
	f && (x(n) || n.type === "Identifier" || N(Pe(n)) || n.type === "ConditionalExpression" || n.type === "SequenceExpression" || de(n) || be(n)) && (i = [m([D, i]), D]);
	let { indentSize: y, previousQuasiText: F } = Wm(e, t);
	return t.__inJestEach && (y = Math.max(y, t.tabWidth)), i = y === 0 && F.endsWith(`
`) ? Se(Number.NEGATIVE_INFINITY, i) : Gs(i, y, t.tabWidth), p([
		"${",
		i,
		Be,
		"}"
	]);
}
function Nt(e, t, r) {
	return e.map(() => Jm(e, t, r), e.node.type === "TSTemplateLiteralType" ? "types" : "expressions");
}
function Mn(e, t) {
	return gt(e, (r) => typeof r == "string" ? t ? V(0, r, /(\\*)`/g, "$1$1\\`") : Zo(r) : r);
}
function Zo(e) {
	return V(0, e, /([\\`]|\$\{)/g, "\\$1");
}
function Gm({ node: e, parent: t }) {
	return e.type === "TemplateLiteral" && t.type === "TaggedTemplateExpression" && t.quasi === e && t.tag.type === "MemberExpression" && t.tag.property.type === "Identifier" && t.tag.property.name === "each" && (t.tag.object.type === "Identifier" && Su.test(t.tag.object.name) || t.tag.object.type === "MemberExpression" && t.tag.object.property.type === "Identifier" && (t.tag.object.property.name === "only" || t.tag.object.property.name === "skip") && t.tag.object.object.type === "Identifier" && Su.test(t.tag.object.object.name));
}
function bu(e) {
	let t = (n) => n.type === "TemplateLiteral", r = (n, o) => Ge(n) && !n.computed && n.key.type === "Identifier" && n.key.name === "styles" && o === "value";
	return e.match(t, (n, o) => Y(n) && o === "elements", r, ...ti) || e.match(t, r, ...ti);
}
function ri(e) {
	return e.match((t) => t.type === "TemplateLiteral", (t, r) => Ge(t) && !t.computed && t.key.type === "Identifier" && t.key.name === "template" && r === "value", ...ti);
}
function ei(e, t) {
	return x(e, g.Block | g.Leading, ({ value: r }) => r === ` ${t} `);
}
function _n({ node: e, parent: t }, r) {
	return ei(e, r) || Um(t) && ei(t, r) || t.type === "ExpressionStatement" && ei(t, r);
}
function Um(e) {
	return e.type === "AsConstExpression" || e.type === "TSAsExpression" && e.typeAnnotation.type === "TSTypeReference" && e.typeAnnotation.typeName.type === "Identifier" && e.typeAnnotation.typeName.name === "const";
}
async function Iu(e, t, r, n) {
	let { node: o } = r, i = "";
	for (let [c, f] of o.quasis.entries()) {
		let { raw: y } = f.value;
		c > 0 && (i += "@prettier-placeholder-" + (c - 1) + "-id"), i += y;
	}
	let a = qm(await e(i, { parser: "scss" }), Nt(r, n, t));
	if (!a) throw new Error("Couldn't insert all the expressions");
	return [
		"`",
		m([d, a]),
		D,
		"`"
	];
}
function qm(e, t) {
	if (!j(t)) return e;
	let r = 0, n = gt(ur(e), (o) => typeof o != "string" || !o.includes("@prettier-placeholder") ? o : o.split(/@prettier-placeholder-(\d+)-id/).map((i, s) => s % 2 === 0 ? Ve(i) : (r++, t[i])));
	return t.length === r ? n : null;
}
function Ym(e) {
	return e.match(void 0, (t, r) => r === "quasi" && t.type === "TaggedTemplateExpression" && lr(t.tag, [
		"css",
		"css.global",
		"css.resolve"
	])) || e.match(void 0, (t, r) => r === "expression" && t.type === "JSXExpressionContainer", (t, r) => r === "children" && t.type === "JSXElement" && t.openingElement.name.type === "JSXIdentifier" && t.openingElement.name.name === "style" && t.openingElement.attributes.some((n) => n.type === "JSXAttribute" && n.name.type === "JSXIdentifier" && n.name.name === "jsx"));
}
function Nn(e) {
	return e.type === "Identifier" && e.name === "styled";
}
function Pu(e) {
	return /^[A-Z]/.test(e.object.name) && e.property.name === "extend";
}
function Hm({ parent: e }) {
	if (!e || e.type !== "TaggedTemplateExpression") return !1;
	let t = e.tag.type === "ParenthesizedExpression" ? e.tag.expression : e.tag;
	switch (t.type) {
		case "MemberExpression": return Nn(t.object) || Pu(t);
		case "CallExpression": return Nn(t.callee) || t.callee.type === "MemberExpression" && (t.callee.object.type === "MemberExpression" && (Nn(t.callee.object.object) || Pu(t.callee.object)) || t.callee.object.type === "CallExpression" && Nn(t.callee.object.callee));
		case "Identifier": return t.name === "css";
		default: return !1;
	}
}
function Xm({ parent: e, grandparent: t }) {
	return t?.type === "JSXAttribute" && e.type === "JSXExpressionContainer" && t.name.type === "JSXIdentifier" && t.name.name === "css";
}
async function wu(e, t, r, n) {
	let { node: o } = r, i = o.quasis.length, s = Nt(r, n, t), u = [];
	for (let a = 0; a < i; a++) {
		let c = o.quasis[a], f = a === 0, y = a === i - 1, F = c.value.cooked, A = F.split(`
`), E = A.length;
		if (!y && /#[^\n\r]*$/.test(A[E - 1])) return null;
		let P = E > 2 && A[0].trim() === "" && A[1].trim() === "", C = E > 2 && A[E - 1].trim() === "" && A[E - 2].trim() === "", I = A.every((h) => /^\s*(?:#[^\n\r]*)?$/.test(h)), k;
		I ? k = Vm(A) : k = await e(F, { parser: "graphql" }), k ? (k = Mn(k, !1), !f && P && u.push(""), u.push(k), !y && C && u.push("")) : !f && !y && P && u.push(""), y || u.push(s[a]);
	}
	return [
		"`",
		m([d, L(d, u)]),
		d,
		"`"
	];
}
function Vm(e) {
	let t = [], r = !1, n = e.map((o) => o.trim());
	for (let [o, i] of n.entries()) i !== "" && (n[o - 1] === "" && r ? t.push([d, i]) : t.push(i), r = !0);
	return t.length === 0 ? null : L(d, t);
}
function Lu({ node: e, parent: t }) {
	return _n({
		node: e,
		parent: t
	}, "GraphQL") || t && (t.type === "TaggedTemplateExpression" && (t.tag.type === "MemberExpression" && t.tag.object.name === "graphql" && t.tag.property.name === "experimental" || t.tag.type === "Identifier" && (t.tag.name === "gql" || t.tag.name === "graphql")) || t.type === "CallExpression" && t.callee.type === "Identifier" && t.callee.name === "graphql");
}
async function Ou(e, t, r, n, o) {
	let { node: i } = n, s = ni;
	ni = ni + 1 >>> 0;
	let u = (I) => `PRETTIER_HTML_PLACEHOLDER_${I}_${s}_IN_JS`, a = i.quasis.map((I, k, h) => k === h.length - 1 ? I.value.cooked : I.value.cooked + u(k)).join(""), c = Nt(n, o, r), f = new RegExp(u("(\\d+)"), "g"), y = 0, A = gt(await t(a, {
		parser: e,
		__onHtmlRoot(I) {
			y = I.children.length;
		}
	}), (I) => {
		if (typeof I != "string") return I;
		let k = [], h = I.split(f);
		for (let v = 0; v < h.length; v++) {
			let U = h[v];
			if (v % 2 === 0) {
				U && (U = Zo(U), o.__embeddedInHtml && (U = V(0, U, /<\/(?=script\b)/gi, "<\\/")), k.push(U));
				continue;
			}
			let ae = Number(U);
			k.push(c[ae]);
		}
		return k;
	}), E = /^\s/.test(a) ? " " : "", P = /\s$/.test(a) ? " " : "", C = o.htmlWhitespaceSensitivity === "ignore" ? d : E && P ? T : null;
	return C ? p([
		"`",
		m([C, p(A)]),
		C,
		"`"
	]) : Et({ hug: !1 }, p([
		"`",
		E,
		y > 1 ? m(p(A)) : p(A),
		P,
		"`"
	]));
}
function Mu(e) {
	return _n(e, "HTML") || e.match((t) => t.type === "TemplateLiteral", (t, r) => t.type === "TaggedTemplateExpression" && t.tag.type === "Identifier" && t.tag.name === "html" && r === "quasi");
}
async function ju(e, t, r) {
	let { node: n } = r, o = V(0, n.quasis[0].value.raw, /((?:\\\\)*)\\`/g, (a, c) => "\\".repeat(c.length / 2) + "`"), i = Km(o), s = i !== "";
	s && (o = V(0, o, new RegExp(`^${i}`, "gm"), ""));
	let u = Mn(await e(o, {
		parser: "markdown",
		__inJsTemplate: !0
	}), !0);
	return [
		"`",
		s ? m([D, u]) : [ar, Ws(u)],
		D,
		"`"
	];
}
function Km(e) {
	let t = e.match(/^([^\S\n]*)\S/m);
	return t === null ? "" : t[1];
}
function vu({ node: e, parent: t }) {
	return t?.type === "TaggedTemplateExpression" && e.quasis.length === 1 && t.tag.type === "Identifier" && (t.tag.name === "md" || t.tag.name === "markdown");
}
function Qm(e) {
	let { node: t } = e;
	if (t.type !== "TemplateLiteral" || Zm(t)) return;
	let r = $m.find(({ test: n }) => n(e));
	if (r) return t.quasis.length === 1 && t.quasis[0].value.raw.trim() === "" ? "``" : r.print;
}
function zm(e) {
	return async (...t) => {
		let r = await e(...t);
		return r && Et({
			embed: !0,
			...r.label
		}, r);
	};
}
function Zm({ quasis: e }) {
	return e.some(({ value: { cooked: t } }) => t === null);
}
function Wu(e, t) {
	e.type === "ChainExpression" ? ef(t) : (e.type === "OptionalMemberExpression" || e.type === "OptionalCallExpression") && tf(t);
}
function Ju(e) {
	if (N(e)) return "object";
	if (M(e)) return "callee";
	if (We(e)) return "expression";
}
function jn(e) {
	let t = Ju(e);
	if (t) return e[t];
}
function ef(e) {
	for (e = jn(e); e.type === "MemberExpression" || e.type === "CallExpression" || e.type === "TSNonNullExpression"; e = jn(e)) {
		let t = Ju(e), r = e[t];
		r.type === "ChainExpression" && (e[t] = r.expression);
	}
}
function tf(e) {
	for (e = jn(e); e.type === "MemberExpression" || e.type === "CallExpression"; e = jn(e)) e.type = `Optional${e.type}`;
}
function Gu(e, t, r) {
	let n = t[r];
	(q(n) || Ee(n)) && (e[r] = String(n.value)), n.type === "Identifier" && (e[r] = n.name);
}
function Uu(e, t) {
	(e.type === "Property" || e.type === "ObjectProperty" || e.type === "MethodDefinition" || e.type === "ClassProperty" || e.type === "ClassMethod" || e.type === "PropertyDefinition" || e.type === "TSDeclareMethod" || e.type === "TSPropertySignature" || e.type === "TSMethodSignature" || e.type === "ObjectTypeProperty" || e.type === "ImportAttribute" || e.type === "RecordDeclarationProperty" || e.type === "RecordDeclarationStaticProperty") && !e.computed && Gu(t, e, "key"), e.type === "TSEnumMember" && Gu(t, e, "id");
}
function qu(e, t) {
	e.type === "RegExpLiteral" && (t.flags = [...e.flags].sort().join("")), e.type === "Literal" && "regex" in e && (t.regex.flags = [...e.regex.flags].sort().join(""));
}
function oi(e, t, r) {
	if (e.type === "Program" && delete t.sourceType, Wu(e, t), Uu(e, t), qu(e, t), (Ji(e) || e.type === "BigIntLiteralTypeAnnotation") && "bigint" in e && (t.bigint = e.bigint.toLowerCase()), e.type === "EmptyStatement" && !zt({
		node: e,
		parent: r
	}) || e.type === "JSXText" || e.type === "JSXExpressionContainer" && (e.expression.type === "Literal" || e.expression.type === "StringLiteral") && e.expression.value === " ") return null;
	if (e.type === "JSXElement" && e.openingElement.name.type === "JSXIdentifier" && e.openingElement.name.name === "style" && e.openingElement.attributes.some((o) => o.type === "JSXAttribute" && o.name.name === "jsx")) for (let { type: o, expression: i } of t.children) o === "JSXExpressionContainer" && i.type === "TemplateLiteral" && Er(i);
	e.type === "JSXAttribute" && e.name.name === "css" && e.value.type === "JSXExpressionContainer" && e.value.expression.type === "TemplateLiteral" && Er(t.value.expression), e.type === "JSXAttribute" && q(e.value) && /["']|&quot;|&apos;/.test(e.value.value) && (t.value.value = V(0, e.value.value, /["']|&quot;|&apos;/g, "\""));
	let n = e.expression || e.callee;
	if (e.type === "Decorator" && n.type === "CallExpression" && n.callee.name === "Component" && n.arguments.length === 1) {
		let o = e.expression.arguments[0].properties;
		for (let [i, s] of t.expression.arguments[0].properties.entries()) switch (o[i].key.name) {
			case "styles":
				Y(s.value) && Er(s.value.elements[0]);
				break;
			case "template":
				s.value.type === "TemplateLiteral" && Er(s.value);
				break;
		}
	}
	e.type === "TaggedTemplateExpression" && (e.tag.type === "MemberExpression" || e.tag.type === "Identifier" && (e.tag.name === "gql" || e.tag.name === "graphql" || e.tag.name === "css" || e.tag.name === "md" || e.tag.name === "markdown" || e.tag.name === "html") || e.tag.type === "CallExpression") && Er(t.quasi), (e.type === "CallExpression" || e.type === "MemberExpression") && !e.optional && delete t.optional, e.type === "TemplateLiteral" && Er(t);
}
function $u(e) {
	let t = e.match(Vu);
	return t ? t[0].trimStart() : "";
}
function Qu(e) {
	let r = e.match(Vu)?.[0];
	return r == null ? e : e.slice(r.length);
}
function zu(e) {
	e = V(0, e.replace(of, "").replace(nf, ""), af, "$1");
	let r = "";
	for (; r !== e;) r = e, e = V(0, e, uf, `
$1 $2
`);
	e = e.replace(Yu, "").trimEnd();
	let n = Object.create(null), o = V(0, e, Hu, "").replace(Yu, "").trimEnd(), i;
	for (; i = Hu.exec(e);) {
		let s = V(0, i[2], sf, "");
		if (typeof n[i[1]] == "string" || Array.isArray(n[i[1]])) {
			let u = n[i[1]];
			n[i[1]] = [
				...Ku,
				...Array.isArray(u) ? u : [u],
				s
			];
		} else n[i[1]] = s;
	}
	return {
		comments: o,
		pragmas: n
	};
}
function Zu({ comments: e = "", pragmas: t = {} }) {
	let s = Object.keys(t), u = s.flatMap((c) => Xu(c, t[c])).map((c) => ` * ${c}
`).join("");
	if (!e) {
		if (s.length === 0) return "";
		if (s.length === 1 && !Array.isArray(t[s[0]])) {
			let c = t[s[0]];
			return `/** ${Xu(s[0], c)[0]} */`;
		}
	}
	let a = e.split(`
`).map((c) => ` * ${c}`).join(`
`) + `
`;
	return `/**
` + (e ? a : "") + (e && s.length > 0 ? ` *
` : "") + u + " */";
}
function Xu(e, t) {
	return [...Ku, ...Array.isArray(t) ? t : [t]].map((r) => `@${e} ${r}`.trim());
}
function pf(e) {
	if (!e.startsWith("#!")) return "";
	let t = e.indexOf(`
`);
	return t === -1 ? e : e.slice(0, t);
}
function cf(e) {
	let t = ta(e);
	t && (e = e.slice(t.length + 1));
	let { pragmas: n, comments: o } = zu($u(e));
	return {
		shebang: t,
		text: e,
		pragmas: n,
		comments: o
	};
}
function ra(e) {
	let { shebang: t, text: r, pragmas: n, comments: o } = cf(e), i = Qu(r), s = Zu({
		pragmas: {
			[ea]: "",
			...n
		},
		comments: o.trimStart()
	});
	return (t ? `${t}
` : "") + s + (i.startsWith(`
`) ? `
` : `

`) + i;
}
function lf(e) {
	if (!le(e)) return [];
	if (!e.value.includes(`
`)) return [];
	let t = [];
	for (let r of `*${e.value}*`.split(`
`)) {
		if (r = r.trimStart(), !r.startsWith("*")) return [];
		t.push(r);
	}
	return t;
}
function ii(e) {
	return Z(mf, e, lf);
}
function vn(e) {
	return ii(e).length > 0;
}
function na(e, t) {
	let r = e.node;
	if (Le(r)) return t.originalText.slice(b(r), S(r)).trimEnd();
	if (vn(r)) return ff(r);
	if (le(r)) return [
		"/*",
		Ve(r.value),
		"*/"
	];
	throw new Error("Not a comment: " + JSON.stringify(r));
}
function ff(e) {
	let t = ii(e), r = e.value[0] === "*" && e.value[1] !== "*";
	return [
		"/",
		t.map((n, o) => {
			if (o === 0) return [n.trimEnd(), d];
			if (o === t.length - 1) return [" ", n];
			let i = n.trimEnd(), s = [" ", i];
			return r && i !== "*" && n.endsWith("  ") ? [
				s,
				"  ",
				Js(ar)
			] : [s, d];
		}),
		"/"
	];
}
function si(e) {
	if (typeof e != "string") throw new TypeError("Expected a string");
	return e.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
}
function Xt(e) {
	return e.type === "JSXText" && (dr.hasNonWhitespaceCharacter(ye(e)) || !/\n/.test(ye(e)));
}
function ia(e) {
	let { node: t, parent: r } = e;
	if (!H(t) || !H(r)) return !1;
	let { index: n, siblings: o } = e, i;
	for (let s = n; s > 0; s--) {
		let u = o[s - 1];
		if (!(u.type === "JSXText" && !Xt(u))) {
			i = u;
			break;
		}
	}
	return i?.type === "JSXExpressionContainer" && i.expression.type === "JSXEmptyExpression" && Lt(i.expression);
}
function Df(e) {
	return Lt(e.node) || ia(e);
}
function sa(e) {
	return e.type === "CallExpression" && !e.optional && e.arguments.length === 1 && e.callee.type === "Identifier" && e.callee.name === "Boolean";
}
function Rn(e, t, r) {
	let { node: n, parent: o, grandparent: i, key: s } = e, u = s !== "body" && (o.type === "IfStatement" || o.type === "WhileStatement" || o.type === "SwitchStatement" || o.type === "DoWhileStatement"), a = n.operator === "|>" && e.root.extra?.__isUsingHackPipeline, c = pi(e, t, r, !1, u);
	if (u) return c;
	if (a) return p(c);
	if (s === "callee" && Tt(o) || o.type === "UnaryExpression" && !x(n) || N(o) && !o.computed) return p([m([D, ...c]), D]);
	let f = ut(o) || o.type === "JSXExpressionContainer" && i.type === "JSXAttribute" || n.operator !== "|" && o.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (o.type === "NGRoot" && t.parser === "__ng_binding" || o.type === "NGMicrosyntaxExpression" && i.type === "NGMicrosyntax" && i.body.length === 1) || n === o.body && o.type === "ArrowFunctionExpression" || n !== o.body && o.type === "ForStatement" || o.type === "ConditionalExpression" && !ut(i) && !Tt(i) || o.type === "TemplateLiteral" || s === "argument" && o.type === "UnaryExpression" || s === "arguments" && sa(o), y = o.type === "AssignmentExpression" || o.type === "VariableDeclarator" || o.type === "ClassProperty" || o.type === "PropertyDefinition" || o.type === "TSAbstractPropertyDefinition" || o.type === "ClassPrivateProperty" || Ge(o), F = be(n.left) && Lr(n.operator, n.left.operator);
	if (f || Fr(n) && !F || !Fr(n) && y) return p(c);
	if (c.length === 0) return "";
	let A = H(n.right), E = c.findIndex((v) => typeof v != "string" && !Array.isArray(v) && v.type === ge), P = c.slice(0, E === -1 ? 1 : E + 1), C = c.slice(P.length, A ? -1 : void 0), I = Symbol("logicalChain-" + ++yf), k = p([...P, m(C)], { id: I });
	if (!A) return k;
	return p([k, ht(w(0, c, -1), { groupId: I })]);
}
function pi(e, t, r, n, o) {
	let { node: i } = e;
	if (!be(i)) return [p(r())];
	let s = [];
	Lr(i.operator, i.left.operator) ? s = e.call(() => pi(e, t, r, !0, o), "left") : s.push(p(r("left")));
	let u = Fr(i), a = i.right.type === "ChainExpression" ? i.right.expression : i.right, c = (i.type === "NGPipeExpression" || i.operator === "|>" || Ef(e, t)) && !Oe(t.originalText, a), y = !x(a, g.Leading, nr) && Oe(t.originalText, a), F = i.type === "NGPipeExpression" ? "|" : i.operator, A = i.type === "NGPipeExpression" && i.arguments.length > 0 ? p(m([
		D,
		": ",
		L([T, ": "], e.map(() => Se(2, p(r())), "arguments"))
	])) : "", E;
	if (u) E = [F, Oe(t.originalText, a) ? m([
		T,
		r("right"),
		A
	]) : [
		" ",
		r("right"),
		A
	]];
	else {
		let h = F === "|>" && e.root.extra?.__isUsingHackPipeline ? e.call(() => pi(e, t, r, !0, o), "right") : r("right");
		if (t.experimentalOperatorPosition === "start") {
			let v = "";
			if (y) switch (Xe(h)) {
				case Me:
					v = h[0], h.shift();
					break;
				case Ne:
					v = h.contents[0], h.contents.shift();
					break;
			}
			E = [
				T,
				v,
				F,
				" ",
				h,
				A
			];
		} else E = [
			c ? T : "",
			F,
			c ? " " : T,
			h,
			A
		];
	}
	let { parent: P } = e, C = x(i.left, g.Trailing | g.Line);
	if ((C || !(o && i.type === "LogicalExpression") && P.type !== i.type && i.left.type !== i.type && i.right.type !== i.type) && (E = p(E, { shouldBreak: C })), t.experimentalOperatorPosition === "start" ? s.push(u || y ? " " : "", E) : s.push(c ? "" : " ", E), n && x(i)) {
		let k = ur(Q(e, s, t));
		return k.type === Ue ? k.parts : Array.isArray(k) ? k : [k];
	}
	return s;
}
function Fr(e) {
	return e.type !== "LogicalExpression" ? !1 : !!(ie(e.right) && e.right.properties.length > 0 || Y(e.right) && e.right.elements.length > 0 || H(e.right));
}
function Ef(e, t) {
	return (t.parser === "__vue_expression" || t.parser === "__vue_ts_expression") && ua(e.node) && !e.hasAncestor((r) => !ua(r) && r.type !== "JsExpressionRoot");
}
function pa(e, t, r) {
	let { node: n } = e;
	if (n.type.startsWith("NG")) switch (n.type) {
		case "NGRoot": return r("node");
		case "NGPipeExpression": return Rn(e, t, r);
		case "NGChainedExpression": return p(L([";", T], e.map(() => Ff(e) ? r() : [
			"(",
			r(),
			")"
		], "expressions")));
		case "NGEmptyExpression": return "";
		case "NGMicrosyntax": return e.map(() => [e.isFirst ? "" : aa(e) ? " " : [";", T], r()], "body");
		case "NGMicrosyntaxKey": return /^[$_a-z][\w$]*(?:-[$_a-z][\w$])*$/i.test(n.name) ? n.name : JSON.stringify(n.name);
		case "NGMicrosyntaxExpression": return [r("expression"), n.alias === null ? "" : [" as ", r("alias")]];
		case "NGMicrosyntaxKeyedExpression": {
			let { index: o, parent: i } = e, s = aa(e) || df(e) || (o === 1 && (n.key.name === "then" || n.key.name === "else" || n.key.name === "as") || o === 2 && (n.key.name === "else" && i.body[o - 1].type === "NGMicrosyntaxKeyedExpression" && i.body[o - 1].key.name === "then" || n.key.name === "track")) && i.body[0].type === "NGMicrosyntaxExpression";
			return [
				r("key"),
				s ? " " : ": ",
				r("expression")
			];
		}
		case "NGMicrosyntaxLet": return [
			"let ",
			r("key"),
			n.value === null ? "" : [" = ", r("value")]
		];
		case "NGMicrosyntaxAs": return [
			r("key"),
			" as ",
			r("alias")
		];
		default: throw new it(n, "Angular");
	}
}
function aa({ node: e, index: t }) {
	return e.type === "NGMicrosyntaxKeyedExpression" && e.key.name === "of" && t === 1;
}
function df(e) {
	let { node: t } = e;
	return e.parent.body[1].key.name === "of" && t.type === "NGMicrosyntaxKeyedExpression" && t.key.name === "track" && t.key.type === "NGMicrosyntaxKey";
}
function Ff({ node: e }) {
	return _r(e, Cf);
}
function ci(e, t, r) {
	let { node: n } = e;
	return p([L(T, e.map(r, "decorators")), la(n, t) ? d : T]);
}
function ca(e, t, r) {
	return ma(e.node) ? [L(d, e.map(r, "declaration", "decorators")), d] : "";
}
function Wn(e, t, r) {
	let { node: n, parent: o } = e, { decorators: i } = n;
	if (!j(i) || ma(o) || Cr(e)) return "";
	let s = n.type === "ClassExpression" || n.type === "ClassDeclaration" || la(n, t);
	return [
		e.key === "declaration" && qi(o) ? d : s ? je : "",
		L(T, e.map(r, "decorators")),
		T
	];
}
function la(e, t) {
	return e.decorators.some((r) => J(t.originalText, S(r)));
}
function ma(e) {
	if (e.type !== "ExportDefaultDeclaration" && e.type !== "ExportNamedDeclaration" && e.type !== "DeclareExportDeclaration") return !1;
	let t = e.declaration?.decorators;
	return j(t) && kt(e, t[0]);
}
function Jn(e) {
	return e.type === "UnaryExpression" && (e.operator === "+" || e.operator === "-") && Ee(e.argument);
}
function xr(e, t, r) {
	let { node: n } = e, o = [], i = Zt(n) ? "elementTypes" : "elements", s = n[i];
	if (s.length === 0 && !n.inexact) o.push(p([
		"[",
		Mt(e, t),
		"]"
	]));
	else {
		let u = w(0, s, -1), a = u?.type !== "RestElement" && !n.inexact, c = u === null, f = Symbol("array"), y = !t.__inJestEach && s.length > 1 && s.every((E, P, C) => {
			if (!Y(E) && !ie(E)) return !1;
			let I = E?.type, k = C[P + 1];
			if (k && I !== k.type) return !1;
			let h = Y(E) ? "elements" : "properties";
			return E[h] && E[h].length > 1;
		}) || x(n, g.Dangling | g.Line), F = li(n, t), A = a ? c ? "," : gn(t) ? F ? O(",", "", { groupId: f }) : O(",") : "" : "";
		o.push(p([
			"[",
			m([
				D,
				F ? Af(e, t, r, A) : [xf(e, t, r, i, n.inexact), A],
				W(e, t)
			]),
			D,
			"]"
		], {
			shouldBreak: y,
			id: f
		}));
	}
	return o.push($(e), G(e, r)), o;
}
function li(e, t) {
	return Y(e) && e.elements.length > 0 && e.elements.every((r) => r && (Ee(r) || Jn(r) && !x(r.argument)) && !x(r, g.Trailing | g.Line, (n) => !J(t.originalText, b(n), { backwards: !0 })));
}
function fa({ node: e }, { originalText: t }) {
	let r = S(e);
	if (r === b(e)) return !1;
	let { length: n } = t;
	for (; r < n && t[r] !== ",";) r = tr(t, rr(t, r + 1));
	return Gt(t, r);
}
function xf(e, t, r, n, o) {
	let i = [];
	return e.each(({ node: s, isLast: u }) => {
		i.push(s ? p(r()) : ""), (!u || o) && i.push([
			",",
			T,
			s && fa(e, t) ? D : ""
		]);
	}, n), o && i.push("..."), i;
}
function Af(e, t, r, n) {
	let o = [];
	return e.each(({ isLast: i, next: s }) => {
		o.push([r(), i ? n : ","]), i || o.push(fa(e, t) ? [d, d] : x(s, g.Leading | g.Line) ? d : T);
	}, "elements"), yn(o);
}
function mi(e) {
	return e.quasis.some((t) => t.value.raw.includes(`
`));
}
function Gn(e, t) {
	return (e.type === "TemplateLiteral" && mi(e) || e.type === "TaggedTemplateExpression" && mi(e.quasi)) && !J(t, b(e), { backwards: !0 });
}
function Da(e) {
	return Z(Tf, e, (t) => t.type === "ConditionalExpression" && !Ce(t, (r) => r.type === "ObjectExpression"));
}
function ya(e, t, r, n = {}) {
	let o = [], i, s = [], u = !1, a = !n.expandLastArg && e.node.body.type === "ArrowFunctionExpression", c;
	(function I() {
		let { node: k } = e, h = hf(e, t, r, n);
		if (o.length === 0) o.push(h);
		else {
			let { leading: v, trailing: U } = Tn(e, t);
			o.push([v, h]), s.unshift(U);
		}
		a && (u || (u = k.returnType && ee(k).length > 0 || k.typeParameters || ee(k).some((v) => v.type !== "Identifier"))), !a || k.body.type !== "ArrowFunctionExpression" ? (i = r("body", n), c = k.body) : e.call(I, "body");
	})();
	let f = !Oe(t.originalText, c) && (gf(c) || Sf(c, i, t) || !u && Da(c)), y = e.key === "callee" && Dt(e.parent), F = Symbol("arrow-chain"), A = Bf(e, n, {
		signatureDocs: o,
		shouldBreak: u
	}), E = !1, P = !1, C = !1;
	return a && (y || n.assignmentLayout) && (P = !0, C = !x(e.node, g.Leading & g.Line), E = n.assignmentLayout === "chain-tail-arrow-chain" || y && !f), i = bf(e, t, n, {
		bodyDoc: i,
		bodyComments: s,
		functionBody: c,
		shouldPutBodyOnSameLine: f
	}), p([
		p(P ? m([C ? D : "", A]) : A, {
			shouldBreak: E,
			id: F
		}),
		" =>",
		a ? ht(i, { groupId: F }) : p(i),
		a && y ? O(D, "", { groupId: F }) : ""
	]);
}
function hf(e, t, r, n) {
	let { node: o } = e, i = [];
	if (o.async && i.push("async "), kn(e, t)) i.push(r(["params", 0]));
	else {
		let u = n.expandLastArg || n.expandFirstArg, a = wn(e, r);
		if (u) {
			if (ue(a)) throw new St();
			a = p(Jt(a));
		}
		i.push(p([Ke(e, t, r, u, !0), a]));
	}
	let s = W(e, t, { marker: "commentBeforeArrow" });
	return s && i.push(" ", s), i;
}
function Sf(e, t, r) {
	return Y(e) || ie(e) || e.type === "ArrowFunctionExpression" || e.type === "DoExpression" || e.type === "BlockStatement" || H(e) || t.label?.hug !== !1 && (t.label?.embed || Gn(e, r.originalText));
}
function Bf(e, t, { signatureDocs: r, shouldBreak: n }) {
	if (r.length === 1) return r[0];
	let { parent: o, key: i } = e;
	return i !== "callee" && Dt(o) || be(o) ? p([
		r[0],
		" =>",
		m([T, L([" =>", T], r.slice(1))])
	], { shouldBreak: n }) : i === "callee" && Dt(o) || t.assignmentLayout ? p(L([" =>", T], r), { shouldBreak: n }) : p(m(L([" =>", T], r)), { shouldBreak: n });
}
function bf(e, t, r, { bodyDoc: n, bodyComments: o, functionBody: i, shouldPutBodyOnSameLine: s }) {
	let { node: u, parent: a } = e, c = r.expandLastArg ? Ie(t, "all") : "", f = (r.expandLastArg || a.type === "JSXExpressionContainer") && !x(u) ? D : "";
	return s && Da(i) ? [
		" ",
		p([
			O("", "("),
			m([D, n]),
			O("", ")"),
			c,
			f
		]),
		o
	] : s ? [
		" ",
		n,
		o
	] : [
		m([
			T,
			n,
			o
		]),
		c,
		f
	];
}
function Wr(e, t) {
	let { printWidth: r } = t;
	if (x(e)) return !1;
	let n = r * Pf;
	if (e.type === "ThisExpression" || e.type === "Identifier" && e.name.length <= n || Jn(e) && !x(e.argument)) return !0;
	let o = e.type === "Literal" && "regex" in e && e.regex.pattern || e.type === "RegExpLiteral" && e.pattern;
	return o ? o.length <= n : q(e) ? ot(ye(e), t).length <= n : e.type === "TemplateLiteral" ? e.expressions.length === 0 && e.quasis[0].value.raw.length <= n && !e.quasis[0].value.raw.includes(`
`) : e.type === "UnaryExpression" ? Wr(e.argument, { printWidth: r }) : e.type === "CallExpression" && e.arguments.length === 0 && e.callee.type === "Identifier" ? e.callee.name.length <= n - 2 : er(e);
}
function jt(e) {
	return N(e) || e.type === "BindExpression" && !!e.object;
}
function Ea(e) {
	if (e.length <= 1) return !1;
	let t = 0;
	for (let r of e) if (wt(r)) {
		if (t += 1, t > 1) return !0;
	} else if (r = Pe(r), M(r)) {
		for (let n of se(r)) if (wt(n)) return !0;
	}
	return !1;
}
function Un(e) {
	let { node: t, parent: r, key: n } = e;
	return n === "callee" && M(t) && M(r) && r.arguments.length > 0 && t.arguments.length > r.arguments.length;
}
function st(e, t = 2) {
	if (t <= 0) return !1;
	let r = (n) => st(n, t - 1);
	if (e = Pe(e), Xr(e)) return dt(e.pattern ?? e.regex.pattern) <= 5;
	if (er(e) || kf(e) || e.type === "ArgumentPlaceholder") return !0;
	if (e.type === "TemplateLiteral") return e.quasis.every((n) => !n.value.raw.includes(`
`)) && e.expressions.every(r);
	if (ie(e)) return e.properties.every((n) => !n.computed && (n.shorthand || n.value && r(n.value)));
	if (Y(e)) return e.elements.every((n) => n === null || r(n));
	if (Dt(e)) {
		if (e.type === "ImportExpression" || st(e.callee, t)) {
			let n = se(e);
			return n.length <= t && n.every(r);
		}
		return !1;
	}
	return N(e) ? st(e.object, t) && st(e.property, t) : e.type === "UnaryExpression" && If.has(e.operator) || e.type === "UpdateExpression" ? st(e.argument, t) : !1;
}
function wf(e, t, r) {
	let { node: n } = e, o = se(n);
	if (o.length === 0) return p([
		"(",
		Mt(e, t),
		")"
	]);
	let i = o.length - 1;
	if (Mf(o)) {
		let y = ["("];
		return kr(e, (F, A) => {
			y.push(r()), A !== i && y.push(", ");
		}), y.push(")"), y;
	}
	let s = !1, u = [];
	kr(e, ({ node: y }, F) => {
		let A = r();
		F === i || (me(y, t) ? (s = !0, A = [
			A,
			",",
			d,
			d
		]) : A = [
			A,
			",",
			T
		]), u.push(A);
	});
	let a = e.root.type !== "NGRoot" && n.type !== "ImportExpression" && n.type !== "TSImportType" && n.type !== "TSExternalModuleReference" ? Ie(t, "all") : "";
	function c() {
		return p([
			"(",
			m([T, ...u]),
			a,
			T,
			")"
		], { shouldBreak: !0 });
	}
	if (s || e.parent.type !== "Decorator" && Ea(o)) return c();
	if (Of(o)) {
		let y = u.slice(1);
		if (y.some(ue)) return c();
		let F;
		try {
			F = r(go(n, 0), { expandFirstArg: !0 });
		} catch (A) {
			if (A instanceof St) return c();
			throw A;
		}
		return ue(F) ? [je, mt([[
			"(",
			p(F, { shouldBreak: !0 }),
			", ",
			...y,
			")"
		], c()])] : mt([
			[
				"(",
				F,
				", ",
				...y,
				")"
			],
			[
				"(",
				p(F, { shouldBreak: !0 }),
				", ",
				...y,
				")"
			],
			c()
		]);
	}
	if (Lf(o, u, t)) {
		let y = u.slice(0, -1);
		if (y.some(ue)) return c();
		let F;
		try {
			F = r(go(n, -1), { expandLastArg: !0 });
		} catch (A) {
			if (A instanceof St) return c();
			throw A;
		}
		return ue(F) ? [je, mt([[
			"(",
			...y,
			p(F, { shouldBreak: !0 }),
			")"
		], c()])] : mt([
			[
				"(",
				...y,
				F,
				")"
			],
			[
				"(",
				...y,
				p(F, { shouldBreak: !0 }),
				")"
			],
			c()
		]);
	}
	let f = [
		"(",
		m([D, ...u]),
		a,
		D,
		")"
	];
	return Un(e) ? f : p(f, { shouldBreak: u.some(ue) || s });
}
function qn(e, t = !1) {
	if (ie(e) && (e.properties.length > 0 || x(e)) || Y(e) && (e.elements.length > 0 || x(e)) || (de(e) || e.type === "TSTypeAssertion") && qn(e.expression) || e.type === "FunctionExpression" || e.type === "DoExpression" || e.type === "ModuleExpression") return !0;
	if (e.type === "ArrowFunctionExpression") {
		let { body: r } = e;
		if (r.type === "BlockStatement" || H(r) || ie(r) || Y(r) || r.type === "ArrowFunctionExpression" && qn(r, !0) || !t && (r.type === "ConditionalExpression" || M(Pe(r)))) return !0;
	}
	return !1;
}
function Lf(e, t, r) {
	if (e.length === 1) {
		let i = w(0, t, -1);
		if (i.label?.embed && i.label?.hug !== !1) return !0;
	}
	let n = w(0, e, -1), o = w(0, e, -2);
	return !x(n, g.Leading) && !x(n, g.Trailing) && qn(n) && (!o || o.type !== n.type) && (e.length !== 2 || o.type !== "ArrowFunctionExpression" || !Y(n)) && !(e.length > 1 && li(n, r));
}
function Of(e) {
	if (e.length !== 2) return !1;
	let [t, r] = e;
	return t.type === "ModuleExpression" && _f(r) ? !0 : !x(t) && (t.type === "FunctionExpression" || t.type === "ArrowFunctionExpression" && t.body.type === "BlockStatement") && r.type !== "FunctionExpression" && r.type !== "ArrowFunctionExpression" && r.type !== "ConditionalExpression" && Ca(r) && !qn(r);
}
function Ca(e) {
	if (e.type === "ParenthesizedExpression") return Ca(e.expression);
	if (de(e) || e.type === "TypeCastExpression") {
		let { typeAnnotation: t } = e;
		if (t.type === "TypeAnnotation" && (t = t.typeAnnotation), t.type === "TSArrayType" && (t = t.elementType, t.type === "TSArrayType" && (t = t.elementType)), t.type === "GenericTypeAnnotation" || t.type === "TSTypeReference") {
			let r = t.type === "GenericTypeAnnotation" ? t.typeParameters : t.typeArguments;
			r?.params.length === 1 && (t = r.params[0]);
		}
		return cr(t) && st(e.expression, 1);
	}
	return Dt(e) && se(e).length > 1 ? !1 : be(e) ? st(e.left, 1) && st(e.right, 1) : Xr(e) || st(e);
}
function Mf(e) {
	return e.length === 2 ? da(e, 0) : e.length === 3 ? e[0].type === "Identifier" && da(e, 1) : !1;
}
function da(e, t) {
	let r = e[t], n = e[t + 1];
	return r.type === "ArrowFunctionExpression" && ee(r).length === 0 && r.body.type === "BlockStatement" && n.type === "ArrayExpression" && e.every((o) => !x(o));
}
function _f(e) {
	if (!(e.type === "ObjectExpression" && e.properties.length === 1)) return !1;
	let [t] = e.properties;
	return Ge(t) ? !t.computed && (t.key.type === "Identifier" && t.key.name === "type" || q(t.key) && t.key.value === "type") && q(t.value) && t.value.value === "module" : !1;
}
function Fa(e, t, r) {
	return [r("object"), p(m([D, fi(e, t, r)]))];
}
function fi(e, t, r) {
	return ["::", r("callee")];
}
function jf(e) {
	let { node: t, ancestors: r } = e;
	for (let n of r) {
		if (!(N(n) && n.object === t || n.type === "TSNonNullExpression" && n.expression === t)) return n.type === "NewExpression" && n.callee === t;
		t = n;
	}
	return !1;
}
function xa(e, t, r) {
	let n = r("object"), o = Di(e, t, r), { node: i } = e, s = e.findAncestor((c) => !(N(c) || c.type === "TSNonNullExpression")), u = e.findAncestor((c) => !We(c)), a = s.type === "BindExpression" || s.type === "AssignmentExpression" && s.left.type !== "Identifier" || jf(e) || i.computed || i.object.type === "Identifier" && i.property.type === "Identifier" && !N(u) || (u.type === "AssignmentExpression" || u.type === "VariableDeclarator") && (Nf(Pe(i.object)) || n.label?.memberChain);
	return Et(n.label, [
		n,
		Be,
		a ? o : p(m([D, o]))
	]);
}
function Di(e, t, r) {
	let n = r("property"), { node: o } = e, i = $(e);
	return o.computed ? !o.property || Ee(o.property) ? [
		i,
		"[",
		n,
		"]"
	] : p([
		i,
		"[",
		m([D, n]),
		D,
		"]"
	]) : [
		i,
		".",
		n
	];
}
function vf(e, t, r) {
	let n = (e.parent.type === "ChainExpression" ? e.grandparent : e.parent).type === "ExpressionStatement", o = [];
	function i(_) {
		let { originalText: Ae } = t, we = Wt(Ae, S(_));
		return Ae.charAt(we) === ")" ? we !== !1 && Gt(Ae, we + 1) : me(_, t);
	}
	function s() {
		let { node: _ } = e;
		if (M(_) && (jt(_.callee) || M(_.callee)) && !oe(e, t)) {
			let Ae = i(_);
			o.unshift({
				node: _,
				hasTrailingEmptyLine: Ae,
				printed: [Q(e, [
					$(e),
					r("typeArguments"),
					Jr(e, t, r)
				], t), Ae ? d : ""]
			}), e.call(s, "callee");
		} else jt(_) && !oe(e, t) ? (o.unshift({
			node: _,
			printed: Q(e, N(_) ? Di(e, t, r) : fi(e, t, r), t)
		}), e.call(s, "object")) : _.type === "ChainExpression" && !oe(e, t) ? e.call(s, "expression") : _.type === "TSNonNullExpression" && !oe(e, t) ? (o.unshift({
			node: _,
			printed: Q(e, "!", t)
		}), e.call(s, "expression")) : o.unshift({
			node: _,
			printed: r()
		});
	}
	let { node: u } = e;
	o.unshift({
		node: u,
		printed: [
			$(e),
			r("typeArguments"),
			Jr(e, t, r)
		]
	}), u.callee && e.call(s, "callee");
	let a = [], c = [o[0]], f = 1;
	for (; f < o.length && (o[f].node.type === "TSNonNullExpression" || o[f].node.type === "ChainExpression" || M(o[f].node) || N(o[f].node) && o[f].node.computed && Ee(o[f].node.property)); ++f) c.push(o[f]);
	if (!M(o[0].node)) for (; f + 1 < o.length && jt(o[f].node) && jt(o[f + 1].node); ++f) c.push(o[f]);
	a.push(c), c = [];
	let y = !1;
	for (; f < o.length; ++f) {
		if (y && jt(o[f].node)) {
			if (o[f].node.computed && Ee(o[f].node.property)) {
				c.push(o[f]);
				continue;
			}
			a.push(c), c = [], y = !1;
		}
		(M(o[f].node) || o[f].node.type === "ImportExpression") && (y = !0), c.push(o[f]), x(o[f].node, g.Trailing) && (a.push(c), c = [], y = !1);
	}
	c.length > 0 && a.push(c);
	function F(_) {
		return /^[A-Z]|^[$_]+$/.test(_);
	}
	function A(_) {
		return _.length <= t.tabWidth;
	}
	function E(_) {
		let Ae = _[1][0]?.node.computed;
		if (_[0].length === 1) {
			let Pt = _[0][0].node;
			return Pt.type === "ThisExpression" || Pt.type === "Identifier" && (F(Pt.name) || n && A(Pt.name) || Ae);
		}
		let we = w(0, _[0], -1).node;
		return N(we) && we.property.type === "Identifier" && (F(we.property.name) || Ae);
	}
	let P = a.length >= 2 && !x(a[1][0].node) && E(a);
	function C(_) {
		return _.map((Ae) => Ae.printed);
	}
	function I(_) {
		return _.length === 0 ? "" : m([d, L(d, _.map(C))]);
	}
	let k = a.map(C), h = k, v = P ? 3 : 2, U = a.flat(), ae = U.slice(1, -1).some((_) => x(_.node, g.Leading)) || U.slice(0, -1).some((_) => x(_.node, g.Trailing)) || a[v] && x(a[v][0].node, g.Leading);
	if (a.length <= v && !ae && a.every((_) => !w(0, _, -1).hasTrailingEmptyLine)) return Un(e) ? h : p(h);
	let fe = w(0, a[P ? 1 : 0], -1).node, z = !M(fe) && i(fe), xe = [
		C(a[0]),
		P ? a.slice(1, 2).map(C) : "",
		z ? d : "",
		I(a.slice(P ? 2 : 1))
	], De = o.map(({ node: _ }) => _).filter(M);
	function xt() {
		let _ = w(0, w(0, a, -1), -1).node, Ae = w(0, k, -1);
		return M(_) && ue(Ae) && De.slice(0, -1).some((we) => we.arguments.some(wt));
	}
	let bt;
	return ae || De.length > 2 && De.some((_) => _.arguments.some((Ae) => !st(Ae))) || k.slice(0, -1).some(ue) || xt() ? bt = p(xe) : bt = [ue(h) || z ? je : "", mt([h, xe])], Et({ memberChain: !0 }, bt);
}
function Vt(e, t, r) {
	let { node: n } = e, o = n.type === "NewExpression", i = $(e), s = se(n), u = n.type !== "TSImportType" && n.typeArguments ? [r("typeArguments"), Be] : "", a = s.length === 1 && Gn(s[0], t.originalText);
	if (a || Wf(e) || Jf(e) || Ut(n, e.parent)) {
		let y = [];
		if (kr(e, () => {
			y.push(r());
		}), !(a && y[0].label?.embed)) return [
			Ta(e, r),
			i,
			u,
			"(",
			L(", ", y),
			")"
		];
	}
	let c = n.type === "ImportExpression" || n.type === "TSImportType" || n.type === "TSExternalModuleReference";
	if (!c && !o && jt(n.callee) && !e.call(() => oe(e, t), "callee", ...n.callee.type === "ChainExpression" ? ["expression"] : [])) return Aa(e, t, r);
	let f = [
		Ta(e, r),
		i,
		u,
		Jr(e, t, r)
	];
	return c || M(n.callee) ? p(f) : f;
}
function Ta(e, t) {
	let { node: r } = e;
	return r.type === "ImportExpression" ? `import${r.phase ? `.${r.phase}` : ""}` : r.type === "TSImportType" ? "import" : r.type === "TSExternalModuleReference" ? "require" : [
		r.type === "NewExpression" ? "new " : "",
		t("callee"),
		Be
	];
}
function Wf(e) {
	let { node: t } = e;
	if (!(t.type === "ImportExpression" || t.type === "TSImportType" || t.type === "TSExternalModuleReference" || t.type === "CallExpression" && !t.optional && lr(t.callee, Rf))) return !1;
	let r = se(t);
	return r.length === 1 && q(r[0]) && !x(r[0]);
}
function Jf(e) {
	let { node: t } = e;
	if (t.type !== "CallExpression" || t.optional || t.callee.type !== "Identifier") return !1;
	let r = se(t);
	return t.callee.name === "require" ? (r.length === 1 && q(r[0]) || r.length > 1) && !x(r[0]) : t.callee.name === "define" && e.parent.type === "ExpressionStatement" ? r.length === 1 || r.length === 2 && r[0].type === "ArrayExpression" || r.length === 3 && q(r[0]) && r[1].type === "ArrayExpression" : !1;
}
function vt(e, t, r, n, o, i) {
	let s = Gf(e, t, r, n, i), u = i ? r(i, { assignmentLayout: s }) : "";
	switch (s) {
		case "break-after-operator": return p([
			p(n),
			o,
			p(m([T, u]))
		]);
		case "never-break-after-operator": return p([
			p(n),
			o,
			" ",
			u
		]);
		case "fluid": {
			let a = Symbol("assignment");
			return p([
				p(n),
				o,
				p(m(T), { id: a }),
				Be,
				ht(u, { groupId: a })
			]);
		}
		case "break-lhs": return p([
			n,
			o,
			" ",
			p(u)
		]);
		case "chain": return [
			p(n),
			o,
			T,
			u
		];
		case "chain-tail": return [
			p(n),
			o,
			m([T, u])
		];
		case "chain-tail-arrow-chain": return [
			p(n),
			o,
			u
		];
		case "only-left": return n;
	}
}
function Sa(e, t, r) {
	let { node: n } = e;
	return vt(e, t, r, r("left"), [" ", n.operator], "right");
}
function Ba(e, t, r) {
	return vt(e, t, r, r("id"), " =", "init");
}
function Gf(e, t, r, n, o) {
	let { node: i } = e, s = i[o];
	if (!s) return "only-left";
	let u = !Yn(s);
	if (e.match(Yn, ba, (F) => !u || F.type !== "ExpressionStatement" && F.type !== "VariableDeclaration")) return u ? s.type === "ArrowFunctionExpression" && s.body.type === "ArrowFunctionExpression" ? "chain-tail-arrow-chain" : "chain-tail" : "chain";
	if (!u && Yn(s.right) || pe(s) && !Ht(s) || Oe(t.originalText, s) || x(s, g.Leading, vn)) return "break-after-operator";
	if (i.type === "ImportAttribute" || s.type === "CallExpression" && s.callee.name === "require" || e.root.type === "JsonRoot") return "never-break-after-operator";
	let f = Ns(n);
	if (qf(i) || Xf(i) || yi(i) && f) return "break-lhs";
	let y = Vf(i, n, t);
	return e.call(() => Uf(e, t, r, y), o) ? "break-after-operator" : Yf(i) ? "break-lhs" : !f && (y || s.type === "TemplateLiteral" || s.type === "TaggedTemplateExpression" || Gi(s) || Ee(s) || s.type === "ClassExpression") ? "never-break-after-operator" : "fluid";
}
function Uf(e, t, r, n) {
	let o = e.node;
	if (be(o) && !Fr(o)) return !0;
	switch (o.type) {
		case "StringLiteralTypeAnnotation":
		case "SequenceExpression": return !0;
		case "TSConditionalType":
		case "ConditionalTypeAnnotation":
			if (!t.experimentalTernaries && !$f(o)) break;
			return !0;
		case "ConditionalExpression": {
			if (!t.experimentalTernaries) {
				let { test: c } = o;
				return be(c) && !Fr(c);
			}
			let { consequent: u, alternate: a } = o;
			return u.type === "ConditionalExpression" || a.type === "ConditionalExpression";
		}
		case "ClassExpression": return j(o.decorators);
	}
	if (n) return !1;
	let i = o, s = [];
	for (;;) if (i.type === "UnaryExpression" || i.type === "AwaitExpression" || i.type === "YieldExpression" && i.argument !== null) i = i.argument, s.push("argument");
	else if (i.type === "TSNonNullExpression") i = i.expression, s.push("expression");
	else break;
	return !!(q(i) || e.call(() => Pa(e, t, r), ...s));
}
function qf(e) {
	if (ba(e)) {
		let t = e.left || e.id;
		return t.type === "ObjectPattern" && t.properties.length > 2 && t.properties.some((r) => Ge(r) && (!r.shorthand || r.value?.type === "AssignmentPattern"));
	}
	return !1;
}
function Yn(e) {
	return e.type === "AssignmentExpression";
}
function ba(e) {
	return Yn(e) || e.type === "VariableDeclarator";
}
function Yf(e) {
	let t = Hf(e);
	if (j(t)) {
		let r = e.type === "TSTypeAliasDeclaration" ? "constraint" : "bound";
		if (t.length > 1 && t.some((n) => n[r] || n.default)) return !0;
	}
	return !1;
}
function Hf(e) {
	if (Vr(e)) return e.typeParameters?.params;
}
function Xf(e) {
	if (e.type !== "VariableDeclarator") return !1;
	let { typeAnnotation: t } = e.id;
	if (!t || !t.typeAnnotation) return !1;
	let r = ga(t.typeAnnotation);
	return j(r) && r.length > 1 && r.some((n) => j(ga(n)) || n.type === "TSConditionalType");
}
function yi(e) {
	return e.type === "VariableDeclarator" && e.init?.type === "ArrowFunctionExpression";
}
function ga(e) {
	let t;
	switch (e.type) {
		case "GenericTypeAnnotation":
			t = e.typeParameters;
			break;
		case "TSTypeReference":
			t = e.typeArguments;
			break;
	}
	return t?.params;
}
function Pa(e, t, r, n = !1) {
	let { node: o } = e, i = () => Pa(e, t, r, !0);
	if (We(o)) return e.call(i, "expression");
	if (M(o)) {
		if (Vt(e, t, r).label?.memberChain) return !1;
		let u = se(o);
		return !(u.length === 0 || u.length === 1 && Wr(u[0], t)) || Kf(o, r) ? !1 : e.call(i, "callee");
	}
	return N(o) ? e.call(i, "object") : n && (o.type === "Identifier" || o.type === "ThisExpression");
}
function Vf(e, t, r) {
	return Ge(e) ? (t = ur(t), typeof t == "string" && dt(t) < r.tabWidth + 3) : !1;
}
function Kf(e, t) {
	let r = e.typeArguments?.params;
	if (j(r)) {
		if (r.length > 1) return !0;
		if (r.length === 1) {
			let n = r[0];
			if (pe(n) || At(n) || n.type === "TSTypeLiteral" || n.type === "ObjectTypeAnnotation") return !0;
		}
		if (ue(t("typeArguments"))) return !0;
	}
	return !1;
}
function ha(e) {
	switch (e.type) {
		case "FunctionTypeAnnotation":
		case "GenericTypeAnnotation":
		case "TSFunctionType": return !!e.typeParameters;
		case "TSTypeReference": return !!e.typeArguments;
		default: return !1;
	}
}
function $f(e) {
	return ha(e.checkType) || ha(e.extendsType);
}
function Ia(e, t, r) {
	let { node: n } = e, o = ["await"];
	if (n.argument) {
		o.push(" ", r("argument"));
		let { parent: i } = e;
		if (M(i) && i.callee === n || N(i) && i.object === n) {
			o = [m([D, ...o]), D];
			let s = e.findAncestor((u) => u.type === "AwaitExpression" || u.type === "BlockStatement");
			if (s?.type !== "AwaitExpression" || !Ce(s.argument, (u) => u === n)) return p(o);
		}
	}
	return o;
}
function Gr(e, t, r, n) {
	let { node: o } = e, i = [], s = ka(0, o[n], (u) => u.type !== "EmptyStatement");
	return e.each(({ node: u }) => {
		u.type !== "EmptyStatement" && (i.push(r()), u !== s && (i.push(d), me(u, t) && i.push(d)));
	}, n), i;
}
function Hn(e, t, r) {
	let n = Zf(e, t, r), { node: o, parent: i } = e;
	if (o.type === "Program" && i?.type !== "ModuleExpression") return n ? [n, d] : "";
	let s = [];
	if (o.type === "StaticBlock" && s.push("static "), s.push("{"), n) s.push(m([d, n]), d);
	else {
		let u = e.grandparent;
		i.type === "ArrowFunctionExpression" || i.type === "FunctionExpression" || i.type === "FunctionDeclaration" || i.type === "ComponentDeclaration" || i.type === "HookDeclaration" || i.type === "ObjectMethod" || i.type === "ClassMethod" || i.type === "ClassPrivateMethod" || i.type === "ForStatement" || i.type === "WhileStatement" || i.type === "DoWhileStatement" || i.type === "DoExpression" || i.type === "ModuleExpression" || i.type === "CatchClause" && !u.finalizer || i.type === "TSModuleDeclaration" || i.type === "DeclareModule" || i.type === "MatchStatementCase" || o.type === "StaticBlock" || s.push(d);
	}
	return s.push("}"), s;
}
function Zf(e, t, r) {
	let { node: n } = e, o = j(n.directives), i = n.body.some((a) => a.type !== "EmptyStatement"), s = x(n, g.Dangling);
	if (!o && !i && !s) return "";
	let u = [];
	return o && (u.push(Gr(e, t, r, "directives")), (i || s) && (u.push(d), me(w(0, n.directives, -1), t) && u.push(d))), i && u.push(Gr(e, t, r, "body")), s && u.push(W(e, t)), u;
}
function eD(e) {
	let t = /* @__PURE__ */ new WeakMap();
	return (r) => Z(t, r, () => Symbol(e));
}
function Oa(e, t) {
	let { node: r } = e;
	if (r.type === "ClassBody" || r.type === "TSInterfaceBody") {
		e.each(t, "body");
		return;
	}
	if (r.type === "TSTypeLiteral") {
		e.each(t, "members");
		return;
	}
	if (r.type === "RecordDeclarationBody") {
		e.each(t, "elements");
		return;
	}
	if (r.type === "ObjectTypeAnnotation") {
		let n = La.flatMap((o) => e.map(({ node: i, index: s }) => ({
			node: i,
			loc: b(i),
			selector: [o, s]
		}), o)).sort((o, i) => o.loc - i.loc);
		for (let [o, { node: i, selector: s }] of n.entries()) e.call(() => t({
			node: i,
			next: n[o + 1]?.node,
			isLast: o === n.length - 1
		}), ...s);
	}
}
function Ma(e) {
	if (e.type === "ObjectTypeAnnotation") return La.some((r) => j(e[r]));
	return j(e.type === "RecordDeclarationBody" ? e.elements : e.body);
}
function Kt(e, t, r) {
	let { node: n } = e, o = [], i = n.type === "ObjectTypeAnnotation", s = n.type === "RecordDeclarationBody", u = !Na(e), a = u ? T : d, c = x(n, g.Dangling), [f, y] = i && n.exact ? ["{|", "|}"] : "{}", F = !0, A;
	if (Oa(e, ({ node: E, next: P, isLast: C }) => {
		if (A ?? (A = E), F && (F = !1), o.push(r()), !s && u && i) {
			let { parent: I } = e;
			I.inexact || !C ? o.push(",") : o.push(Ie(t));
		}
		s && E.type !== "MethodDefinition" && o.push(","), !s && !u && (tD({
			node: E,
			next: P
		}, t) || va({
			node: E,
			next: P
		}, t)) && o.push(";"), C || (o.push(a), me(E, t) && o.push(d));
	}), c && o.push(W(e, t)), n.type === "ObjectTypeAnnotation" && n.inexact) {
		F && (F = !1);
		let E;
		x(n, g.Dangling) ? E = [x(n, g.Line) || J(t.originalText, S(w(0, re(n), -1))) ? d : T, "..."] : E = [A ? T : "", "..."], o.push(E);
	}
	if (u) {
		let E = x(n, g.Dangling | g.Line) || t.objectWrap === "preserve" && A && te(t.originalText, b(n), b(A)), P;
		if (o.length === 0) P = f + y;
		else {
			let C = !t.bracketSpacing || F && !E ? D : T;
			P = [
				f,
				m([C, ...o]),
				C,
				y
			];
		}
		return e.match(void 0, (C, I) => I === "typeAnnotation", (C, I) => I === "typeAnnotation", Yt) || e.match(void 0, (C, I) => C.type === "FunctionTypeParam" && I === "typeAnnotation", Yt) ? P : p(P, { shouldBreak: E });
	}
	return [
		f,
		o.length > 0 ? [m([d, o]), d] : "",
		y
	];
}
function Na(e) {
	let { node: t } = e;
	if (t.type === "ObjectTypeAnnotation") {
		let { key: r, parent: n } = e;
		return r === "body" && (n.type === "InterfaceDeclaration" || n.type === "DeclareInterface" || n.type === "DeclareClass");
	}
	return t.type === "ClassBody" || t.type === "TSInterfaceBody" || t.type === "RecordDeclarationBody";
}
function ke(e, t) {
	let { parent: r } = e;
	return e.callParent(Na) ? r.type === "ObjectTypeAnnotation" ? ";" : R(t) : r.type === "TSTypeLiteral" ? e.isLast ? t.semi ? O(";") : "" : t.semi || va({
		node: e.node,
		next: e.next
	}, t) ? ";" : O("", ";") : "";
}
function tD({ node: e, next: t }, r) {
	if (r.semi || !_a(e)) return !1;
	if (!e.value && ja(e)) return !0;
	if (!t || t.static || t.accessibility || t.readonly) return !1;
	if (!t.computed) {
		let n = t.key?.name;
		if (n === "in" || n === "instanceof") return !0;
	}
	if (_a(t) && !t.static && t.variance && !t.declare) return !0;
	switch (t.type) {
		case "ClassProperty":
		case "PropertyDefinition":
		case "TSAbstractPropertyDefinition": return t.computed;
		case "MethodDefinition":
		case "TSAbstractMethodDefinition":
		case "ClassMethod":
		case "ClassPrivateMethod": {
			if ((t.value ? t.value.async : t.async) || t.kind === "get" || t.kind === "set") return !1;
			let o = t.value ? t.value.generator : t.generator;
			return !!(t.computed || o);
		}
		case "TSIndexSignature": return !0;
	}
	return !1;
}
function va({ node: e, next: t }, r) {
	return r.semi || !rD(e) ? !1 : ja(e) ? !0 : t && t.type === "TSCallSignatureDeclaration" ? !(e.type === "TSPropertySignature" && e.typeAnnotation) : !1;
}
function Ar(e, t, r) {
	let n = iD(e, t, r), { node: o } = e;
	if (o.type === "ClassExpression" && j(o.decorators)) {
		let i = Wn(e, t, r);
		return oe(e, t) ? [m([
			D,
			i,
			n
		]), D] : [i, n];
	}
	return n;
}
function iD(e, t, r) {
	let { node: n } = e, o = oD(n), i = n.type === "RecordDeclaration", s = o ? "interface" : i ? "record" : "class", u = [
		ne(e),
		mr(e),
		s
	], a = Wa(e), c = [], f = [];
	if (n.type !== "InterfaceTypeAnnotation") {
		n.id && c.push(" ");
		for (let F of ["id", "typeParameters"]) if (n[F]) {
			let { leading: A, trailing: E } = e.call(() => Tn(e, t), F);
			c.push(A, r(F), m(E));
		}
	}
	if (n.superClass) {
		let F = [aD(e, t, r), r("superTypeArguments")], A = e.call(() => ["extends ", Q(e, F, t)], "superClass");
		a ? f.push(T, p(A)) : f.push(" ", A);
	} else f.push(Ei(e, t, r, "extends"));
	f.push(Ei(e, t, r, "mixins"), Ei(e, t, r, "implements"));
	let y;
	return a ? (y = nD(n), u.push(p([...c, m(f)], { id: y }))) : u.push(...c, ...f), !o && a && Ma(n.body) ? u.push(O(d, " ", { groupId: y })) : u.push(" "), u.push(r("body")), u;
}
function Ra(e) {
	let t = e.superClass ? 1 : 0;
	for (let r of [
		"extends",
		"mixins",
		"implements"
	]) if (Array.isArray(e[r]) && (t += e[r].length), t > 1) return !0;
	return t > 1;
}
function sD(e) {
	let { node: t } = e;
	if (x(t.id, g.Trailing) || x(t.typeParameters, g.Trailing) || x(t.superClass) || Ra(t)) return !0;
	if (t.superClass) return e.parent.type === "AssignmentExpression" ? !1 : !t.superTypeArguments && N(Pe(t.superClass));
	let r = t.extends?.[0] ?? t.mixins?.[0] ?? t.implements?.[0];
	return r ? r.type === "InterfaceExtends" && r.id.type === "QualifiedTypeIdentifier" && !r.typeParameters || (r.type === "TSClassImplements" || r.type === "TSInterfaceHeritage") && N(r.expression) && !r.typeArguments : !1;
}
function Wa(e) {
	return Z(uD, e.node, () => sD(e));
}
function Ei(e, t, r, n) {
	let { node: o } = e;
	if (!j(o[n])) return "";
	let i = W(e, t, { marker: n }), s = L([",", T], e.map(r, n));
	if (!Ra(o)) {
		let u = [
			`${n} `,
			i,
			s
		];
		return Wa(e) ? [T, p(u)] : [" ", u];
	}
	return [
		T,
		i,
		i && d,
		n,
		p(m([T, s]))
	];
}
function aD(e, t, r) {
	let n = r("superClass"), { parent: o } = e;
	return o.type === "AssignmentExpression" ? p(O([
		"(",
		m([D, n]),
		D,
		")"
	], n)) : n;
}
function Xn(e, t, r) {
	let { node: n } = e, o = [];
	return j(n.decorators) && o.push(ci(e, t, r)), o.push(qt(n)), n.static && o.push("static "), o.push(mr(e)), n.override && o.push("override "), o.push(Rr(e, t, r)), o;
}
function Vn(e, t, r) {
	let { node: n } = e, o = [];
	j(n.decorators) && o.push(ci(e, t, r)), o.push(ne(e), qt(n)), n.static && o.push("static "), o.push(mr(e)), n.override && o.push("override "), n.readonly && o.push("readonly "), n.variance && o.push(r("variance")), (n.type === "ClassAccessorProperty" || n.type === "AccessorProperty" || n.type === "TSAbstractAccessorProperty") && o.push("accessor "), o.push(ve(e, t, r), $(e), hn(e), G(e, r));
	return [vt(e, t, r, o, " =", n.type === "TSAbstractPropertyDefinition" || n.type === "TSAbstractAccessorProperty" ? void 0 : "value"), R(t)];
}
function pD(e, t) {
	let r = re(e, g.Leading);
	if (r.length === 0) return !1;
	let [n] = r, o = t.originalText, i = b(n);
	return te(o, i, S(n)) || J(o, i, { backwards: !0 });
}
function Ft(e, t, r, n = "body") {
	return e.call(({ node: o }) => {
		let i = r();
		if (o.type === "EmptyStatement") return x(o, g.Leading) ? [" ", i] : i;
		let s = o.type === "BlockStatement";
		return pD(o, t) ? s ? [d, i] : m([d, i]) : s || o.type === "IfStatement" && e.parent.type === "IfStatement" && e.key === "alternate" ? [" ", i] : m([T, i]);
	}, n);
}
function Ua(e, t, r) {
	return [
		p(["do", Ft(e, t, r)]),
		e.node.body.type === "BlockStatement" ? " " : d,
		"while (",
		fr(e, t, r),
		")",
		R(t)
	];
}
function di(e) {
	return cD(e) ? di(e.expression) : e;
}
function Ya(e) {
	return e.type === "MemberExpression" || e.type === "OptionalMemberExpression" || e.type === "Identifier" && e.name !== "undefined";
}
function lD(e, t) {
	if (zo(e, t)) {
		let r = di(e.node.expression);
		return qa(r) || Ya(r);
	}
	return !(!t.semi || $o(e, t) || Qo(e, t));
}
function Ha(e, t, r) {
	let n = [r("expression")];
	if (yr(e, t)) {
		if (Ln(e, t)) {
			let { node: o } = e, i = w(0, re(o, g.Leading), -1);
			return Q(e, [
				";",
				An(e, t, { filter: (u) => u === i }),
				...n
			], t, { filter: (u) => u !== i });
		}
		n.unshift(";");
	} else lD(e, t) && n.push(";");
	return n;
}
function Xa(e, t, r) {
	let { node: n } = e, o = Ft(e, t, r), i = W(e, t), s = i ? [i, D] : "";
	return !n.init && !n.test && !n.update ? [s, p(["for (;;)", o])] : [s, p([
		"for (",
		p([m([
			D,
			r("init"),
			";",
			T,
			r("test"),
			";",
			n.update ? [T, r("update")] : ""
		]), D]),
		")",
		o
	])];
}
function Va(e, t, r) {
	let { node: n } = e, o = n.type === "ForOfStatement";
	return p([
		"for",
		o && n.await ? " await" : "",
		" (",
		r("left"),
		" ",
		o ? "of" : "in",
		" ",
		r("right"),
		")",
		Ft(e, t, r)
	]);
}
function Ka(e, t, r) {
	if (t.__isVueBindings || t.__isVueForBindingLeft) {
		let n = e.map(r, "program", "body", 0, "params");
		if (n.length === 1) return n[0];
		let o = L([",", T], n);
		return t.__isVueForBindingLeft ? [
			"(",
			m([D, p(o)]),
			D,
			")"
		] : o;
	}
	if (t.__isEmbeddedTypescriptGenericParameters) {
		let n = e.map(r, "program", "body", 0, "typeParameters", "params");
		return L([",", T], n);
	}
}
function Kn(e) {
	return Le(w(0, re(e, g.Dangling), -1));
}
function Qa(e, t, r) {
	let { node: n } = e, o = p([
		"if (",
		fr(e, t, r),
		")",
		Ja(e, t, r)
	]);
	if (!n.alternate) return o;
	let { consequent: i } = n, s = i.type === "BlockStatement", u = [o], a = s;
	s || (u.push(d), a = !1);
	let c = re(n, g.Dangling);
	if (c.length > 0) {
		let [f] = c;
		$a(f, t) ? u.push(s ? [d, d] : d) : J(t.originalText, b(f), { backwards: !0 }) ? u.push(s ? d : "") : u.push(" "), u.push(W(e, t), Kn(n) || J(t.originalText, S(w(0, c, -1))) ? d : " "), a = !1;
	}
	return u.push(a ? " " : "", "else", p(Ga(e, t, r))), u;
}
function ep(e, t) {
	let { node: r } = e;
	switch (r.type) {
		case "RegExpLiteral": return za(r);
		case "BigIntLiteral": return $n(r.extra.raw);
		case "NumericLiteral": return _t(r.extra.raw);
		case "StringLiteral": return Ve(ot(r.extra.raw, t));
		case "NullLiteral": return "null";
		case "BooleanLiteral": return String(r.value);
		case "DirectiveLiteral": return Za(r.extra.raw, t);
		case "Literal": {
			if (r.regex) return za(r.regex);
			if (r.bigint) return $n(r.raw);
			let { value: n } = r;
			return typeof n == "number" ? _t(r.raw) : typeof n == "string" ? mD(e) ? Za(r.raw, t) : Ve(ot(r.raw, t)) : String(n);
		}
	}
}
function mD(e) {
	if (e.key !== "expression") return;
	let { parent: t } = e;
	return t.type === "ExpressionStatement" && typeof t.directive == "string";
}
function $n(e) {
	return e.toLowerCase();
}
function za({ pattern: e, flags: t }) {
	return t = [...t].sort().join(""), `/${e}/${t}`;
}
function Za(e, t) {
	let r = e.slice(1, -1);
	if (r === fD || !(r.includes("\"") || r.includes("'"))) {
		let n = t.singleQuote ? "'" : "\"";
		return n + r + n;
	}
	return e;
}
function ft(e, t, r) {
	let { node: n, parent: o } = e, i = DD(n), s = n.type === "TSEnumBody" || i, u = tp(n), a = i && n.hasUnknownMembers, c = s ? "members" : u ? "attributes" : "properties", f = n[c], y = s || n.type === "ObjectPattern" && o.type !== "FunctionDeclaration" && o.type !== "FunctionExpression" && o.type !== "ArrowFunctionExpression" && o.type !== "ObjectMethod" && o.type !== "ClassMethod" && o.type !== "ClassPrivateMethod" && o.type !== "AssignmentPattern" && o.type !== "CatchClause" && n.properties.some((C) => C.value && (C.value.type === "ObjectPattern" || C.value.type === "ArrayPattern")) || n.type !== "ObjectPattern" && t.objectWrap === "preserve" && f.length > 0 && yD(n, f[0], t), F = [], A = e.map(({ node: C }) => {
		let I = [...F, r()];
		return F = [",", T], me(C, t) && F.push(d), I;
	}, c);
	if (a) {
		let C;
		if (x(n, g.Dangling)) {
			let I = x(n, g.Line);
			C = [
				W(e, t),
				I || J(t.originalText, S(w(0, re(n), -1))) ? d : T,
				"..."
			];
		} else C = ["..."];
		A.push([...F, ...C]);
	}
	let E = !(a || w(0, f, -1)?.type === "RestElement"), P;
	if (A.length === 0) P = p([
		"{",
		Mt(e, t),
		"}",
		$(e),
		G(e, r)
	]);
	else {
		let C = t.bracketSpacing ? T : D;
		P = [
			"{",
			m([C, ...A]),
			E ? Ie(t) : "",
			C,
			"}",
			$(e),
			G(e, r)
		];
	}
	return e.match((C) => C.type === "ObjectPattern" && !j(C.decorators), Yt) || Ye(n) && (e.match(void 0, (C, I) => I === "typeAnnotation", (C, I) => I === "typeAnnotation", Yt) || e.match(void 0, (C, I) => C.type === "FunctionTypeParam" && I === "typeAnnotation", Yt)) || !y && e.match((C) => C.type === "ObjectPattern", (C) => C.type === "AssignmentExpression" || C.type === "VariableDeclarator") ? P : p(P, { shouldBreak: y });
}
function yD(e, t, r) {
	let n = r.originalText, o = b(t), i = b(e);
	return tp(e) && (i = ce(r).lastIndexOf("{", o)), te(n, i, o);
}
function rp(e, t, r) {
	let { node: n } = e;
	return [
		"import",
		n.phase ? ` ${n.phase}` : "",
		Fi(n),
		ip(e, t, r),
		op(e, t, r),
		up(e, t, r),
		R(t)
	];
}
function Qn(e, t, r) {
	let { node: n } = e, o = [
		ca(e, t, r),
		ne(e),
		"export",
		np(n) ? " default" : ""
	], { declaration: i, exported: s } = n;
	return x(n, g.Dangling) && (o.push(" ", W(e, t)), Kn(n) && o.push(d)), i ? o.push(" ", r("declaration")) : (o.push(CD(n)), n.type === "ExportAllDeclaration" || n.type === "DeclareExportAllDeclaration" ? (o.push(" *"), s && o.push(" as ", r("exported"))) : o.push(ip(e, t, r)), o.push(op(e, t, r), up(e, t, r))), o.push(dD(n, t)), o;
}
function dD(e, t) {
	return !e.declaration || np(e) && !ED(e.declaration) ? R(t) : "";
}
function Ci(e, t = !0) {
	return e && e !== "value" ? `${t ? " " : ""}${e}${t ? "" : " "}` : "";
}
function Fi(e, t) {
	return Ci(e.importKind, t);
}
function CD(e) {
	return Ci(e.exportKind);
}
function op(e, t, r) {
	let { node: n } = e;
	return n.source ? [
		sp(n, t) ? " from" : "",
		" ",
		r("source")
	] : "";
}
function ip(e, t, r) {
	let { node: n } = e;
	if (!sp(n, t)) return "";
	let o = [" "];
	if (j(n.specifiers)) {
		let i = [], s = [];
		e.each(() => {
			let u = e.node.type;
			if (u === "ExportNamespaceSpecifier" || u === "ExportDefaultSpecifier" || u === "ImportNamespaceSpecifier" || u === "ImportDefaultSpecifier") i.push(r());
			else if (u === "ExportSpecifier" || u === "ImportSpecifier") s.push(r());
			else throw new it(n, "specifier");
		}, "specifiers"), o.push(L(", ", i)), s.length > 0 && (i.length > 0 && o.push(", "), s.length > 1 || i.length > 0 || n.specifiers.some((a) => x(a)) ? o.push(p([
			"{",
			m([t.bracketSpacing ? T : D, L([",", T], s)]),
			Ie(t),
			t.bracketSpacing ? T : D,
			"}"
		])) : o.push([
			"{",
			t.bracketSpacing ? " " : "",
			...s,
			t.bracketSpacing ? " " : "",
			"}"
		]));
	} else o.push("{}");
	return o;
}
function sp(e, t) {
	return e.type !== "ImportDeclaration" || j(e.specifiers) || e.importKind === "type" ? !0 : ce(t).slice(b(e), b(e.source)).trimEnd().endsWith("from");
}
function FD(e, t) {
	let r = ce(t).slice(S(e.source), e.attributes?.[0] ? b(e.attributes[0]) : S(e)).trimStart();
	return r.startsWith("assert") ? "assert" : r.startsWith("with") || j(e.attributes) ? "with" : void 0;
}
function up(e, t, r) {
	let { node: n } = e;
	if (!n.source) return "";
	let o = FD(n, t);
	if (!o) return "";
	let i = ft(e, t, r);
	return xD(n) && (i = Jt(i)), [` ${o} `, i];
}
function ap(e, t, r) {
	let { node: n } = e, { type: o } = n, i = o.startsWith("Import"), s = i ? "imported" : "local", u = i ? "local" : "exported", a = n[s], c = n[u], f = "", y = "";
	return o === "ExportNamespaceSpecifier" || o === "ImportNamespaceSpecifier" ? f = "*" : a && (f = r(s)), c && !Ir(n) && (y = r(u)), [
		Ci(o === "ImportSpecifier" ? n.importKind : n.exportKind, !1),
		f,
		f && y ? " as " : "",
		y
	];
}
function zn(e, t, r) {
	let { node: n } = e;
	return n.shorthand ? r("value") : vt(e, t, r, ve(e, t, r), ":", "value");
}
function Tr(e, t) {
	return [
		"...",
		t("argument"),
		G(e, t)
	];
}
function AD(e, t, r) {
	let { node: n } = e, o = r();
	return pn(n, t) ? [
		"(",
		m([d, o]),
		d,
		")"
	] : be(n) || t.experimentalTernaries && n.type === "ConditionalExpression" && (n.consequent.type === "ConditionalExpression" || n.alternate.type === "ConditionalExpression") ? p([
		O("("),
		m([D, o]),
		D,
		O(")")
	]) : o;
}
function Zn(e, t, r) {
	let { node: n } = e;
	return [
		n.type === "ThrowStatement" ? "throw" : "return",
		n.argument ? [" ", e.call(() => AD(e, t, r), "argument")] : "",
		R(t)
	];
}
function TD(e, t) {
	let { key: r, parent: n } = e;
	return !!(r === "argument" && ut(n) && oe(e, t) || r === "body" && n.type === "ArrowFunctionExpression");
}
function pp(e, t, r) {
	let { parent: n } = e;
	if (n.type === "ExpressionStatement" || n.type === "ForStatement") {
		let i = [];
		return e.each(({ isFirst: s }) => {
			s ? i.push(r()) : i.push(",", m([T, r()]));
		}, "expressions"), p(i);
	}
	let o = L([",", T], e.map(r, "expressions"));
	return TD(e, t) ? p(O([m([D, o]), D], o)) : p(o);
}
function cp(e, t, r) {
	return [
		p([
			"switch (",
			m([D, r("discriminant")]),
			D,
			")"
		]),
		" {",
		e.node.cases.length > 0 ? m([d, L(d, e.map(({ node: n, isLast: o }) => [r(), !o && me(n, t) ? d : ""], "cases"))]) : W(e, t, { indent: !0 }),
		d,
		"}"
	];
}
function lp(e, t, r) {
	let { node: n } = e, o = [];
	n.test ? o.push("case ", r("test"), ":") : o.push("default:"), x(n, g.Dangling) && o.push(" ", W(e, t));
	let i = n.consequent.filter((s) => s.type !== "EmptyStatement");
	if (i.length > 0) {
		let s = Gr(e, t, r, "consequent");
		o.push(i.length === 1 && i[0].type === "BlockStatement" ? [" ", s] : m([d, s]));
	}
	return o;
}
function mp(e, t) {
	let r = 0;
	for (let n in e) {
		let o = e[n];
		if (on(o) && typeof o.type == "string" && (r++, r += mp(o, t - r)), r > t) return r;
	}
	return r;
}
function xi(e, t = 5) {
	return mp(e, t) <= t;
}
function gD(e) {
	let t = [e];
	for (let r = 0; r < t.length; r++) {
		let n = t[r];
		for (let o of [
			"test",
			"consequent",
			"alternate"
		]) {
			let i = n[o];
			if (H(i)) return !0;
			i.type === "ConditionalExpression" && t.push(i);
		}
	}
	return !1;
}
function hD(e, t, r) {
	let { node: n } = e, o = n.type === "ConditionalExpression", i = o ? "alternate" : "falseType", { parent: s } = e, u = o ? r("test") : [
		r("checkType"),
		" ",
		"extends",
		" ",
		r("extendsType")
	];
	return s.type === n.type && s[i] === n ? Se(2, u) : u;
}
function BD(e) {
	let { node: t } = e;
	if (t.type !== "ConditionalExpression") return !1;
	let r, n = t;
	for (let o = 0; !r; o++) {
		let i = e.getParentNode(o);
		if (We(i) && i.expression === n || M(i) && i.callee === n || N(i) && i.object === n) {
			n = i;
			continue;
		}
		i.type === "NewExpression" && i.callee === n || de(i) && i.expression === n ? (r = e.getParentNode(o + 1), n = i) : r = i;
	}
	return n === t ? !1 : r[SD.get(r.type)] === n;
}
function fp(e, t, r) {
	let { node: n } = e, o = n.type === "ConditionalExpression", i = o ? "consequent" : "trueType", s = o ? "alternate" : "falseType", u = o ? ["test"] : ["checkType", "extendsType"], a = n[i], c = n[s], f = [], y = !1, { parent: F } = e, A = F.type === n.type && u.some((z) => F[z] === n), E = F.type === n.type && !A, P, C, I = 0;
	do
		C = P || n, P = e.getParentNode(I), I++;
	while (P && P.type === n.type && u.every((z) => P[z] !== C));
	let k = P || F, h = C;
	if (o && (H(n[u[0]]) || H(a) || H(c) || gD(h))) {
		y = !0, E = !0;
		let z = (De) => [
			O("("),
			m([D, De]),
			D,
			O(")")
		], xe = (De) => De.type === "NullLiteral" || De.type === "Literal" && De.value === null || De.type === "Identifier" && De.name === "undefined";
		f.push(" ? ", xe(a) ? r(i) : z(r(i)), " : ", c.type === n.type || xe(c) ? r(s) : z(r(s)));
	} else {
		let z = (De) => t.useTabs ? m(r(De)) : Se(2, r(De)), xe = [
			T,
			"? ",
			a.type === n.type ? O("", "(") : "",
			z(i),
			a.type === n.type ? O("", ")") : "",
			T,
			": ",
			z(s)
		];
		f.push(F.type !== n.type || F[s] === n || A ? xe : t.useTabs ? Dn(m(xe)) : Se(Math.max(0, t.tabWidth - 2), xe));
	}
	let v = (z) => F === k ? p(z) : z, U = !y && (N(F) || F.type === "NGPipeExpression" && F.left === n) && !F.computed, ae = BD(e), fe = v([
		hD(e, t, r),
		E ? f : m(f),
		o && U && !ae ? D : ""
	]);
	return A || ae ? p([m([D, fe]), D]) : fe;
}
function bD(e, t) {
	return (N(t) || t.type === "NGPipeExpression" && t.left === e) && !t.computed;
}
function PD(e, t, r, n) {
	return [
		...e.map((i) => re(i)),
		re(t),
		re(r)
	].flat().some((i) => le(i) && te(n.originalText, b(i), S(i)));
}
function kD(e) {
	let { node: t } = e;
	if (t.type !== "ConditionalExpression") return !1;
	let r, n = t;
	for (let o = 0; !r; o++) {
		let i = e.getParentNode(o);
		if (We(i) && i.expression === n || M(i) && i.callee === n || N(i) && i.object === n) {
			n = i;
			continue;
		}
		i.type === "NewExpression" && i.callee === n || de(i) && i.expression === n ? (r = e.getParentNode(o + 1), n = i) : r = i;
	}
	return n === t ? !1 : r[ID.get(r.type)] === n;
}
function gr(e, t, r, n) {
	if (!t.experimentalTernaries) return fp(e, t, r);
	let { node: o } = e, i = o.type === "ConditionalExpression", s = Qe(o), u = i ? "consequent" : "trueType", a = i ? "alternate" : "falseType", c = i ? ["test"] : ["checkType", "extendsType"], f = o[u], y = o[a], F = c.map((br) => o[br]), { parent: A } = e, E = A.type === o.type, P = E && c.some((br) => A[br] === o), C = E && A[a] === o, I = f.type === o.type, k = y.type === o.type, h = k || C, v = t.tabWidth > 2 || t.useTabs, U, ae, fe = 0;
	do
		ae = U || o, U = e.getParentNode(fe), fe++;
	while (U && U.type === o.type && c.every((br) => U[br] !== ae));
	let z = U || A, xe = n && n.assignmentLayout && n.assignmentLayout !== "break-after-operator" && (A.type === "AssignmentExpression" || A.type === "VariableDeclarator" || A.type === "ClassProperty" || A.type === "PropertyDefinition" || A.type === "ClassPrivateProperty" || A.type === "ObjectProperty" || A.type === "Property"), De = ut(A) && !(I || k), xt = i && z.type === "JSXExpressionContainer" && e.grandparent.type !== "JSXAttribute", bt = kD(e), _ = bD(o, A), Ae = s && oe(e, t), we = v ? t.useTabs ? "	" : " ".repeat(t.tabWidth - 1) : "", Pt = PD(F, f, y, t) || I || k, Sr = !h && !E && !s && (xt ? f.type === "NullLiteral" || f.type === "Literal" && f.value === null : Wr(f, t) && xi(o.test, 3)), ki = h || C || s && !E || E && i && xi(o.test, 1) || Sr, qr = [];
	x(o.test, g.Dangling) && e.call(() => {
		qr.push(W(e, t));
	}, "test"), x(o, g.Dangling) && qr.push(W(e, t));
	let wi = Symbol("test"), Kp = Symbol("consequent"), Yr = Symbol("test-and-consequent"), Li = p([i ? [Ai(r("test")), o.test.type === "ConditionalExpression" ? je : ""] : [
		r("checkType"),
		" ",
		"extends",
		" ",
		Qe(o.extendsType) || o.extendsType.type === "TSMappedType" ? r("extendsType") : p(Ai(r("extendsType")))
	], " ?"], { id: wi }), Qp = r(u), Hr = m([I || xt && (H(f) || E || h) ? d : T, Qp]), zp = ki ? p([Li, h ? Hr : O(Hr, p(Hr, { id: Kp }), { groupId: wi })], { id: Yr }) : [Li, Hr], Eo = r(a), Oi = Sr ? O(Eo, Dn(Ai(Eo)), { groupId: Yr }) : Eo, Br = [
		zp,
		qr.length > 0 ? [m([d, qr]), d] : k ? d : Sr ? O(T, " ", { groupId: Yr }) : T,
		":",
		k || !v ? " " : ki ? O(we, O(h || Sr ? " " : we, " "), { groupId: Yr }) : O(we, " "),
		k ? Oi : p([m(Oi), xt && !Sr ? D : ""]),
		_ && !bt ? D : "",
		Pt ? je : ""
	];
	return xe && !Pt ? p(m([D, p(Br)])) : xe || De ? p(m(Br)) : bt || s && P ? p([m([D, Br]), Ae ? D : ""]) : A === z ? p(Br) : Br;
}
function Dp(e, t, r) {
	let { node: n } = e;
	return [
		"try ",
		r("block"),
		n.handler ? [" ", r("handler")] : "",
		n.finalizer ? [" finally ", r("finalizer")] : ""
	];
}
function yp(e, t, r) {
	let { node: n } = e;
	if (n.param) {
		let o = x(n.param, (s) => !le(s) || s.leading && J(t.originalText, S(s)) || s.trailing && J(t.originalText, b(s), { backwards: !0 })), i = r("param");
		return [
			"catch ",
			o ? [
				"(",
				m([D, i]),
				D,
				") "
			] : [
				"(",
				i,
				") "
			],
			r("body")
		];
	}
	return ["catch ", r("body")];
}
function eo(e, t, r) {
	let { node: n } = e, o = e.map(r, "declarations"), i = e.key === "init" && e.parent.type === "ForStatement" || e.key === "left" && (e.parent.type === "ForInStatement" || e.parent.type === "ForOfStatement"), s = n.declarations.some((a) => a.init), u;
	return o.length === 1 && !x(n.declarations[0]) ? u = o[0] : u = m(o[0]), p([
		ne(e),
		n.kind,
		u ? [" ", u] : "",
		m(o.slice(1).map((a) => [
			",",
			s && !i ? d : T,
			a
		])),
		i ? "" : R(t)
	]);
}
function Ep(e, t, r) {
	let { node: n } = e;
	return p([
		n.type === "WithStatement" ? "with" : "while",
		" (",
		fr(e, t, r),
		")",
		Ft(e, t, r)
	]);
}
function dp(e, t, r, n) {
	let { node: o } = e;
	if (er(o)) return ep(e, t);
	switch (o.type) {
		case "JsExpressionRoot": return r("node");
		case "JsonRoot": return [
			W(e, t),
			r("node"),
			d
		];
		case "File": return Ka(e, t, r) ?? r("program");
		case "ExpressionStatement": return Ha(e, t, r);
		case "ChainExpression": return r("expression");
		case "ParenthesizedExpression": return !x(o.expression) && (ie(o.expression) || Y(o.expression)) ? [
			"(",
			r("expression"),
			")"
		] : p([
			"(",
			m([D, r("expression")]),
			D,
			")"
		]);
		case "AssignmentExpression": return Sa(e, t, r);
		case "VariableDeclarator": return Ba(e, t, r);
		case "BinaryExpression":
		case "LogicalExpression": return Rn(e, t, r);
		case "AssignmentPattern": return [
			r("left"),
			" = ",
			r("right")
		];
		case "OptionalMemberExpression":
		case "MemberExpression": return xa(e, t, r);
		case "MetaProperty": return [
			r("meta"),
			".",
			r("property")
		];
		case "BindExpression": return Fa(e, t, r);
		case "Identifier": return [
			o.name,
			$(e),
			hn(e),
			G(e, r)
		];
		case "V8IntrinsicIdentifier": return ["%", o.name];
		case "SpreadElement": return Tr(e, r);
		case "RestElement": return Tr(e, r);
		case "FunctionDeclaration":
		case "FunctionExpression": return Dr(e, t, r, n);
		case "ArrowFunctionExpression": return ya(e, t, r, n);
		case "YieldExpression": return [`yield${o.delegate ? "*" : ""}`, o.argument ? [" ", r("argument")] : ""];
		case "AwaitExpression": return Ia(e, t, r);
		case "ExportDefaultDeclaration":
		case "ExportNamedDeclaration":
		case "ExportAllDeclaration": return Qn(e, t, r);
		case "ImportDeclaration": return rp(e, t, r);
		case "ImportSpecifier":
		case "ExportSpecifier":
		case "ImportNamespaceSpecifier":
		case "ExportNamespaceSpecifier":
		case "ImportDefaultSpecifier":
		case "ExportDefaultSpecifier": return ap(e, t, r);
		case "ImportAttribute": return zn(e, t, r);
		case "Program":
		case "BlockStatement":
		case "StaticBlock": return Hn(e, t, r);
		case "ClassBody": return Kt(e, t, r);
		case "ThrowStatement": return Zn(e, t, r);
		case "ReturnStatement": return Zn(e, t, r);
		case "NewExpression":
		case "ImportExpression":
		case "OptionalCallExpression":
		case "CallExpression": return Vt(e, t, r);
		case "ObjectExpression":
		case "ObjectPattern": return ft(e, t, r);
		case "Property": return $e(o) ? Rr(e, t, r) : zn(e, t, r);
		case "ObjectProperty": return zn(e, t, r);
		case "ObjectMethod": return Rr(e, t, r);
		case "Decorator": return ["@", r("expression")];
		case "ArrayExpression":
		case "ArrayPattern": return xr(e, t, r);
		case "SequenceExpression": return pp(e, t, r);
		case "ThisExpression": return "this";
		case "Super": return "super";
		case "Directive": return [r("value"), R(t)];
		case "UnaryExpression": {
			let i = [o.operator];
			/[a-z]$/.test(o.operator) && i.push(" ");
			let s = r("argument");
			return x(o.argument) ? i.push(p([
				"(",
				m([D, s]),
				D,
				")"
			])) : i.push(s), i;
		}
		case "UpdateExpression": return [
			o.prefix ? o.operator : "",
			r("argument"),
			o.prefix ? "" : o.operator
		];
		case "ConditionalExpression": return gr(e, t, r, n);
		case "VariableDeclaration": return eo(e, t, r);
		case "IfStatement": return Qa(e, t, r);
		case "ForStatement": return Xa(e, t, r);
		case "WithStatement":
		case "WhileStatement": return Ep(e, t, r);
		case "DoWhileStatement": return Ua(e, t, r);
		case "ForInStatement":
		case "ForOfStatement": return Va(e, t, r);
		case "DoExpression": return [
			o.async ? "async " : "",
			"do ",
			r("body")
		];
		case "BreakStatement":
		case "ContinueStatement": return [
			o.type === "BreakStatement" ? "break" : "continue",
			o.label ? [" ", r("label")] : "",
			R(t)
		];
		case "LabeledStatement": return [
			r("label"),
			`:${o.body.type === "EmptyStatement" && !x(o.body, g.Leading) ? "" : " "}`,
			r("body")
		];
		case "TryStatement": return Dp(e, t, r);
		case "CatchClause": return yp(e, t, r);
		case "SwitchStatement": return cp(e, t, r);
		case "SwitchCase": return lp(e, t, r);
		case "DebuggerStatement": return ["debugger", R(t)];
		case "ClassDeclaration":
		case "ClassExpression": return Ar(e, t, r);
		case "ClassMethod":
		case "ClassPrivateMethod":
		case "MethodDefinition": return Xn(e, t, r);
		case "ClassProperty":
		case "PropertyDefinition":
		case "ClassPrivateProperty":
		case "ClassAccessorProperty":
		case "AccessorProperty": return Vn(e, t, r);
		case "TemplateElement": return Ve(o.value.raw);
		case "TemplateLiteral": return On(e, t, r);
		case "TaggedTemplateExpression": return Bu(e, t, r);
		case "PrivateIdentifier": return ["#", o.name];
		case "PrivateName": return ["#", r("id")];
		case "TopicReference": return "%";
		case "ArgumentPlaceholder": return "?";
		case "ModuleExpression": return ["module ", r("body")];
		case "VoidPattern": return "void";
		case "EmptyStatement": if (zt(e)) return ";";
		default: throw new it(o, "ESTree");
	}
}
function to(e) {
	return [e("elementType"), "[]"];
}
function ro(e, t, r) {
	let { parent: n, node: o, key: i } = e, u = o.type === "AsConstExpression" ? "const" : r("typeAnnotation"), a = [
		r("expression"),
		" ",
		Ui(o) ? "satisfies" : "as",
		" ",
		u
	];
	return i === "callee" && Tt(n) || i === "object" && N(n) ? p([m([D, ...a]), D]) : a;
}
function Cp(e, t, r) {
	let { node: n } = e, o = [
		ne(e),
		n.async ? "async " : "",
		"component"
	];
	n.id && o.push(" ", r("id")), o.push(r("typeParameters"));
	let i = Ke(e, t, r);
	return n.rendersType ? o.push(p([
		i,
		" ",
		r("rendersType")
	])) : o.push(p([i])), n.body && o.push(" ", r("body")), n.type === "DeclareComponent" && o.push(R(t)), o;
}
function Fp(e, t, r) {
	let { node: n } = e;
	return n.shorthand ? r("local") : [
		r("name"),
		" as ",
		r("local")
	];
}
function xp(e, t, r) {
	let { node: n } = e, o = [];
	return n.name && o.push(r("name"), n.optional ? "?: " : ": "), o.push(r("typeAnnotation")), o;
}
function Ap(e, t, r) {
	let { node: n } = e;
	return [n.explicitType ? `of ${n.explicitType} ` : "", ft(e, t, r)];
}
function Tp(e, t, r) {
	let { node: n } = e;
	return [n.type === "EnumSymbolBody" || n.explicitType ? `of ${n.type.slice(4, -4).toLowerCase()} ` : "", ft(e, t, r)];
}
function no(e, t, r) {
	let { node: n } = e, o = n.type === "TSEnumMember", i = o ? ve(e, t, r) : r("id"), s = o ? "initializer" : "init";
	return n[s] ? [
		i,
		" = ",
		r(s)
	] : i;
}
function oo(e, t) {
	let { node: r } = e;
	return [
		ne(e),
		r.const ? "const " : "",
		"enum ",
		t("id"),
		" ",
		t("body")
	];
}
function io(e, t, r) {
	let { node: n } = e, o = [mr(e)];
	(n.type === "TSConstructorType" || n.type === "TSConstructSignatureDeclaration") && o.push("new ");
	let i = Ke(e, t, r, !1, !0), s = [];
	return n.type === "FunctionTypeAnnotation" ? s.push(wD(e) ? " => " : ": ", r("returnType")) : s.push(G(e, r, "returnType")), Bt(n, s) && (i = p(i)), o.push(i, s), [p(o), n.type === "TSConstructSignatureDeclaration" || n.type === "TSCallSignatureDeclaration" ? ke(e, t) : ""];
}
function wD(e) {
	let { node: t, parent: r } = e;
	return t.type === "FunctionTypeAnnotation" && (pr(r) || !((r.type === "ObjectTypeProperty" || r.type === "ObjectTypeInternalSlot") && !r.variance && !r.optional && kt(r, t) || r.type === "ObjectTypeCallProperty" || e.getParentNode(2)?.type === "DeclareFunction"));
}
function hp(e, t, r) {
	return [
		ne(e),
		"hook",
		e.node.id ? [" ", r("id")] : "",
		R(t)
	];
}
function gp(e) {
	let { node: t } = e;
	return t.type === "HookTypeAnnotation" && e.getParentNode(2)?.type === "DeclareHook";
}
function Sp(e, t, r) {
	let { node: n } = e, o = Ke(e, t, r, !1, !0), i = [gp(e) ? ": " : " => ", r("returnType")];
	return p([
		gp(e) ? "" : "hook ",
		Bt(n, i) ? p(o) : o,
		i
	]);
}
function so(e, t, r) {
	return [
		r("objectType"),
		$(e),
		"[",
		r("indexType"),
		"]"
	];
}
function uo(e, t, r) {
	return ["infer ", r("typeParameter")];
}
function ao(e, t, r) {
	let n = !1;
	return p(e.map(({ isFirst: o, previous: i, node: s, index: u }) => {
		let a = r();
		if (o) return a;
		let c = Ye(s), f = Ye(i);
		return f && c ? [" & ", n ? m(a) : a] : !f && !c || Oe(t.originalText, s) ? t.experimentalOperatorPosition === "start" ? m([
			T,
			"& ",
			a
		]) : m([
			" &",
			T,
			a
		]) : (u > 1 && (n = !0), [" & ", u > 1 ? m(a) : a]);
	}, "types"));
}
function LD(e) {
	switch (e) {
		case null: return "";
		case "PlusOptional": return "+?";
		case "MinusOptional": return "-?";
		case "Optional": return "?";
	}
}
function bp(e, t, r) {
	let { node: n } = e;
	return [p([
		n.variance ? r("variance") : "",
		p([
			"[",
			m([
				D,
				r("keyTparam"),
				" in ",
				r("sourceType")
			]),
			D,
			"]"
		]),
		LD(n.optional),
		": ",
		r("propType")
	]), ke(e, t)];
}
function Bp(e, t) {
	return e === "+" || e === "-" ? e + t : t;
}
function Pp(e, t, r) {
	let { node: n } = e, o = !1;
	if (t.objectWrap === "preserve") {
		let u = ce(t), a = b(n) + 1, f = a + u.slice(a).search(/\S/);
		te(t.originalText, a, f) && (o = !0);
	}
	let i = [], s = re(n, g.Dangling);
	if (s.length > 0) {
		let u = w(0, s, -1), a = W(e, t);
		i.push(...a.slice(0, -1), p([w(0, a, -1), Le(u) || J(t.originalText, S(u)) ? d : T]));
	}
	return p([
		"{",
		m([
			t.bracketSpacing ? T : D,
			...i,
			n.readonly ? [Bp(n.readonly, "readonly"), " "] : "",
			p([
				"[",
				m([
					D,
					r("key"),
					" in ",
					r("constraint"),
					n.nameType ? [" as ", r("nameType")] : ""
				]),
				D,
				"]"
			]),
			n.optional ? Bp(n.optional, "?") : "",
			n.typeAnnotation ? ": " : "",
			r("typeAnnotation"),
			t.semi ? O(";") : ""
		]),
		t.bracketSpacing ? T : D,
		"}"
	], { shouldBreak: o });
}
function Ip(e, t, r) {
	let { node: n } = e;
	return [
		p([
			"match (",
			m([D, r("argument")]),
			D,
			")"
		]),
		" {",
		n.cases.length > 0 ? m([d, L(d, e.map(({ node: o, isLast: i }) => [r(), !i && me(o, t) ? d : ""], "cases"))]) : "",
		d,
		"}"
	];
}
function kp(e, t, r) {
	let { node: n } = e, o = x(n, g.Dangling) ? [" ", W(e, t)] : [], i = n.type === "MatchStatementCase" ? [" ", r("body")] : m([
		T,
		r("body"),
		","
	]);
	return [
		r("pattern"),
		n.guard ? p([m([
			T,
			"if (",
			r("guard"),
			")"
		])]) : "",
		p([
			" =>",
			o,
			i
		])
	];
}
function wp(e, t, r) {
	let { node: n } = e;
	switch (n.type) {
		case "MatchOrPattern": return ND(e, t, r);
		case "MatchAsPattern": return [
			r("pattern"),
			" as ",
			r("target")
		];
		case "MatchWildcardPattern": return ["_"];
		case "MatchLiteralPattern": return r("literal");
		case "MatchUnaryPattern": return [n.operator, r("argument")];
		case "MatchIdentifierPattern": return r("id");
		case "MatchMemberPattern": {
			let o = n.property.type === "Identifier" ? [".", r("property")] : [
				"[",
				m([D, r("property")]),
				D,
				"]"
			];
			return p([r("base"), o]);
		}
		case "MatchBindingPattern": return [
			n.kind,
			" ",
			r("id")
		];
		case "MatchObjectPattern":
		case "MatchInstanceObjectPattern": return OD(e, t, r);
		case "MatchInstancePattern": return p([
			r("targetConstructor"),
			" ",
			r("properties")
		]);
		case "MatchArrayPattern": {
			let o = e.map(r, "elements");
			return n.rest && o.push(r("rest")), p([
				"[",
				m([D, L([",", T], o)]),
				n.rest ? "" : O(","),
				D,
				"]"
			]);
		}
		case "MatchObjectPatternProperty": return n.shorthand ? r("pattern") : p([
			r("key"),
			":",
			m([T, r("pattern")])
		]);
		case "MatchRestPattern": {
			let o = ["..."];
			return n.argument && o.push(r("argument")), o;
		}
	}
}
function OD(e, t, r) {
	let { node: n } = e, o = e.map(r, "properties");
	return n.rest && o.push(r("rest")), p([
		"{",
		m([D, L([",", T], o)]),
		n.rest ? "" : O(","),
		D,
		"}"
	]);
}
function MD(e) {
	let { patterns: t } = e;
	if (t.some((n) => x(n))) return !1;
	let r = t.find((n) => n.type === "MatchObjectPattern");
	return r ? t.every((n) => n === r || Lp(n)) : !1;
}
function _D(e) {
	return Lp(e) || e.type === "MatchObjectPattern" ? !0 : e.type === "MatchOrPattern" ? MD(e) : !1;
}
function ND(e, t, r) {
	let { node: n } = e, { parent: o } = e, i = o.type !== "MatchStatementCase" && o.type !== "MatchExpressionCase" && o.type !== "MatchArrayPattern" && o.type !== "MatchObjectPatternProperty" && !Oe(t.originalText, n), s = _D(n), u = e.map(() => {
		let c = r();
		return s || (c = Se(2, c)), Q(e, c, t);
	}, "patterns");
	if (s) return L(" | ", u);
	let a = [O(["| "]), L([T, "| "], u)];
	return oe(e, t) ? p([m([O([D]), a]), D]) : o.type === "MatchArrayPattern" && o.elements.length > 1 ? p([
		m([O(["(", D]), a]),
		D,
		O(")")
	]) : p(i ? m(a) : a);
}
function Op(e, t, r) {
	let { node: n } = e, o = [
		ne(e),
		"opaque type ",
		r("id"),
		r("typeParameters")
	];
	if (n.supertype && o.push(": ", r("supertype")), n.lowerBound || n.upperBound) {
		let i = [];
		n.lowerBound && i.push(m([
			T,
			"super ",
			r("lowerBound")
		])), n.upperBound && i.push(m([
			T,
			"extends ",
			r("upperBound")
		])), o.push(p(i));
	}
	return n.impltype && o.push(" = ", r("impltype")), o.push(R(t)), o;
}
function po(e, t, r) {
	let { node: n } = e;
	return [
		"...",
		...n.type === "TupleTypeSpreadElement" && n.label ? [r("label"), ": "] : [],
		r("typeAnnotation")
	];
}
function co(e, t, r) {
	let { node: n } = e;
	return [
		n.variance ? r("variance") : "",
		r("label"),
		n.optional ? "?" : "",
		": ",
		r("elementType")
	];
}
function lo(e, t, r) {
	let { node: n } = e;
	return [vt(e, t, r, [
		ne(e),
		"type ",
		r("id"),
		r("typeParameters")
	], " =", n.type === "TSTypeAliasDeclaration" ? "typeAnnotation" : "right"), R(t)];
}
function jD(e, t, r) {
	let { node: n } = e;
	return ee(n).length === 1 && n.type.startsWith("TS") && !n[r][0].constraint && e.parent.type === "ArrowFunctionExpression" && !(t.filepath && /\.ts$/.test(t.filepath));
}
function $t(e, t, r, n) {
	let { node: o } = e, i = o[n];
	if (!i) return "";
	if (!Array.isArray(i)) return r(n);
	let s = Ut(e.grandparent), u = e.match((f) => !(f[n].length === 1 && Ye(f[n][0])), void 0, (f, y) => y === "typeAnnotation", (f) => f.type === "Identifier", yi);
	if (i.length === 0 || !u && (s || i.length === 1 && (i[0].type === "NullableTypeAnnotation" || Fu(i[0]))) && !i.some((f) => {
		let y = re(f, (F) => F.leading || F.trailing);
		return y.length > 0 && (y.some((F) => Le(F)) || J(t.originalText, S(w(0, y, -1))));
	})) return [
		"<",
		L(", ", e.map(r, n)),
		vD(e, t),
		">"
	];
	let c = o.type === "TSTypeParameterInstantiation" ? "" : jD(e, t, n) ? "," : Ie(t);
	return p([
		"<",
		m([D, L([",", T], e.map(r, n))]),
		c,
		D,
		">"
	]);
}
function vD(e, t) {
	let { node: r } = e;
	if (!x(r, g.Dangling)) return "";
	let n = !x(r, g.Line), o = W(e, t, { indent: !n });
	return n ? o : [o, d];
}
function mo(e, t, r) {
	let { node: n } = e, o = [n.const ? "const " : ""], i = n.type === "TSTypeParameter" ? r("name") : n.name;
	if (n.variance && o.push(r("variance")), n.in && o.push("in "), n.out && o.push("out "), o.push(i), n.bound && (n.usesExtendsBound && o.push(" extends "), o.push(G(e, r, "bound"))), n.constraint) {
		let s = Symbol("constraint");
		o.push(" extends", p(m(T), { id: s }), Be, ht(r("constraint"), { groupId: s }));
	}
	if (n.default) {
		let s = Symbol("default");
		o.push(" =", p(m(T), { id: s }), Be, ht(r("default"), { groupId: s }));
	}
	return p(o);
}
function fo(e, t) {
	let { node: r } = e;
	return [
		r.type === "TSTypePredicate" && r.asserts ? "asserts " : r.type === "TypePredicate" && r.kind ? `${r.kind} ` : "",
		t("parameterName"),
		r.typeAnnotation ? [" is ", G(e, t)] : ""
	];
}
function Do({ node: e }, t) {
	return [
		"typeof ",
		t(e.type === "TSTypeQuery" ? "exprName" : "argument"),
		t("typeArguments")
	];
}
function Mp(e, t, r, n) {
	let { node: o } = e;
	if (Cn(o)) return o.type.slice(0, -14).toLowerCase();
	switch (o.type) {
		case "ComponentDeclaration":
		case "DeclareComponent":
		case "ComponentTypeAnnotation": return Cp(e, t, r);
		case "ComponentParameter": return Fp(e, t, r);
		case "ComponentTypeParameter": return xp(e, t, r);
		case "HookDeclaration": return Dr(e, t, r);
		case "DeclareHook": return hp(e, t, r);
		case "HookTypeAnnotation": return Sp(e, t, r);
		case "DeclareFunction": return [
			ne(e),
			"function ",
			r("id"),
			r("predicate"),
			R(t)
		];
		case "DeclareModule": return [
			"declare module ",
			r("id"),
			" ",
			r("body")
		];
		case "DeclareModuleExports": return [
			"declare module.exports",
			G(e, r),
			R(t)
		];
		case "DeclareNamespace": return [
			"declare namespace ",
			r("id"),
			" ",
			r("body")
		];
		case "DeclareVariable": return Array.isArray(o.declarations) ? eo(e, t, r) : [
			ne(e),
			o.kind ?? "var",
			" ",
			r("id"),
			R(t)
		];
		case "DeclareExportDeclaration":
		case "DeclareExportAllDeclaration": return Qn(e, t, r);
		case "DeclareOpaqueType":
		case "OpaqueType": return Op(e, t, r);
		case "DeclareTypeAlias":
		case "TypeAlias": return lo(e, t, r);
		case "IntersectionTypeAnnotation": return ao(e, t, r);
		case "UnionTypeAnnotation": return bn(e, t, r, n);
		case "ConditionalTypeAnnotation": return gr(e, t, r);
		case "InferTypeAnnotation": return uo(e, t, r);
		case "FunctionTypeAnnotation": return io(e, t, r);
		case "TupleTypeAnnotation": return xr(e, t, r);
		case "TupleTypeLabeledElement": return co(e, t, r);
		case "TupleTypeSpreadElement": return po(e, t, r);
		case "GenericTypeAnnotation": return [r("id"), $t(e, t, r, "typeParameters")];
		case "IndexedAccessType":
		case "OptionalIndexedAccessType": return so(e, t, r);
		case "TypeAnnotation": return Pn(e, t, r);
		case "TypeParameter": return mo(e, t, r);
		case "TypeofTypeAnnotation": return Do(e, r);
		case "ExistsTypeAnnotation": return "*";
		case "ArrayTypeAnnotation": return to(r);
		case "DeclareEnum":
		case "EnumDeclaration": return oo(e, r);
		case "EnumBody": return Ap(e, t, r);
		case "EnumBooleanBody":
		case "EnumNumberBody":
		case "EnumBigIntBody":
		case "EnumStringBody":
		case "EnumSymbolBody": return Tp(e, t, r);
		case "EnumBooleanMember":
		case "EnumNumberMember":
		case "EnumBigIntMember":
		case "EnumStringMember":
		case "EnumDefaultedMember": return no(e, t, r);
		case "FunctionTypeParam": {
			let i = o.name ? r("name") : e.parent.this === o ? "this" : "";
			return [
				i,
				$(e),
				i ? ": " : "",
				r("typeAnnotation")
			];
		}
		case "DeclareClass":
		case "DeclareInterface":
		case "InterfaceDeclaration":
		case "InterfaceTypeAnnotation":
		case "RecordDeclaration": return Ar(e, t, r);
		case "ObjectTypeAnnotation":
		case "RecordDeclarationBody": return Kt(e, t, r);
		case "ClassImplements":
		case "InterfaceExtends": return [r("id"), r("typeParameters")];
		case "RecordDeclarationImplements": return [r("id"), r("typeArguments")];
		case "NullableTypeAnnotation": return ["?", r("typeAnnotation")];
		case "Variance": {
			let { kind: i } = o;
			return Re(i === "plus" || i === "minus" || i === "readonly" || i === "writeonly" || i === "in" || i === "out"), i === "plus" ? "+" : i === "minus" ? "-" : `${i} `;
		}
		case "KeyofTypeAnnotation": return ["keyof ", r("argument")];
		case "ObjectTypeCallProperty": return [
			o.static ? "static " : "",
			r("value"),
			ke(e, t)
		];
		case "ObjectTypeMappedTypeProperty": return bp(e, t, r);
		case "ObjectTypeIndexer": return [
			o.static ? "static " : "",
			o.variance ? r("variance") : "",
			"[",
			r("id"),
			o.id ? ": " : "",
			r("key"),
			"]: ",
			r("value"),
			ke(e, t)
		];
		case "ObjectTypeProperty": {
			let i = "";
			return o.proto ? i = "proto " : o.static && (i = "static "), [
				i,
				o.kind !== "init" ? o.kind + " " : "",
				o.variance ? r("variance") : "",
				ve(e, t, r),
				$(e),
				$e(o) ? "" : ": ",
				r("value"),
				ke(e, t)
			];
		}
		case "ObjectTypeInternalSlot": return [
			o.static ? "static " : "",
			"[[",
			r("id"),
			"]]",
			$(e),
			o.method ? "" : ": ",
			r("value"),
			ke(e, t)
		];
		case "ObjectTypeSpreadProperty": return Tr(e, r);
		case "QualifiedTypeofIdentifier":
		case "QualifiedTypeIdentifier": return [
			r("qualification"),
			".",
			r("id")
		];
		case "NullLiteralTypeAnnotation": return "null";
		case "BooleanLiteralTypeAnnotation": return String(o.value);
		case "StringLiteralTypeAnnotation": return Ve(ot(ye(o), t));
		case "NumberLiteralTypeAnnotation": return _t(ye(o));
		case "BigIntLiteralTypeAnnotation": return $n(ye(o));
		case "TypeCastExpression": return [
			"(",
			r("expression"),
			G(e, r),
			")"
		];
		case "TypePredicate": return fo(e, r);
		case "TypeOperator": return [
			o.operator,
			" ",
			r("typeAnnotation")
		];
		case "TypeParameterDeclaration":
		case "TypeParameterInstantiation": return $t(e, t, r, "params");
		case "InferredPredicate":
		case "DeclaredPredicate": return [
			e.key === "predicate" && e.parent.type !== "DeclareFunction" && !e.parent.returnType ? ": " : " ",
			"%checks",
			...o.type === "DeclaredPredicate" ? [
				"(",
				r("value"),
				")"
			] : []
		];
		case "AsExpression":
		case "AsConstExpression":
		case "SatisfiesExpression": return ro(e, t, r);
		case "MatchExpression":
		case "MatchStatement": return Ip(e, t, r);
		case "MatchExpressionCase":
		case "MatchStatementCase": return kp(e, t, r);
		case "MatchOrPattern":
		case "MatchAsPattern":
		case "MatchWildcardPattern":
		case "MatchLiteralPattern":
		case "MatchUnaryPattern":
		case "MatchIdentifierPattern":
		case "MatchInstancePattern":
		case "MatchInstanceObjectPattern":
		case "MatchMemberPattern":
		case "MatchBindingPattern":
		case "MatchObjectPattern":
		case "MatchObjectPatternProperty":
		case "MatchRestPattern":
		case "MatchArrayPattern": return wp(e, t, r);
		case "RecordExpression": return [
			r("recordConstructor"),
			r("typeArguments"),
			" ",
			r("properties")
		];
		case "RecordExpressionProperties": return ft(e, t, r);
		case "RecordDeclarationProperty":
		case "RecordDeclarationStaticProperty": {
			let i = o.type === "RecordDeclarationStaticProperty", s = i ? "value" : "defaultValue";
			return [
				i ? "static " : "",
				ve(e, t, r),
				G(e, r),
				o[s] ? [" = ", r(s)] : ""
			];
		}
	}
}
function _p(e, t) {
	let { node: r } = e, n = t.originalText.slice(b(r), S(r));
	return t.semi && Pr(r) ? n += ";" : yr(e, t) && (n = `;${n}`), r.type === "ClassExpression" && j(r.decorators) ? [m([D, n]), D] : n;
}
function RD(e, t, r) {
	let { node: n } = e;
	if (n.type === "JSXElement" && ey(n)) return [r("openingElement"), r("closingElement")];
	let o = n.type === "JSXElement" ? r("openingElement") : r("openingFragment"), i = n.type === "JSXElement" ? r("closingElement") : r("closingFragment");
	if (n.children.length === 1 && n.children[0].type === "JSXExpressionContainer" && (n.children[0].expression.type === "TemplateLiteral" || n.children[0].expression.type === "TaggedTemplateExpression")) return [
		o,
		...e.map(r, "children"),
		i
	];
	n.children = n.children.map((h) => ty(h) ? {
		type: "JSXText",
		value: " ",
		raw: " "
	} : h);
	let s = n.children.some(H), u = n.children.filter((h) => h.type === "JSXExpressionContainer").length > 1, a = n.type === "JSXElement" && n.openingElement.attributes.length > 1, c = ue(o) || s || a || u, f = e.parent.rootMarker === "mdx", y = t.singleQuote ? "{' '}" : "{\" \"}", F = f ? T : O([y, D], " "), E = WD(e, t, r, F, n.openingElement?.name?.name === "fbt"), P = n.children.some((h) => Xt(h));
	for (let h = E.length - 2; h >= 0; h--) {
		let v = E[h] === "" && E[h + 1] === "", U = E[h] === d && E[h + 1] === "" && E[h + 2] === d, ae = (E[h] === D || E[h] === d) && E[h + 1] === "" && E[h + 2] === F, fe = E[h] === F && E[h + 1] === "" && (E[h + 2] === D || E[h + 2] === d), z = E[h] === F && E[h + 1] === "" && E[h + 2] === F, xe = E[h] === D && E[h + 1] === "" && E[h + 2] === d || E[h] === d && E[h + 1] === "" && E[h + 2] === D;
		U && P || v || ae || z || xe ? E.splice(h, 2) : fe && E.splice(h + 1, 2);
	}
	for (; E.length > 0 && Ti(w(0, E, -1));) E.pop();
	for (; E.length > 1 && Ti(E[0]) && Ti(E[1]);) E.shift(), E.shift();
	let C = [""];
	for (let [h, v] of E.entries()) {
		if (v === F) {
			if (h === 1 && js(E[h - 1])) {
				if (E.length === 2) {
					C.push([C.pop(), y]);
					continue;
				}
				C.push([y, d], "");
				continue;
			}
			if (h === E.length - 1) {
				C.push([C.pop(), y]);
				continue;
			}
			if (E[h - 1] === "" && E[h - 2] === d) {
				C.push([C.pop(), y]);
				continue;
			}
		}
		h % 2 === 0 ? C.push([C.pop(), v]) : C.push(v, ""), ue(v) && (c = !0);
	}
	let I = P ? yn(C) : p(C, { shouldBreak: !0 });
	if (t.cursorNode?.type === "JSXText" && n.children.includes(t.cursorNode) ? I = [
		jr,
		I,
		jr
	] : t.nodeBeforeCursor?.type === "JSXText" && n.children.includes(t.nodeBeforeCursor) ? I = [jr, I] : t.nodeAfterCursor?.type === "JSXText" && n.children.includes(t.nodeAfterCursor) && (I = [I, jr]), f) return I;
	let k = p([
		o,
		m([d, I]),
		d,
		i
	]);
	return c ? k : mt([p([
		o,
		...E,
		i
	]), k]);
}
function WD(e, t, r, n, o) {
	let i = "", s = [i];
	function u(c) {
		i = c, s.push([s.pop(), c]);
	}
	function a(c) {
		c !== "" && (i = c, s.push(c, ""));
	}
	return e.each(({ node: c, next: f }) => {
		if (c.type === "JSXText") {
			let y = ye(c);
			if (Xt(c)) {
				let F = dr.split(y, !0);
				F[0] === "" && (F.shift(), /\n/.test(F[0]) ? a(jp(o, F[1], c, f)) : a(n), F.shift());
				let A;
				if (w(0, F, -1) === "" && (F.pop(), A = F.pop()), F.length === 0) return;
				for (let [E, P] of F.entries()) E % 2 === 1 ? a(T) : u(P);
				A !== void 0 ? /\n/.test(A) ? a(jp(o, i, c, f)) : a(n) : a(Np(o, i, c, f));
			} else /\n/.test(y) ? y.match(/\n/g).length > 1 && a(d) : a(n);
		} else if (u(r()), f && Xt(f)) {
			let A = dr.trim(ye(f)), [E] = dr.split(A);
			a(Np(o, E, c, f));
		} else a(d);
	}, "children"), s;
}
function Np(e, t, r, n) {
	return e ? "" : r.type === "JSXElement" && !r.closingElement || n?.type === "JSXElement" && !n.closingElement ? t.length === 1 ? D : d : D;
}
function jp(e, t, r, n) {
	return e ? d : t.length === 1 ? r.type === "JSXElement" && !r.closingElement || n?.type === "JSXElement" && !n.closingElement ? d : D : d;
}
function GD(e, t, r) {
	let { parent: n } = e;
	if (JD(n)) return t;
	let o = UD(e), i = oe(e, r);
	return p([
		i ? "" : O("("),
		m([D, t]),
		D,
		i ? "" : O(")")
	], { shouldBreak: o });
}
function UD(e) {
	return e.match(void 0, (t, r) => r === "body" && t.type === "ArrowFunctionExpression", (t, r) => r === "arguments" && M(t)) && (e.match(void 0, void 0, void 0, (t, r) => r === "expression" && t.type === "JSXExpressionContainer") || e.match(void 0, void 0, void 0, (t, r) => r === "expression" && t.type === "ChainExpression", (t, r) => r === "expression" && t.type === "JSXExpressionContainer"));
}
function qD(e, t, r) {
	let { node: n } = e, o = [r("name")];
	if (n.value) {
		let i;
		if (q(n.value)) {
			let u = V(0, V(0, ye(n.value).slice(1, -1), "&apos;", "'"), "&quot;", "\""), a = Sn(u, t.jsxSingleQuote);
			u = a === "\"" ? V(0, u, "\"", "&quot;") : V(0, u, "'", "&apos;"), i = e.call(() => Q(e, Ve(a + u + a), t), "value");
		} else i = r("value");
		o.push("=", i);
	}
	return o;
}
function YD(e, t, r) {
	let { node: n } = e, o = (i, s) => i.type === "JSXEmptyExpression" || !x(i) && (Y(i) || ie(i) || i.type === "ArrowFunctionExpression" || i.type === "AwaitExpression" && (o(i.argument, i) || i.argument.type === "JSXElement") || M(Pe(i)) || i.type === "FunctionExpression" || i.type === "TemplateLiteral" || i.type === "TaggedTemplateExpression" || i.type === "DoExpression" || H(s) && (i.type === "ConditionalExpression" || be(i)));
	return o(n.expression, e.parent) ? p([
		"{",
		r("expression"),
		Be,
		"}"
	]) : p([
		"{",
		m([D, r("expression")]),
		D,
		Be,
		"}"
	]);
}
function HD(e, t, r) {
	let { node: n } = e, o = x(n.name) || x(n.typeArguments);
	if (n.selfClosing && n.attributes.length === 0 && !o) return [
		"<",
		r("name"),
		r("typeArguments"),
		" />"
	];
	if (n.attributes?.length === 1 && q(n.attributes[0].value) && !n.attributes[0].value.value.includes(`
`) && !o && !x(n.attributes[0])) return p([
		"<",
		r("name"),
		r("typeArguments"),
		" ",
		...e.map(r, "attributes"),
		n.selfClosing ? " />" : ">"
	]);
	let i = n.attributes?.some((u) => q(u.value) && u.value.value.includes(`
`)), s = t.singleAttributePerLine && n.attributes.length > 1 ? d : T;
	return p([
		"<",
		r("name"),
		r("typeArguments"),
		m(e.map(({ isFirst: u, previous: a }) => [u ? s : me(a, t) ? [d, d] : s, r()], "attributes")),
		...XD(n, t, o)
	], { shouldBreak: i });
}
function XD(e, t, r) {
	return e.selfClosing ? [T, "/>"] : VD(e, t, r) ? [">"] : [D, ">"];
}
function VD(e, t, r) {
	let n = e.attributes.length > 0 && x(w(0, e.attributes, -1), g.Trailing);
	return e.attributes.length === 0 && !r || (t.bracketSameLine || t.jsxBracketSameLine) && (!r || e.attributes.length > 0) && !n;
}
function KD(e, t, r) {
	let { node: n } = e, o = ["</"], i = r("name");
	return x(n.name, g.Leading | g.Line) ? o.push(m([d, i]), d) : x(n.name, g.Leading | g.Block) ? o.push(" ", i) : o.push(i), o.push(">"), o;
}
function $D(e, t) {
	let { node: r } = e, n = x(r), o = x(r, g.Line), i = r.type === "JSXOpeningFragment";
	return [
		i ? "<" : "</",
		m([o ? d : n && !i ? " " : "", W(e, t)]),
		o ? d : "",
		">"
	];
}
function QD(e, t, r) {
	return GD(e, Q(e, RD(e, t, r), t), t);
}
function zD(e, t) {
	let { node: r } = e, n = x(r, g.Line);
	return [W(e, t, { indent: n }), n ? d : ""];
}
function ZD(e, t, r) {
	let { node: n } = e;
	return [
		"{",
		e.call(({ node: o }) => {
			let i = ["...", r()];
			return x(o) ? [m([D, Q(e, i, t)]), D] : i;
		}, n.type === "JSXSpreadAttribute" ? "argument" : "expression"),
		"}"
	];
}
function vp(e, t, r) {
	let { node: n } = e;
	if (n.type.startsWith("JSX")) switch (n.type) {
		case "JSXAttribute": return qD(e, t, r);
		case "JSXIdentifier": return n.name;
		case "JSXNamespacedName": return L(":", [r("namespace"), r("name")]);
		case "JSXMemberExpression": return L(".", [r("object"), r("property")]);
		case "JSXSpreadAttribute":
		case "JSXSpreadChild": return ZD(e, t, r);
		case "JSXExpressionContainer": return YD(e, t, r);
		case "JSXFragment":
		case "JSXElement": return QD(e, t, r);
		case "JSXOpeningElement": return HD(e, t, r);
		case "JSXClosingElement": return KD(e, t, r);
		case "JSXOpeningFragment":
		case "JSXClosingFragment": return $D(e, t);
		case "JSXEmptyExpression": return zD(e, t);
		case "JSXText": throw new Error("JSXText should be handled by JSXElement");
		default: throw new it(n, "JSX");
	}
}
function ey(e) {
	if (e.children.length === 0) return !0;
	if (e.children.length > 1) return !1;
	let t = e.children[0];
	return t.type === "JSXText" && !Xt(t);
}
function ty(e) {
	return e.type === "JSXExpressionContainer" && q(e.expression) && e.expression.value === " " && !x(e.expression);
}
function Rp(e, t, r) {
	let { node: n } = e, o = n.parameters.length > 1 ? Ie(t) : "", i = p([
		m([D, L([", ", D], e.map(r, "parameters"))]),
		o,
		D
	]);
	return [
		e.key === "body" && e.parent.type === "ClassBody" && n.static ? "static " : "",
		n.readonly ? "readonly " : "",
		"[",
		n.parameters ? i : "",
		"]",
		G(e, r),
		ke(e, t)
	];
}
function gi(e, t, r) {
	let { node: n } = e;
	return [
		n.postfix ? "" : r,
		G(e, t),
		n.postfix ? r : ""
	];
}
function Wp(e, t, r) {
	let { node: n } = e, o = [], i = n.kind && n.kind !== "method" ? `${n.kind} ` : "";
	o.push(qt(n), i, ve(e, t, r), $(e));
	let s = Ke(e, t, r, !1, !0), u = G(e, r, "returnType"), a = Bt(n, u);
	return o.push(a ? p(s) : s), n.returnType && o.push(p(u)), [p(o), ke(e, t)];
}
function Jp(e, t, r) {
	let { node: n } = e;
	return [
		ne(e),
		n.kind === "global" ? "" : `${n.kind} `,
		r("id"),
		n.body ? [" ", p(r("body"))] : R(t)
	];
}
function Gp(e, t, r) {
	let { node: n } = e, o = !(Y(n.expression) || ie(n.expression)), i = p([
		"<",
		m([D, r("typeAnnotation")]),
		D,
		">"
	]), s = [
		O("("),
		m([D, r("expression")]),
		D,
		O(")")
	];
	return o ? mt([
		[i, r("expression")],
		[i, p(s, { shouldBreak: !0 })],
		[i, r("expression")]
	]) : p([i, r("expression")]);
}
function Up(e, t, r, n) {
	let { node: o } = e;
	if (o.type.startsWith("TS")) {
		if (Fn(o)) return o.type.slice(2, -7).toLowerCase();
		switch (o.type) {
			case "TSThisType": return "this";
			case "TSTypeAssertion": return Gp(e, t, r);
			case "TSDeclareFunction": return Dr(e, t, r);
			case "TSExportAssignment": return [
				"export = ",
				r("expression"),
				R(t)
			];
			case "TSModuleBlock": return Hn(e, t, r);
			case "TSInterfaceBody":
			case "TSTypeLiteral": return Kt(e, t, r);
			case "TSTypeAliasDeclaration": return lo(e, t, r);
			case "TSQualifiedName": return [
				r("left"),
				".",
				r("right")
			];
			case "TSAbstractMethodDefinition":
			case "TSDeclareMethod": return Xn(e, t, r);
			case "TSAbstractAccessorProperty":
			case "TSAbstractPropertyDefinition": return Vn(e, t, r);
			case "TSInterfaceHeritage":
			case "TSClassImplements":
			case "TSInstantiationExpression": return [r("expression"), r("typeArguments")];
			case "TSTemplateLiteralType": return On(e, t, r);
			case "TSNamedTupleMember": return co(e, t, r);
			case "TSRestType": return po(e, t, r);
			case "TSOptionalType": return [r("typeAnnotation"), "?"];
			case "TSInterfaceDeclaration": return Ar(e, t, r);
			case "TSTypeParameterDeclaration":
			case "TSTypeParameterInstantiation": return $t(e, t, r, "params");
			case "TSTypeParameter": return mo(e, t, r);
			case "TSAsExpression":
			case "TSSatisfiesExpression": return ro(e, t, r);
			case "TSArrayType": return to(r);
			case "TSPropertySignature": return [
				o.readonly ? "readonly " : "",
				ve(e, t, r),
				$(e),
				G(e, r),
				ke(e, t)
			];
			case "TSParameterProperty": return [
				qt(o),
				o.static ? "static " : "",
				o.override ? "override " : "",
				o.readonly ? "readonly " : "",
				r("parameter")
			];
			case "TSTypeQuery": return Do(e, r);
			case "TSIndexSignature": return Rp(e, t, r);
			case "TSTypePredicate": return fo(e, r);
			case "TSNonNullExpression": return [r("expression"), "!"];
			case "TSImportType": return [
				Vt(e, t, r),
				o.qualifier ? [".", r("qualifier")] : "",
				$t(e, t, r, "typeArguments")
			];
			case "TSLiteralType": return r("literal");
			case "TSIndexedAccessType": return so(e, t, r);
			case "TSTypeOperator": return [
				o.operator,
				" ",
				r("typeAnnotation")
			];
			case "TSMappedType": return Pp(e, t, r);
			case "TSMethodSignature": return Wp(e, t, r);
			case "TSNamespaceExportDeclaration": return [
				"export as namespace ",
				r("id"),
				R(t)
			];
			case "TSEnumDeclaration": return oo(e, r);
			case "TSEnumBody": return ft(e, t, r);
			case "TSEnumMember": return no(e, t, r);
			case "TSImportEqualsDeclaration": return [
				"import ",
				Fi(o, !1),
				r("id"),
				" = ",
				r("moduleReference"),
				R(t)
			];
			case "TSExternalModuleReference": return Vt(e, t, r);
			case "TSModuleDeclaration": return Jp(e, t, r);
			case "TSConditionalType": return gr(e, t, r);
			case "TSInferType": return uo(e, t, r);
			case "TSIntersectionType": return ao(e, t, r);
			case "TSUnionType": return bn(e, t, r, n);
			case "TSFunctionType":
			case "TSCallSignatureDeclaration":
			case "TSConstructorType":
			case "TSConstructSignatureDeclaration": return io(e, t, r);
			case "TSTupleType": return xr(e, t, r);
			case "TSTypeReference": return [r("typeName"), $t(e, t, r, "typeArguments")];
			case "TSTypeAnnotation": return Pn(e, t, r);
			case "TSEmptyBodyFunctionExpression": return In(e, t, r);
			case "TSJSDocAllType": return "*";
			case "TSJSDocUnknownType": return "?";
			case "TSJSDocNullableType": return gi(e, r, "?");
			case "TSJSDocNonNullableType": return gi(e, r, "!");
			default: throw new it(o, "TypeScript");
		}
	}
}
function ry(e, t, r, n) {
	for (let o of [
		pa,
		vp,
		Mp,
		Up,
		dp
	]) {
		let i = o(e, t, r, n);
		if (i !== void 0) return i;
	}
}
function hi(e, t, r, n) {
	e.isRoot && t.__onHtmlBindingRoot?.(e.node, t);
	let { node: o } = e, i = Cr(e) ? _p(e, t) : ry(e, t, r, n);
	if (!i) return "";
	if (ny(o)) return i;
	i = oy(e, t, i);
	let s = o.type !== "ClassExpression" && j(o.decorators) ? Wn(e, t, r) : "", u = oe(e, t);
	return !s && !u ? i : mn(i, (a) => [
		u ? "(" : "",
		s ? p([s, a]) : a,
		u ? ")" : ""
	]);
}
function oy(e, t, r) {
	let { node: n } = e;
	return (x(n, g.Leading) || x(n, g.Trailing)) && tn(e) ? [m([D, Q(e, r, t)]), D] : r;
}
function Ur(e) {
	return e.extra.raw;
}
function Pi(e, t) {
	let { type: r } = e;
	if (r === "ObjectProperty") {
		let { key: n } = e;
		if (n.type === "Identifier") {
			let { name: o } = n;
			t.key = {
				type: "StringLiteral",
				value: o,
				extra: { rawValue: o }
			};
		} else if (n.type === "NumericLiteral") {
			let o = Ur(n);
			String(Number(o)) === o && (t.key = {
				type: "StringLiteral",
				value: o,
				extra: { rawValue: o }
			});
		}
	}
	if (r === "StringLiteral" && delete t.extra.raw, r === "UnaryExpression" && e.operator === "+") return t.argument;
	if ((r === "ArrayExpression" || r === "ObjectExpression") && (t.extra ?? (t.extra = {}), e.extra?.trailingComma && delete t.extra.trailingComma), r === "ArrayExpression") {
		for (let [n, o] of e.elements.entries()) o === null && t.elements.splice(n, 0, { type: "NullLiteral" });
		return;
	}
	if (r === "TemplateLiteral") {
		let n = e.quasis[0].value.cooked;
		return {
			type: "StringLiteral",
			value: n,
			extra: { rawValue: n }
		};
	}
}
function Ii(e, t, r) {
	let { node: n } = e;
	switch (n.type) {
		case "JsonRoot": return [r("node"), d];
		case "ArrayExpression": {
			if (n.elements.length === 0) return "[]";
			let o = e.map(() => e.node === null ? "null" : r(), "elements");
			return [
				"[",
				m([d, L([",", d], o)]),
				d,
				"]"
			];
		}
		case "ObjectExpression": return n.properties.length === 0 ? "{}" : [
			"{",
			m([d, L([",", d], e.map(r, "properties"))]),
			d,
			"}"
		];
		case "ObjectProperty": return [
			r("key"),
			": ",
			r("value")
		];
		case "UnaryExpression": return [n.operator === "+" ? "" : n.operator, r("argument")];
		case "NullLiteral": return "null";
		case "BooleanLiteral": return n.value ? "true" : "false";
		case "StringLiteral": return ot(Ur(n), t);
		case "NumericLiteral": {
			let o = Ur(n);
			return Hp(e) && String(Number(o)) === o ? `"${o}"` : o;
		}
		case "Identifier": return Hp(e) ? JSON.stringify(n.name) : n.name;
		case "TemplateLiteral": return r(["quasis", 0]);
		case "TemplateElement": return JSON.stringify(n.value.cooked);
		default: throw new it(n, "JSON");
	}
}
function Hp(e) {
	return e.key === "key" && e.parent.type === "ObjectProperty";
}
var Zp, Co, Vp, Mi, Bi, j, tc, Re, Qt, w, ic, ji, xo, sc, uc, ac, vi, pc, Ri, cc, Wi, Pr, de, Ui, pe, At, Zt, Qe, Vr, ut, qi, Y, ie, er, Ye, wt, H, be, M, N, Tt, Dt, We, Yi, Hi, mc, fc, Dc, Xi, yc, Vi, at, Ki, $i, tr, Qi, pt, rr, Wt, Je, J, te, Sc, zi, bc, V, Zi, wc, le, Le, Oc, ho, wr, Jc, rs, as, qc, $c, Qc, Es, ds, Cs, g, Fs, pl, xs, rn, nn, gs, ll, on, Or, El, sn, l, un, xl, hl, oe, ze, Me, ct, Ze, et, lt, ge, Ue, _e, tt, rt, He, Fe, Ne, qe, cn, Xe, Pl, Oo, Ot, Ls, ln, he, fn, vs, Rs, je, jr, T, D, Mo, d, ar, Be, Nl, jl, vl, Rl, Jl, qs, Ys, Hs, Xs, Vs, Ks, No, jo, $s, Gl, Ul, vo, Ro, Yl, Qs, Hl, dt, Vl, Kl, Wo, Jo, tu, nt, Ct, Go, St, Gt, me, Cn, ru, Fn, tm, xn, Yo, am, pm, cm, iu, mm, ym, Em, au, _t, pu, cu, Cm, Fm, xm, mu, ot, fu, Du, vr, yu, gm, Sm, Pm, Im, wm, xu, Lm, Ko, Mm, Tu, gu, hu, Rm, Su, ti, ku, ni, _u, Nu, $m, Ru, rf, Er, nf, of, Vu, sf, Yu, uf, Hu, af, Ku, ea, ta, mf, ui, dr, Cr, ai, it, yf, ua, Cf, Tf, gf, Pf, If, kf, Jr, Nf, Aa, Rf, Qf, ka, wa, La, _a, ja, rD, nD, oD, uD, Ja, Ga, cD, qa, $a, fD, tp, DD, np, ED, xD, SD, ID, Ai, Lp, Ti, JD, ny, Si, bi, yo, Yp, uy, ay, hr, Rt, Xp, cy, ly;
//#endregion
__esmMin((() => {
	Zp = Object.defineProperty;
	Co = (e, t) => {
		for (var r in t) Zp(e, r, {
			get: t[r],
			enumerable: !0
		});
	};
	Vp = {};
	Co(Vp, {
		languages: () => ly,
		options: () => Xp,
		printers: () => cy
	});
	Mi = [
		{
			name: "JavaScript",
			type: "programming",
			aceMode: "javascript",
			extensions: [
				".js",
				"._js",
				".bones",
				".cjs",
				".es",
				".es6",
				".gs",
				".jake",
				".javascript",
				".jsb",
				".jscad",
				".jsfl",
				".jslib",
				".jsm",
				".jspre",
				".jss",
				".mjs",
				".njs",
				".pac",
				".sjs",
				".ssjs",
				".xsjs",
				".xsjslib",
				".start.frag",
				".end.frag",
				".wxs"
			],
			filenames: [
				"Jakefile",
				"start.frag",
				"end.frag"
			],
			tmScope: "source.js",
			aliases: ["js", "node"],
			codemirrorMode: "javascript",
			codemirrorMimeType: "text/javascript",
			interpreters: [
				"bun",
				"chakra",
				"d8",
				"deno",
				"gjs",
				"js",
				"node",
				"nodejs",
				"qjs",
				"rhino",
				"v8",
				"v8-shell",
				"zx"
			],
			parsers: [
				"babel",
				"acorn",
				"espree",
				"meriyah",
				"babel-flow",
				"babel-ts",
				"flow",
				"typescript"
			],
			vscodeLanguageIds: ["javascript", "mongo"],
			linguistLanguageId: 183
		},
		{
			name: "Flow",
			type: "programming",
			aceMode: "javascript",
			extensions: [".js.flow"],
			filenames: [],
			tmScope: "source.js",
			aliases: [],
			codemirrorMode: "javascript",
			codemirrorMimeType: "text/javascript",
			interpreters: [
				"bun",
				"chakra",
				"d8",
				"deno",
				"gjs",
				"js",
				"node",
				"nodejs",
				"qjs",
				"rhino",
				"v8",
				"v8-shell"
			],
			parsers: ["flow", "babel-flow"],
			vscodeLanguageIds: ["javascript"],
			linguistLanguageId: 183
		},
		{
			name: "JSX",
			type: "programming",
			aceMode: "javascript",
			extensions: [".jsx"],
			filenames: void 0,
			tmScope: "source.js.jsx",
			aliases: void 0,
			codemirrorMode: "jsx",
			codemirrorMimeType: "text/jsx",
			interpreters: void 0,
			parsers: [
				"babel",
				"babel-flow",
				"babel-ts",
				"flow",
				"typescript",
				"espree",
				"meriyah"
			],
			vscodeLanguageIds: ["javascriptreact"],
			group: "JavaScript",
			linguistLanguageId: 183
		},
		{
			name: "TypeScript",
			type: "programming",
			aceMode: "typescript",
			extensions: [
				".ts",
				".cts",
				".mts"
			],
			tmScope: "source.ts",
			aliases: ["ts"],
			codemirrorMode: "javascript",
			codemirrorMimeType: "application/typescript",
			interpreters: [
				"bun",
				"deno",
				"ts-node",
				"tsx"
			],
			parsers: ["typescript", "babel-ts"],
			vscodeLanguageIds: ["typescript"],
			linguistLanguageId: 378
		},
		{
			name: "TSX",
			type: "programming",
			aceMode: "tsx",
			extensions: [".tsx"],
			tmScope: "source.tsx",
			aliases: ["typescriptreact"],
			codemirrorMode: "jsx",
			codemirrorMimeType: "text/typescript-jsx",
			group: "TypeScript",
			parsers: ["typescript", "babel-ts"],
			vscodeLanguageIds: ["typescriptreact"],
			linguistLanguageId: 94901924
		}
	];
	Bi = {};
	Co(Bi, { estree: () => Si });
	j = ec;
	tc = () => {};
	Re = tc;
	Qt = (e, t) => (r, n, ...o) => r | 1 && n == null ? void 0 : (t.call(n) ?? n[e]).apply(n, o);
	w = Qt("at", function() {
		if (Array.isArray(this) || typeof this == "string") return rc;
	});
	ic = /* @__PURE__ */ new WeakMap();
	ji = (e) => e?.type === "TSAsExpression" && e.typeAnnotation.type === "TSTypeReference" && e.typeAnnotation.typeName.type === "Identifier" && e.typeAnnotation.typeName.name === "const";
	xo = (e) => Number.isSafeInteger(e) && e >= 0;
	sc = 5;
	uc = 8;
	ac = 8;
	vi = (e) => (t) => t.label ? S(t.label) : b(t) + e;
	pc = (e) => e.__contentEnd ?? It(e);
	Ri = [
		"ExpressionStatement",
		"Directive",
		"ImportDeclaration",
		"ExportDefaultDeclaration",
		"ExportNamedDeclaration",
		"ExportAllDeclaration",
		"ReturnStatement",
		"ThrowStatement",
		"DoWhileStatement"
	];
	cc = new Map([
		["BreakStatement", vi(sc)],
		["ContinueStatement", vi(uc)],
		["DebuggerStatement", (e) => b(e) + ac],
		["VariableDeclaration", (e) => S(w(0, e.declarations, -1))],
		...Ri.map((e) => [e, pc])
	]);
	Wi = B(Ri);
	Pr = (e) => {
		if (Wi(e) && e.__contentEnd) return !0;
		let { type: t } = e;
		return t === "BreakStatement" || t === "ContinueStatement" || t === "DebuggerStatement" || t === "VariableDeclaration" ? !0 : t === "IfStatement" ? Pr(e.alternate ?? e.consequent) : t === "ForInStatement" || t === "ForOfStatement" || t === "ForStatement" || t === "LabeledStatement" || t === "WithStatement" || t === "WhileStatement" ? Pr(e.body) : !1;
	};
	de = B([
		"TSAsExpression",
		"TSSatisfiesExpression",
		"AsExpression",
		"AsConstExpression",
		"SatisfiesExpression"
	]);
	Ui = B(["SatisfiesExpression", "TSSatisfiesExpression"]);
	pe = B(["TSUnionType", "UnionTypeAnnotation"]);
	At = B(["TSIntersectionType", "IntersectionTypeAnnotation"]);
	Zt = B(["TupleTypeAnnotation", "TSTupleType"]);
	Qe = B(["TSConditionalType", "ConditionalTypeAnnotation"]);
	Vr = B(["TSTypeAliasDeclaration", "TypeAlias"]);
	ut = B(["ReturnStatement", "ThrowStatement"]);
	qi = B([
		"ExportDefaultDeclaration",
		"DeclareExportDeclaration",
		"ExportNamedDeclaration",
		"ExportAllDeclaration",
		"DeclareExportAllDeclaration"
	]);
	Y = B(["ArrayExpression"]);
	ie = B(["ObjectExpression"]);
	er = B([
		"Literal",
		"BooleanLiteral",
		"BigIntLiteral",
		"DirectiveLiteral",
		"NullLiteral",
		"NumericLiteral",
		"RegExpLiteral",
		"StringLiteral"
	]);
	Ye = B([
		"ObjectTypeAnnotation",
		"TSTypeLiteral",
		"TSMappedType"
	]);
	wt = B(["FunctionExpression", "ArrowFunctionExpression"]);
	H = B(["JSXElement", "JSXFragment"]);
	be = B([
		"BinaryExpression",
		"LogicalExpression",
		"NGPipeExpression"
	]);
	M = B(["CallExpression", "OptionalCallExpression"]);
	N = B(["MemberExpression", "OptionalMemberExpression"]);
	Tt = B([
		"CallExpression",
		"OptionalCallExpression",
		"NewExpression"
	]);
	Dt = B([
		"CallExpression",
		"OptionalCallExpression",
		"NewExpression",
		"ImportExpression"
	]);
	We = B(["ChainExpression", "TSNonNullExpression"]);
	Yi = B(["TSArrayType", "ArrayTypeAnnotation"]);
	Hi = B(["TSTypeParameterInstantiation", "TypeParameterInstantiation"]);
	mc = B([
		"File",
		"TemplateElement",
		"TSEmptyBodyFunctionExpression",
		"ChainExpression"
	]);
	fc = (e, [t]) => t?.type === "ComponentParameter" && t.shorthand && t.name === e && t.local !== t.name || t?.type === "MatchObjectPatternProperty" && t.shorthand && t.key === e || t?.type === "ObjectProperty" && t.shorthand && t.key === e && t.value !== t.key || t?.type === "Property" && t.shorthand && t.key === e && !$e(t) && t.value !== t.key || t?.type === "ImportSpecifier" && Ir(t) && t.local === e && t.local !== t.imported || t?.type === "ExportSpecifier" && Ir(t) && t.exported === e && t.local !== t.exported;
	Dc = (e, [t]) => !!(e.type === "FunctionExpression" && t.type === "MethodDefinition" && t.value === e && ee(e).length === 0 && !e.returnType && !j(e.typeParameters) && e.body);
	Xi = (e, [t]) => t?.typeAnnotation === e && ji(t);
	yc = (e, [t, ...r]) => Xi(e, [t]) || t?.typeName === e && Xi(t, r);
	Vi = Ec;
	at = Kr(" 	");
	Ki = Kr(",; 	");
	$i = Kr(/[^\n\r]/);
	tr = Cc;
	Qi = (e) => e === `
` || e === "\r" || e === "\u2028" || e === "\u2029";
	pt = Fc;
	rr = xc;
	Wt = Ac;
	Je = Tc;
	J = gc;
	te = hc;
	Sc = /* @__PURE__ */ new WeakMap();
	zi = Symbol.for("comments");
	bc = String.prototype.replaceAll ?? function(e, t) {
		return e.global ? this.replace(e, t) : this.split(e).join(t);
	};
	V = Qt("replaceAll", function() {
		if (typeof this == "string") return bc;
	});
	Zi = Ic;
	wc = /* @__PURE__ */ new WeakMap();
	le = B([
		"Block",
		"CommentBlock",
		"MultiLine"
	]);
	Le = B([
		"Line",
		"CommentLine",
		"SingleLine",
		"HashbangComment",
		"HTMLOpen",
		"HTMLClose",
		"Hashbang",
		"InterpreterDirective"
	]);
	Oc = /* @__PURE__ */ new WeakMap();
	ho = (e, t) => le(e) && !te(t, b(e), S(e));
	wr = (e, t) => Le(e) || ho(e, t);
	Jc = B([
		"ClassDeclaration",
		"ClassExpression",
		"DeclareClass",
		"DeclareInterface",
		"InterfaceDeclaration",
		"TSInterfaceDeclaration"
	]);
	rs = B([
		"ClassMethod",
		"ClassProperty",
		"PropertyDefinition",
		"TSAbstractPropertyDefinition",
		"TSAbstractMethodDefinition",
		"TSDeclareMethod",
		"MethodDefinition",
		"ClassAccessorProperty",
		"AccessorProperty",
		"TSAbstractAccessorProperty",
		"TSParameterProperty"
	]);
	as = B([
		"FunctionDeclaration",
		"FunctionExpression",
		"ClassMethod",
		"MethodDefinition",
		"ObjectMethod"
	]);
	qc = B([
		"ComponentDeclaration",
		"DeclareComponent",
		"ComponentTypeAnnotation"
	]);
	$c = B([
		"VariableDeclarator",
		"AssignmentExpression",
		"TypeAlias",
		"TSTypeAliasDeclaration"
	]);
	Qc = B([
		"ObjectExpression",
		"ArrayExpression",
		"TemplateLiteral",
		"TaggedTemplateExpression",
		"ObjectTypeAnnotation",
		"TSTypeLiteral"
	]);
	Es = B([
		"ArrowFunctionExpression",
		"FunctionExpression",
		"FunctionDeclaration",
		"ObjectMethod",
		"ClassMethod",
		"TSDeclareFunction",
		"TSCallSignatureDeclaration",
		"TSConstructSignatureDeclaration",
		"TSMethodSignature",
		"TSConstructorType",
		"TSFunctionType",
		"TSDeclareMethod",
		"HookDeclaration"
	]);
	ds = {
		endOfLine: Nc,
		ownLine: _c,
		remaining: jc
	};
	Cs = al;
	g = {
		Leading: 2,
		Trailing: 4,
		Dangling: 8,
		Block: 16,
		Line: 32,
		PrettierIgnore: 64,
		First: 128,
		Last: 256
	};
	Fs = (e, t) => {
		if (typeof e == "function" && (t = e, e = 0), e || t) return (r, n, o) => !(e & g.Leading && !r.leading || e & g.Trailing && !r.trailing || e & g.Dangling && (r.leading || r.trailing) || e & g.Block && !le(r) || e & g.Line && !Le(r) || e & g.First && n !== 0 || e & g.Last && n !== o.length - 1 || e & g.PrettierIgnore && !yt(r) || t && !t(r));
	};
	pl = new Map([
		["|>"],
		["??"],
		["||"],
		["&&"],
		["|"],
		["^"],
		["&"],
		[
			"==",
			"===",
			"!=",
			"!=="
		],
		[
			"<",
			">",
			"<=",
			">=",
			"in",
			"instanceof"
		],
		[
			">>",
			"<<",
			">>>"
		],
		["+", "-"],
		[
			"*",
			"/",
			"%"
		],
		["**"]
	].flatMap((e, t) => e.map((r) => [r, t])));
	xs = {
		"==": !0,
		"!=": !0,
		"===": !0,
		"!==": !0
	};
	rn = {
		"*": !0,
		"/": !0,
		"%": !0
	};
	nn = {
		">>": !0,
		">>>": !0,
		"<<": !0
	};
	gs = (e) => e.extra?.parenthesized;
	ll = B(["OptionalCallExpression", "OptionalMemberExpression"]);
	on = fl;
	Or = null;
	El = 10;
	for (let e = 0; e <= El; e++) Mr();
	sn = dl;
	l = [
		["elements"],
		["left", "right"],
		["value"],
		["directives", "body"],
		["label"],
		[
			"callee",
			"typeArguments",
			"arguments"
		],
		[
			"test",
			"consequent",
			"alternate"
		],
		["body", "test"],
		["expression"],
		[
			"left",
			"right",
			"body"
		],
		[
			"id",
			"typeParameters",
			"params",
			"predicate",
			"returnType",
			"body"
		],
		["object", "property"],
		["properties"],
		[
			"decorators",
			"key",
			"typeParameters",
			"params",
			"returnType",
			"body"
		],
		[
			"decorators",
			"key",
			"value"
		],
		["argument"],
		["expressions"],
		["id", "init"],
		["body"],
		[
			"decorators",
			"id",
			"typeParameters",
			"superClass",
			"superTypeArguments",
			"mixins",
			"implements",
			"body"
		],
		[
			"declaration",
			"specifiers",
			"source",
			"attributes"
		],
		["local"],
		["exported"],
		[
			"decorators",
			"variance",
			"key",
			"typeAnnotation",
			"value"
		],
		["id"],
		["key", "value"],
		["elementType"],
		["id", "typeParameters"],
		[
			"id",
			"typeParameters",
			"extends",
			"body"
		],
		["id", "body"],
		["typeAnnotation"],
		[
			"id",
			"typeParameters",
			"right"
		],
		["name", "typeAnnotation"],
		["types"],
		["qualification", "id"],
		["elementTypes"],
		["expression", "typeAnnotation"],
		["params"],
		["members"],
		["objectType", "indexType"],
		[
			"decorators",
			"key",
			"typeAnnotation",
			"value"
		],
		[
			"id",
			"typeParameters",
			"params",
			"returnType",
			"body"
		],
		[
			"key",
			"typeParameters",
			"params",
			"returnType"
		],
		[
			"typeParameters",
			"params",
			"returnType"
		],
		["parameterName", "typeAnnotation"],
		[
			"checkType",
			"extendsType",
			"trueType",
			"falseType"
		],
		["typeParameter"],
		["literal"],
		["expression", "typeArguments"],
		[
			"decorators",
			"key",
			"typeAnnotation"
		],
		["argument", "cases"],
		[
			"pattern",
			"body",
			"guard"
		],
		["properties", "rest"],
		["node"]
	];
	un = sn({
		ArrayExpression: l[0],
		AssignmentExpression: l[1],
		BinaryExpression: l[1],
		InterpreterDirective: [],
		Directive: l[2],
		DirectiveLiteral: [],
		BlockStatement: l[3],
		BreakStatement: l[4],
		CallExpression: l[5],
		CatchClause: ["param", "body"],
		ConditionalExpression: l[6],
		ContinueStatement: l[4],
		DebuggerStatement: [],
		DoWhileStatement: l[7],
		EmptyStatement: [],
		ExpressionStatement: l[8],
		File: ["program"],
		ForInStatement: l[9],
		ForStatement: [
			"init",
			"test",
			"update",
			"body"
		],
		FunctionDeclaration: l[10],
		FunctionExpression: l[10],
		Identifier: ["typeAnnotation", "decorators"],
		IfStatement: l[6],
		LabeledStatement: ["label", "body"],
		StringLiteral: [],
		NumericLiteral: [],
		NullLiteral: [],
		BooleanLiteral: [],
		RegExpLiteral: [],
		LogicalExpression: l[1],
		MemberExpression: l[11],
		NewExpression: l[5],
		Program: l[3],
		ObjectExpression: l[12],
		ObjectMethod: l[13],
		ObjectProperty: l[14],
		RestElement: [
			"argument",
			"typeAnnotation",
			"decorators"
		],
		ReturnStatement: l[15],
		SequenceExpression: l[16],
		ParenthesizedExpression: l[8],
		SwitchCase: ["test", "consequent"],
		SwitchStatement: ["discriminant", "cases"],
		ThisExpression: [],
		ThrowStatement: l[15],
		TryStatement: [
			"block",
			"handler",
			"finalizer"
		],
		UnaryExpression: l[15],
		UpdateExpression: l[15],
		VariableDeclaration: ["declarations"],
		VariableDeclarator: l[17],
		WhileStatement: l[7],
		WithStatement: ["object", "body"],
		AssignmentPattern: [
			"left",
			"right",
			"decorators",
			"typeAnnotation"
		],
		ArrayPattern: [
			"elements",
			"typeAnnotation",
			"decorators"
		],
		ArrowFunctionExpression: [
			"typeParameters",
			"params",
			"predicate",
			"returnType",
			"body"
		],
		ClassBody: l[18],
		ClassExpression: l[19],
		ClassDeclaration: l[19],
		ExportAllDeclaration: [
			"source",
			"attributes",
			"exported"
		],
		ExportDefaultDeclaration: ["declaration"],
		ExportNamedDeclaration: l[20],
		ExportSpecifier: ["local", "exported"],
		ForOfStatement: l[9],
		ImportDeclaration: [
			"specifiers",
			"source",
			"attributes"
		],
		ImportDefaultSpecifier: l[21],
		ImportNamespaceSpecifier: l[21],
		ImportSpecifier: ["imported", "local"],
		MetaProperty: ["meta", "property"],
		ClassMethod: l[13],
		ObjectPattern: [
			"decorators",
			"properties",
			"typeAnnotation"
		],
		SpreadElement: l[15],
		Super: [],
		TaggedTemplateExpression: [
			"tag",
			"typeArguments",
			"quasi"
		],
		TemplateElement: [],
		TemplateLiteral: ["quasis", "expressions"],
		YieldExpression: l[15],
		AwaitExpression: l[15],
		ImportExpression: ["source", "options"],
		BigIntLiteral: [],
		ExportNamespaceSpecifier: l[22],
		OptionalMemberExpression: l[11],
		OptionalCallExpression: l[5],
		ClassProperty: l[23],
		ClassPrivateProperty: l[23],
		ClassPrivateMethod: l[13],
		PrivateName: l[24],
		StaticBlock: l[18],
		ImportAttribute: l[25],
		AnyTypeAnnotation: [],
		ArrayTypeAnnotation: l[26],
		BooleanTypeAnnotation: [],
		BooleanLiteralTypeAnnotation: [],
		NullLiteralTypeAnnotation: [],
		ClassImplements: l[27],
		DeclareClass: [
			"id",
			"typeParameters",
			"extends",
			"mixins",
			"implements",
			"body"
		],
		DeclareFunction: ["id", "predicate"],
		DeclareInterface: l[28],
		DeclareModule: l[29],
		DeclareModuleExports: l[30],
		DeclareTypeAlias: l[31],
		DeclareOpaqueType: [
			"id",
			"typeParameters",
			"supertype",
			"lowerBound",
			"upperBound"
		],
		DeclareVariable: ["id", "declarations"],
		DeclareExportDeclaration: l[20],
		DeclareExportAllDeclaration: ["source", "attributes"],
		DeclaredPredicate: l[2],
		ExistsTypeAnnotation: [],
		FunctionTypeAnnotation: [
			"typeParameters",
			"this",
			"params",
			"rest",
			"returnType"
		],
		FunctionTypeParam: l[32],
		GenericTypeAnnotation: l[27],
		InferredPredicate: [],
		InterfaceExtends: l[27],
		InterfaceDeclaration: l[28],
		InterfaceTypeAnnotation: ["extends", "body"],
		IntersectionTypeAnnotation: l[33],
		MixedTypeAnnotation: [],
		EmptyTypeAnnotation: [],
		NullableTypeAnnotation: l[30],
		NumberLiteralTypeAnnotation: [],
		BigIntLiteralTypeAnnotation: [],
		NumberTypeAnnotation: [],
		ObjectTypeAnnotation: [
			"properties",
			"indexers",
			"callProperties",
			"internalSlots"
		],
		ObjectTypeInternalSlot: ["id", "value"],
		ObjectTypeCallProperty: l[2],
		ObjectTypeIndexer: [
			"variance",
			"id",
			"key",
			"value"
		],
		ObjectTypeProperty: [
			"key",
			"value",
			"variance"
		],
		ObjectTypeSpreadProperty: l[15],
		OpaqueType: [
			"id",
			"typeParameters",
			"supertype",
			"impltype",
			"lowerBound",
			"upperBound"
		],
		QualifiedTypeIdentifier: l[34],
		StringLiteralTypeAnnotation: [],
		StringTypeAnnotation: [],
		SymbolTypeAnnotation: [],
		ThisTypeAnnotation: [],
		TupleTypeAnnotation: l[35],
		TypeofTypeAnnotation: ["argument", "typeArguments"],
		TypeAlias: l[31],
		TypeAnnotation: l[30],
		TypeCastExpression: l[36],
		TypeParameter: [
			"bound",
			"default",
			"variance"
		],
		TypeParameterDeclaration: l[37],
		TypeParameterInstantiation: l[37],
		UnionTypeAnnotation: l[33],
		Variance: [],
		VoidTypeAnnotation: [],
		EnumDeclaration: l[29],
		EnumBooleanBody: l[38],
		EnumNumberBody: l[38],
		EnumStringBody: l[38],
		EnumSymbolBody: l[38],
		EnumBooleanMember: l[17],
		EnumNumberMember: l[17],
		EnumStringMember: l[17],
		EnumDefaultedMember: l[24],
		IndexedAccessType: l[39],
		OptionalIndexedAccessType: l[39],
		JSXAttribute: ["name", "value"],
		JSXClosingElement: ["name"],
		JSXElement: [
			"openingElement",
			"children",
			"closingElement"
		],
		JSXEmptyExpression: [],
		JSXExpressionContainer: l[8],
		JSXSpreadChild: l[8],
		JSXIdentifier: [],
		JSXMemberExpression: l[11],
		JSXNamespacedName: ["namespace", "name"],
		JSXOpeningElement: [
			"name",
			"typeArguments",
			"attributes"
		],
		JSXSpreadAttribute: l[15],
		JSXText: [],
		JSXFragment: [
			"openingFragment",
			"children",
			"closingFragment"
		],
		JSXOpeningFragment: [],
		JSXClosingFragment: [],
		Placeholder: [],
		V8IntrinsicIdentifier: [],
		ArgumentPlaceholder: [],
		BindExpression: ["object", "callee"],
		ClassAccessorProperty: l[40],
		Decorator: l[8],
		DoExpression: l[18],
		ExportDefaultSpecifier: l[22],
		ModuleExpression: l[18],
		TopicReference: [],
		VoidPattern: [],
		TSParameterProperty: ["parameter", "decorators"],
		TSDeclareFunction: l[41],
		TSDeclareMethod: l[42],
		TSQualifiedName: l[1],
		TSCallSignatureDeclaration: l[43],
		TSConstructSignatureDeclaration: l[43],
		TSPropertySignature: ["key", "typeAnnotation"],
		TSMethodSignature: l[42],
		TSIndexSignature: ["parameters", "typeAnnotation"],
		TSAnyKeyword: [],
		TSBooleanKeyword: [],
		TSBigIntKeyword: [],
		TSIntrinsicKeyword: [],
		TSNeverKeyword: [],
		TSNullKeyword: [],
		TSNumberKeyword: [],
		TSObjectKeyword: [],
		TSStringKeyword: [],
		TSSymbolKeyword: [],
		TSUndefinedKeyword: [],
		TSUnknownKeyword: [],
		TSVoidKeyword: [],
		TSThisType: [],
		TSFunctionType: l[43],
		TSConstructorType: l[43],
		TSTypeReference: ["typeName", "typeArguments"],
		TSTypePredicate: l[44],
		TSTypeQuery: ["exprName", "typeArguments"],
		TSTypeLiteral: l[38],
		TSArrayType: l[26],
		TSTupleType: l[35],
		TSOptionalType: l[30],
		TSRestType: l[30],
		TSNamedTupleMember: ["label", "elementType"],
		TSUnionType: l[33],
		TSIntersectionType: l[33],
		TSConditionalType: l[45],
		TSInferType: l[46],
		TSParenthesizedType: l[30],
		TSTypeOperator: l[30],
		TSIndexedAccessType: l[39],
		TSMappedType: [
			"key",
			"constraint",
			"nameType",
			"typeAnnotation"
		],
		TSTemplateLiteralType: ["quasis", "types"],
		TSLiteralType: l[47],
		TSClassImplements: l[48],
		TSInterfaceHeritage: l[48],
		TSInterfaceDeclaration: l[28],
		TSInterfaceBody: l[18],
		TSTypeAliasDeclaration: [
			"id",
			"typeParameters",
			"typeAnnotation"
		],
		TSInstantiationExpression: l[48],
		TSAsExpression: l[36],
		TSSatisfiesExpression: l[36],
		TSTypeAssertion: l[36],
		TSEnumBody: l[38],
		TSEnumDeclaration: l[29],
		TSEnumMember: ["id", "initializer"],
		TSModuleDeclaration: l[29],
		TSModuleBlock: l[18],
		TSImportType: [
			"source",
			"options",
			"qualifier",
			"typeArguments"
		],
		TSImportEqualsDeclaration: ["id", "moduleReference"],
		TSExternalModuleReference: l[8],
		TSNonNullExpression: l[8],
		TSExportAssignment: l[8],
		TSNamespaceExportDeclaration: l[24],
		TSTypeAnnotation: l[30],
		TSTypeParameterInstantiation: l[37],
		TSTypeParameterDeclaration: l[37],
		TSTypeParameter: [
			"name",
			"constraint",
			"default"
		],
		ChainExpression: l[8],
		Literal: [],
		MethodDefinition: l[14],
		PrivateIdentifier: [],
		Property: l[25],
		PropertyDefinition: l[23],
		AccessorProperty: l[40],
		TSAbstractAccessorProperty: l[49],
		TSAbstractKeyword: [],
		TSAbstractMethodDefinition: l[25],
		TSAbstractPropertyDefinition: l[49],
		TSAsyncKeyword: [],
		TSDeclareKeyword: [],
		TSEmptyBodyFunctionExpression: [
			"id",
			"typeParameters",
			"params",
			"returnType"
		],
		TSExportKeyword: [],
		TSPrivateKeyword: [],
		TSProtectedKeyword: [],
		TSPublicKeyword: [],
		TSReadonlyKeyword: [],
		TSStaticKeyword: [],
		AsConstExpression: l[8],
		AsExpression: l[36],
		BigIntTypeAnnotation: [],
		ComponentDeclaration: [
			"id",
			"params",
			"body",
			"typeParameters",
			"rendersType"
		],
		ComponentParameter: ["name", "local"],
		ComponentTypeAnnotation: [
			"params",
			"rest",
			"typeParameters",
			"rendersType"
		],
		ComponentTypeParameter: l[32],
		ConditionalTypeAnnotation: l[45],
		DeclareComponent: [
			"id",
			"params",
			"rest",
			"typeParameters",
			"rendersType"
		],
		DeclareEnum: l[29],
		DeclareHook: l[24],
		DeclareNamespace: l[29],
		EnumBigIntBody: l[38],
		EnumBigIntMember: l[17],
		EnumBody: l[38],
		HookDeclaration: l[41],
		HookTypeAnnotation: [
			"params",
			"returnType",
			"rest",
			"typeParameters"
		],
		InferTypeAnnotation: l[46],
		KeyofTypeAnnotation: l[15],
		MatchArrayPattern: ["elements", "rest"],
		MatchAsPattern: ["pattern", "target"],
		MatchBindingPattern: l[24],
		MatchExpression: l[50],
		MatchExpressionCase: l[51],
		MatchIdentifierPattern: l[24],
		MatchInstanceObjectPattern: l[52],
		MatchInstancePattern: ["targetConstructor", "properties"],
		MatchLiteralPattern: l[47],
		MatchMemberPattern: ["base", "property"],
		MatchObjectPattern: l[52],
		MatchObjectPatternProperty: ["key", "pattern"],
		MatchOrPattern: ["patterns"],
		MatchRestPattern: l[15],
		MatchStatement: l[50],
		MatchStatementCase: l[51],
		MatchUnaryPattern: l[15],
		MatchWildcardPattern: [],
		NeverTypeAnnotation: [],
		ObjectTypeMappedTypeProperty: [
			"keyTparam",
			"propType",
			"sourceType",
			"variance"
		],
		QualifiedTypeofIdentifier: l[34],
		RecordDeclaration: [
			"id",
			"typeParameters",
			"implements",
			"body"
		],
		RecordDeclarationBody: l[0],
		RecordDeclarationImplements: ["id", "typeArguments"],
		RecordDeclarationProperty: [
			"key",
			"typeAnnotation",
			"defaultValue"
		],
		RecordDeclarationStaticProperty: [
			"key",
			"typeAnnotation",
			"value"
		],
		RecordExpression: [
			"recordConstructor",
			"typeArguments",
			"properties"
		],
		RecordExpressionProperties: l[12],
		SatisfiesExpression: l[36],
		TupleTypeLabeledElement: [
			"label",
			"elementType",
			"variance"
		],
		TupleTypeSpreadElement: ["label", "typeAnnotation"],
		TypeOperator: l[30],
		TypePredicate: l[44],
		UndefinedTypeAnnotation: [],
		UnknownTypeAnnotation: [],
		NGChainedExpression: l[16],
		NGEmptyExpression: [],
		NGPipeExpression: [
			"left",
			"right",
			"arguments"
		],
		NGMicrosyntax: l[18],
		NGMicrosyntaxAs: ["key", "alias"],
		NGMicrosyntaxExpression: ["expression", "alias"],
		NGMicrosyntaxKey: [],
		NGMicrosyntaxKeyedExpression: ["key", "expression"],
		NGMicrosyntaxLet: l[25],
		NGRoot: l[53],
		JsExpressionRoot: l[53],
		JsonRoot: l[53],
		TSJSDocAllType: [],
		TSJSDocUnknownType: [],
		TSJSDocNullableType: l[30],
		TSJSDocNonNullableType: l[30]
	});
	xl = /* @__PURE__ */ new WeakMap();
	hl = B([
		"BlockStatement",
		"BreakStatement",
		"ComponentDeclaration",
		"ClassBody",
		"ClassDeclaration",
		"ClassMethod",
		"ClassProperty",
		"PropertyDefinition",
		"ClassPrivateProperty",
		"ContinueStatement",
		"DebuggerStatement",
		"DeclareComponent",
		"DeclareClass",
		"DeclareExportAllDeclaration",
		"DeclareExportDeclaration",
		"DeclareFunction",
		"DeclareHook",
		"DeclareInterface",
		"DeclareModule",
		"DeclareModuleExports",
		"DeclareNamespace",
		"DeclareVariable",
		"DeclareEnum",
		"DoWhileStatement",
		"EnumDeclaration",
		"ExportAllDeclaration",
		"ExportDefaultDeclaration",
		"ExportNamedDeclaration",
		"ExpressionStatement",
		"ForInStatement",
		"ForOfStatement",
		"ForStatement",
		"FunctionDeclaration",
		"HookDeclaration",
		"IfStatement",
		"ImportDeclaration",
		"InterfaceDeclaration",
		"LabeledStatement",
		"MethodDefinition",
		"ReturnStatement",
		"SwitchStatement",
		"ThrowStatement",
		"TryStatement",
		"TSDeclareFunction",
		"TSEnumDeclaration",
		"TSImportEqualsDeclaration",
		"TSInterfaceDeclaration",
		"TSModuleDeclaration",
		"TSNamespaceExportDeclaration",
		"TypeAlias",
		"VariableDeclaration",
		"WhileStatement",
		"WithStatement"
	]);
	oe = ws;
	ze = "string";
	Me = "array";
	ct = "cursor";
	Ze = "indent";
	et = "align";
	lt = "trim";
	ge = "group";
	Ue = "fill";
	_e = "if-break";
	tt = "indent-if-break";
	rt = "line-suffix";
	He = "line-suffix-boundary";
	Fe = "line";
	Ne = "label";
	qe = "break-parent";
	cn = /* @__PURE__ */ new Set([
		ct,
		Ze,
		et,
		lt,
		ge,
		Ue,
		_e,
		tt,
		rt,
		He,
		Fe,
		Ne,
		qe
	]);
	Xe = bl;
	Pl = (e) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(e);
	Oo = class extends Error {
		name = "InvalidDocError";
		constructor(t) {
			super(Il(t)), this.doc = t;
		}
	};
	Ot = Oo;
	Ls = {};
	ln = kl;
	he = Re;
	fn = Re;
	vs = Re;
	Rs = Re;
	je = { type: qe };
	jr = { type: ct };
	T = { type: Fe };
	D = {
		type: Fe,
		soft: !0
	};
	Mo = {
		type: Fe,
		hard: !0
	};
	d = [Mo, je];
	ar = [{
		type: Fe,
		hard: !0,
		literal: !0
	}, je];
	Be = { type: He };
	Nl = "cr";
	jl = "crlf";
	vl = "\r";
	Rl = `\r
`;
	Jl = `
`;
	qs = () => /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E-\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED8\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFE])))?))?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3C-\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE8A\uDE8E-\uDEC2\uDEC6\uDEC8\uDECD-\uDEDC\uDEDF-\uDEEA\uDEEF]|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
	Ys = 12288;
	Hs = 65510;
	Xs = [
		12288,
		12288,
		65281,
		65376,
		65504,
		65510
	];
	Vs = 4352;
	Ks = 262141;
	No = [
		4352,
		4447,
		8986,
		8987,
		9001,
		9002,
		9193,
		9196,
		9200,
		9200,
		9203,
		9203,
		9725,
		9726,
		9748,
		9749,
		9776,
		9783,
		9800,
		9811,
		9855,
		9855,
		9866,
		9871,
		9875,
		9875,
		9889,
		9889,
		9898,
		9899,
		9917,
		9918,
		9924,
		9925,
		9934,
		9934,
		9940,
		9940,
		9962,
		9962,
		9970,
		9971,
		9973,
		9973,
		9978,
		9978,
		9981,
		9981,
		9989,
		9989,
		9994,
		9995,
		10024,
		10024,
		10060,
		10060,
		10062,
		10062,
		10067,
		10069,
		10071,
		10071,
		10133,
		10135,
		10160,
		10160,
		10175,
		10175,
		11035,
		11036,
		11088,
		11088,
		11093,
		11093,
		11904,
		11929,
		11931,
		12019,
		12032,
		12245,
		12272,
		12287,
		12289,
		12350,
		12353,
		12438,
		12441,
		12543,
		12549,
		12591,
		12593,
		12686,
		12688,
		12773,
		12783,
		12830,
		12832,
		12871,
		12880,
		42124,
		42128,
		42182,
		43360,
		43388,
		44032,
		55203,
		63744,
		64255,
		65040,
		65049,
		65072,
		65106,
		65108,
		65126,
		65128,
		65131,
		94176,
		94180,
		94192,
		94198,
		94208,
		101589,
		101631,
		101662,
		101760,
		101874,
		110576,
		110579,
		110581,
		110587,
		110589,
		110590,
		110592,
		110882,
		110898,
		110898,
		110928,
		110930,
		110933,
		110933,
		110948,
		110951,
		110960,
		111355,
		119552,
		119638,
		119648,
		119670,
		126980,
		126980,
		127183,
		127183,
		127374,
		127374,
		127377,
		127386,
		127488,
		127490,
		127504,
		127547,
		127552,
		127560,
		127568,
		127569,
		127584,
		127589,
		127744,
		127776,
		127789,
		127797,
		127799,
		127868,
		127870,
		127891,
		127904,
		127946,
		127951,
		127955,
		127968,
		127984,
		127988,
		127988,
		127992,
		128062,
		128064,
		128064,
		128066,
		128252,
		128255,
		128317,
		128331,
		128334,
		128336,
		128359,
		128378,
		128378,
		128405,
		128406,
		128420,
		128420,
		128507,
		128591,
		128640,
		128709,
		128716,
		128716,
		128720,
		128722,
		128725,
		128728,
		128732,
		128735,
		128747,
		128748,
		128756,
		128764,
		128992,
		129003,
		129008,
		129008,
		129292,
		129338,
		129340,
		129349,
		129351,
		129535,
		129648,
		129660,
		129664,
		129674,
		129678,
		129734,
		129736,
		129736,
		129741,
		129756,
		129759,
		129770,
		129775,
		129784,
		131072,
		196605,
		196608,
		262141
	];
	jo = (e, t) => {
		let r = 0, n = Math.floor(e.length / 2) - 1;
		for (; r <= n;) {
			let o = Math.floor((r + n) / 2), i = o * 2;
			if (t < e[i]) n = o - 1;
			else if (t > e[i + 1]) r = o + 1;
			else return !0;
		}
		return !1;
	};
	$s = 19968, [Gl, Ul] = ql(No);
	vo = (e) => e < Ys || e > Hs ? !1 : jo(Xs, e);
	Ro = (e) => e >= Gl && e <= Ul ? !0 : e < Vs || e > Ks ? !1 : jo(No, e);
	Yl = /^(?:[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u2764\u27A1\u2934\u2935\u2B05-\u2B07]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF3\uDFF5\uDFF7]|\uD83D[\uDC3F\uDC41\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])$/;
	Qs = (e) => Yl.test(e);
	Hl = /[^\x20-\x7F]/;
	dt = Xl;
	Vl = { type: 0 };
	Kl = { type: 1 };
	Wo = {
		value: "",
		length: 0,
		queue: [],
		get root() {
			return Wo;
		}
	};
	Jo = class {
		#e = [];
		#t = "";
		#n = 0;
		#o = [];
		#r = [];
		#i() {
			let t = this.#t;
			t !== "" && (this.#e.push(t), this.#n += t.length, this.#t = "");
			for (let r of this.#r) this.#o.push(Math.min(r, this.#n));
			this.#r.length = 0;
		}
		markPosition() {
			if (this.#o.length + this.#r.length >= 2) throw new Error("There are too many 'cursor' in doc.");
			this.#r.push(this.#n + this.#t.length);
		}
		write(t) {
			this.#t += t;
		}
		trim() {
			let { text: t, count: r } = En(this.#t);
			return this.#t = t, this.#i(), r;
		}
		finish() {
			return this.#i(), {
				text: this.#e.join(""),
				positions: this.#o
			};
		}
	};
	tu = Jo;
	nt = Symbol("MODE_BREAK");
	Ct = Symbol("MODE_FLAT");
	Go = Symbol("DOC_FILL_PRINTED_LENGTH");
	St = class extends Error {
		name = "ArgExpansionBailout";
	};
	Gt = Ql;
	me = (e, { originalText: t }) => {
		let r = S(e);
		if (Gt(t, r)) return !0;
		let n = It(e);
		return n === r ? !1 : Gt(t, n);
	};
	Cn = B([
		"AnyTypeAnnotation",
		"ThisTypeAnnotation",
		"NumberTypeAnnotation",
		"VoidTypeAnnotation",
		"BooleanTypeAnnotation",
		"BigIntTypeAnnotation",
		"SymbolTypeAnnotation",
		"StringTypeAnnotation",
		"NeverTypeAnnotation",
		"UndefinedTypeAnnotation",
		"UnknownTypeAnnotation",
		"EmptyTypeAnnotation",
		"MixedTypeAnnotation"
	]);
	ru = B([
		"TSThisType",
		"NullLiteralTypeAnnotation",
		"BooleanLiteralTypeAnnotation",
		"StringLiteralTypeAnnotation",
		"BigIntLiteralTypeAnnotation",
		"NumberLiteralTypeAnnotation",
		"TSLiteralType",
		"TSTemplateLiteralType"
	]);
	Fn = Zl;
	tm = [
		"it",
		"it.only",
		"it.skip",
		"describe",
		"describe.only",
		"describe.skip",
		"test",
		"test.only",
		"test.skip",
		"test.fixme",
		"test.step",
		"test.describe",
		"test.describe.only",
		"test.describe.skip",
		"test.describe.fixme",
		"test.describe.parallel",
		"test.describe.parallel.only",
		"test.describe.serial",
		"test.describe.serial.only",
		"skip",
		"xit",
		"xdescribe",
		"xtest",
		"fit",
		"fdescribe",
		"ftest"
	];
	xn = im;
	Yo = () => !0;
	am = B([
		"DeclareClass",
		"DeclareComponent",
		"DeclareFunction",
		"DeclareHook",
		"DeclareVariable",
		"DeclareExportDeclaration",
		"DeclareExportAllDeclaration",
		"DeclareOpaqueType",
		"DeclareTypeAlias",
		"DeclareEnum",
		"DeclareInterface"
	]);
	pm = (e) => {
		let { node: t } = e;
		return am(t) ? e.parent.type !== "DeclareExportDeclaration" && !t.implicitDeclare : t.declare;
	};
	cm = B([
		"TSAbstractMethodDefinition",
		"TSAbstractPropertyDefinition",
		"TSAbstractAccessorProperty"
	]);
	iu = (e) => e.type === "UnaryExpression" && e.operator === "!";
	mm = (e) => e.mark !== "commentBeforeArrow";
	ym = /^[\$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC][\$0-9A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]*$/;
	Em = (e) => ym.test(e);
	au = Em;
	_t = dm;
	pu = Object.freeze({
		character: "'",
		codePoint: 39
	});
	cu = Object.freeze({
		character: "\"",
		codePoint: 34
	});
	Cm = Object.freeze({
		preferred: pu,
		alternate: cu
	});
	Fm = Object.freeze({
		preferred: cu,
		alternate: pu
	});
	xm = /\\(["'\\])|(["'])/g;
	mu = Am;
	ot = Tm;
	fu = (e) => e.type === "TSEnumMember";
	Du = (e) => fu(e) ? "id" : "key";
	vr = (e) => e[Du(e)];
	yu = (e) => !fu(e) && e.computed;
	gm = ({ parser: e }) => e === "typescript" || e === "babel-ts" || e === "oxc-ts" || e === "yuku-ts";
	Sm = /* @__PURE__ */ new WeakMap();
	Pm = B([
		"VoidTypeAnnotation",
		"TSVoidKeyword",
		"NullLiteralTypeAnnotation",
		"TSNullKeyword"
	]);
	Im = B([
		"ObjectTypeAnnotation",
		"TSTypeLiteral",
		"GenericTypeAnnotation",
		"TSTypeReference"
	]);
	wm = /* @__PURE__ */ new WeakSet();
	xu = (e) => e.match((t) => t.type === "TSTypeAnnotation", (t, r) => (r === "returnType" || r === "typeAnnotation") && (t.type === "TSFunctionType" || t.type === "TSConstructorType")) ? "=>" : e.match((t) => t.type === "TSTypeAnnotation", (t, r) => r === "typeAnnotation" && (t.type === "TSJSDocNullableType" || t.type === "TSJSDocNonNullableType" || t.type === "TSTypePredicate")) || e.match((t) => t.type === "TypeAnnotation", (t, r) => r === "typeAnnotation" && t.type === "Identifier", (t, r) => r === "id" && t.type === "DeclareFunction") || e.match((t) => t.type === "TypeAnnotation", (t, r) => r === "typeAnnotation" && t.type === "Identifier", (t, r) => r === "id" && t.type === "DeclareHook") || e.match((t) => t.type === "TypeAnnotation", (t, r) => r === "bound" && t.type === "TypeParameter" && t.usesExtendsBound) ? "" : ":";
	Lm = ({ node: e, key: t, parent: r }) => t === "value" && e.type === "FunctionExpression" && (r.type === "ObjectMethod" || r.type === "ClassMethod" || r.type === "ClassPrivateMethod" || r.type === "MethodDefinition" || r.type === "TSAbstractMethodDefinition" || r.type === "TSDeclareMethod" || r.type === "Property" && $e(r));
	Ko = ({ node: e, parent: t }) => e.type === "ExpressionStatement" && t.type === "Program" && t.body.length === 1 && (Array.isArray(t.directives) && t.directives.length === 0 || !t.directives);
	Mm = B([
		"ClassDeclaration",
		"ClassExpression",
		"DeclareClass",
		"DeclareInterface",
		"InterfaceDeclaration",
		"TSInterfaceDeclaration"
	]);
	Tu = _m;
	gu = Nm;
	hu = jm;
	Rm = /* @__PURE__ */ new WeakMap();
	Su = /^[fx]?(?:describe|it|test)$/;
	ti = [
		(e, t) => t === "properties" && e.type === "ObjectExpression",
		(e, t) => t === "arguments" && e.type === "CallExpression" && e.callee.type === "Identifier" && e.callee.name === "Component",
		(e, t) => t === "expression" && e.type === "Decorator"
	];
	ku = (e) => Ym(e) || Hm(e) || Xm(e) || bu(e);
	ni = 0;
	_u = Ou.bind(void 0, "html");
	Nu = Ou.bind(void 0, "angular");
	$m = [
		{
			test: ku,
			print: Iu
		},
		{
			test: Lu,
			print: wu
		},
		{
			test: Mu,
			print: _u
		},
		{
			test: ri,
			print: Nu
		},
		{
			test: vu,
			print: ju
		}
	].map(({ test: e, print: t }) => ({
		test: e,
		print: zm(t)
	}));
	Ru = Qm;
	rf = /* @__PURE__ */ new Set([
		"range",
		"raw",
		"comments",
		"extra",
		"start",
		"end",
		"loc",
		"errors",
		"tokens",
		"trailingComma",
		"docblock",
		"__contentEnd"
	]);
	Er = (e) => {
		for (let t of e.quasis) delete t.value;
	};
	oi.ignoredProperties = rf;
	nf = /\*\/$/;
	of = /^\/\*\*?/;
	Vu = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/;
	sf = /(^|\s+)\/\/([^\n\r]*)/g;
	Yu = /^(\r?\n)+/;
	uf = /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g;
	Hu = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g;
	af = /(\r?\n|^) *\* ?/g;
	Ku = [];
	ea = "format";
	ta = pf;
	mf = /* @__PURE__ */ new WeakMap();
	ui = class {
		#e;
		constructor(t) {
			this.#e = new Set(t);
		}
		getLeadingWhitespaceCount(t) {
			let r = this.#e, n = 0;
			for (let o = 0; o < t.length && r.has(t.charAt(o)); o++) n++;
			return n;
		}
		getTrailingWhitespaceCount(t) {
			let r = this.#e, n = 0;
			for (let o = t.length - 1; o >= 0 && r.has(t.charAt(o)); o--) n++;
			return n;
		}
		getLeadingWhitespace(t) {
			let r = this.getLeadingWhitespaceCount(t);
			return t.slice(0, r);
		}
		getTrailingWhitespace(t) {
			let r = this.getTrailingWhitespaceCount(t);
			return t.slice(t.length - r);
		}
		hasLeadingWhitespace(t) {
			return this.#e.has(t.charAt(0));
		}
		hasTrailingWhitespace(t) {
			return this.#e.has(w(0, t, -1));
		}
		trimStart(t) {
			let r = this.getLeadingWhitespaceCount(t);
			return t.slice(r);
		}
		trimEnd(t) {
			let r = this.getTrailingWhitespaceCount(t);
			return t.slice(0, t.length - r);
		}
		trim(t) {
			return this.trimEnd(this.trimStart(t));
		}
		split(t, r = !1) {
			let n = `[${si([...this.#e].join(""))}]+`, o = new RegExp(r ? `(${n})` : n);
			return t.split(o);
		}
		hasWhitespaceCharacter(t) {
			let r = this.#e;
			return Array.prototype.some.call(t, (n) => r.has(n));
		}
		hasNonWhitespaceCharacter(t) {
			let r = this.#e;
			return Array.prototype.some.call(t, (n) => !r.has(n));
		}
		isWhitespaceOnly(t) {
			let r = this.#e;
			return Array.prototype.every.call(t, (n) => r.has(n));
		}
		#t(t) {
			let r = Number.POSITIVE_INFINITY;
			for (let n of t.split(`
`)) {
				if (n.length === 0) continue;
				let o = this.getLeadingWhitespaceCount(n);
				if (o === 0) return 0;
				n.length !== o && o < r && (r = o);
			}
			return r === Number.POSITIVE_INFINITY ? 0 : r;
		}
		dedentString(t) {
			let r = this.#t(t);
			return r === 0 ? t : t.split(`
`).map((n) => n.slice(r)).join(`
`);
		}
	};
	dr = new ui(` 
\r	`);
	Cr = Df;
	ai = class extends Error {
		name = "UnexpectedNodeError";
		constructor(t, r, n = "type") {
			super(`Unexpected ${r} node ${n}: ${JSON.stringify(t[n])}.`), this.node = t;
		}
	};
	it = ai;
	yf = 0;
	ua = (e) => e.type === "BinaryExpression" && e.operator === "|";
	Cf = B([
		"CallExpression",
		"OptionalCallExpression",
		"AssignmentExpression"
	]);
	Tf = /* @__PURE__ */ new WeakMap();
	gf = (e) => e.type === "SequenceExpression";
	Pf = .25;
	If = /* @__PURE__ */ new Set([
		"!",
		"-",
		"+",
		"~"
	]);
	kf = B([
		"Identifier",
		"ThisExpression",
		"Super",
		"PrivateName",
		"PrivateIdentifier"
	]);
	Jr = wf;
	Nf = (e) => M(e) && se(e).length > 0;
	Aa = vf;
	Rf = [
		"require",
		"require.resolve",
		"require.resolve.paths",
		"import.meta.resolve"
	];
	Qf = Array.prototype.findLast ?? function(e) {
		for (let t = this.length - 1; t >= 0; t--) {
			let r = this[t];
			if (e(r, t, this)) return r;
		}
	};
	ka = Qt("findLast", function() {
		if (Array.isArray(this)) return Qf;
	});
	wa = eD;
	La = [
		"properties",
		"indexers",
		"callProperties",
		"internalSlots"
	];
	_a = B([
		"ClassProperty",
		"PropertyDefinition",
		"ClassPrivateProperty",
		"ClassAccessorProperty",
		"AccessorProperty",
		"TSAbstractPropertyDefinition",
		"TSAbstractAccessorProperty"
	]);
	ja = (e) => {
		if (e.computed || e.typeAnnotation) return !1;
		let { type: t, name: r } = e.key;
		return t === "Identifier" && (r === "static" || r === "get" || r === "set");
	};
	rD = B(["TSPropertySignature"]);
	nD = wa("heritageGroup");
	oD = B([
		"TSInterfaceDeclaration",
		"DeclareInterface",
		"InterfaceDeclaration",
		"InterfaceTypeAnnotation"
	]);
	uD = /* @__PURE__ */ new WeakMap();
	Ja = (e, t, r) => Ft(e, t, r, "consequent");
	Ga = (e, t, r) => Ft(e, t, r, "alternate");
	cD = B([
		"TSAsExpression",
		"TSTypeAssertion",
		"TSNonNullExpression",
		"TSInstantiationExpression",
		"TSSatisfiesExpression"
	]);
	qa = B(["FunctionExpression", "ArrowFunctionExpression"]);
	$a = (e, { originalText: t }) => xn(t, b(e));
	fD = "use strict";
	tp = B([
		"ImportDeclaration",
		"ExportDefaultDeclaration",
		"ExportNamedDeclaration",
		"ExportAllDeclaration",
		"DeclareExportDeclaration",
		"DeclareExportAllDeclaration"
	]);
	DD = B([
		"EnumBody",
		"EnumBooleanBody",
		"EnumNumberBody",
		"EnumBigIntBody",
		"EnumStringBody",
		"EnumSymbolBody"
	]);
	np = (e) => e.type === "ExportDefaultDeclaration" || e.type === "DeclareExportDeclaration" && e.default;
	ED = B([
		"ClassDeclaration",
		"ComponentDeclaration",
		"FunctionDeclaration",
		"TSInterfaceDeclaration",
		"DeclareClass",
		"DeclareComponent",
		"DeclareFunction",
		"DeclareHook",
		"HookDeclaration",
		"TSDeclareFunction",
		"EnumDeclaration"
	]);
	xD = (e) => {
		let { attributes: t } = e;
		if (t.length !== 1) return !1;
		let [r] = t, { type: n, key: o, value: i } = r;
		return n === "ImportAttribute" && (o.type === "Identifier" && o.name === "type" || q(o) && o.value === "type") && q(i) && !x(r) && !x(o) && !x(i);
	};
	SD = /* @__PURE__ */ new Map([
		["AssignmentExpression", "right"],
		["VariableDeclarator", "init"],
		["ReturnStatement", "argument"],
		["ThrowStatement", "argument"],
		["UnaryExpression", "argument"],
		["YieldExpression", "argument"],
		["AwaitExpression", "argument"]
	]);
	ID = /* @__PURE__ */ new Map([
		["AssignmentExpression", "right"],
		["VariableDeclarator", "init"],
		["ReturnStatement", "argument"],
		["ThrowStatement", "argument"],
		["UnaryExpression", "argument"],
		["YieldExpression", "argument"],
		["AwaitExpression", "argument"]
	]);
	Ai = (e) => [
		O("("),
		m([D, e]),
		D,
		O(")")
	];
	Lp = B([
		"MatchWildcardPattern",
		"MatchLiteralPattern",
		"MatchUnaryPattern",
		"MatchIdentifierPattern"
	]);
	Ti = (e) => e === "" || e === T || e === d || e === D;
	JD = B([
		"ArrayExpression",
		"JSXAttribute",
		"JSXElement",
		"JSXExpressionContainer",
		"JSXFragment",
		"ExpressionStatement",
		"NewExpression",
		"CallExpression",
		"OptionalCallExpression",
		"ConditionalExpression",
		"JsExpressionRoot",
		"MatchExpressionCase"
	]);
	ny = B([
		"ClassMethod",
		"ClassPrivateMethod",
		"ClassProperty",
		"ClassAccessorProperty",
		"AccessorProperty",
		"TSAbstractAccessorProperty",
		"PropertyDefinition",
		"TSAbstractPropertyDefinition",
		"ClassPrivateProperty",
		"MethodDefinition",
		"TSAbstractMethodDefinition",
		"TSDeclareMethod"
	]);
	Si = {
		features: {
			experimental_avoidAstMutation: !0,
			experimental_locForRangeFormat: {
				locStart: b,
				locEnd: It
			}
		},
		massageAstNode: oi,
		canAttachComment: Vi,
		handleComments: ds,
		isGap: Cs,
		willPrintOwnComments: Tu,
		embed: Ru,
		insertPragma: ra,
		printComment: na,
		printPrettierIgnored: hi,
		print: hi,
		getVisitorKeys: un,
		isBlockComment: le,
		hasPrettierIgnore: Cr
	};
	bi = [
		{
			name: "JSON.stringify",
			type: "data",
			aceMode: "json",
			extensions: [".importmap"],
			filenames: [
				"package.json",
				"package-lock.json",
				"composer.json"
			],
			tmScope: "source.json",
			aliases: [
				"geojson",
				"jsonl",
				"sarif",
				"topojson"
			],
			codemirrorMode: "javascript",
			codemirrorMimeType: "application/json",
			parsers: ["json-stringify"],
			vscodeLanguageIds: ["json"],
			linguistLanguageId: 174
		},
		{
			name: "JSON",
			type: "data",
			aceMode: "json",
			extensions: [
				".json",
				".4DForm",
				".4DProject",
				".avsc",
				".geojson",
				".gltf",
				".har",
				".ice",
				".JSON-tmLanguage",
				".json.example",
				".mcmeta",
				".sarif",
				".slnlaunch",
				".tact",
				".tfstate",
				".tfstate.backup",
				".topojson",
				".webapp",
				".webmanifest",
				".yy",
				".yyp"
			],
			filenames: [
				".all-contributorsrc",
				".arcconfig",
				".auto-changelog",
				".c8rc",
				".htmlhintrc",
				".imgbotconfig",
				".nycrc",
				".tern-config",
				".tern-project",
				".watchmanconfig",
				".babelrc",
				".jscsrc",
				".jshintrc",
				".jslintrc",
				".swcrc"
			],
			tmScope: "source.json",
			aliases: [
				"geojson",
				"jsonl",
				"sarif",
				"topojson"
			],
			codemirrorMode: "javascript",
			codemirrorMimeType: "application/json",
			parsers: ["json"],
			vscodeLanguageIds: ["json"],
			linguistLanguageId: 174
		},
		{
			name: "JSON with Comments",
			type: "data",
			aceMode: "javascript",
			extensions: [
				".jsonc",
				".code-snippets",
				".code-workspace",
				".sublime-build",
				".sublime-color-scheme",
				".sublime-commands",
				".sublime-completions",
				".sublime-keymap",
				".sublime-macro",
				".sublime-menu",
				".sublime-mousemap",
				".sublime-project",
				".sublime-settings",
				".sublime-theme",
				".sublime-workspace",
				".sublime_metrics",
				".sublime_session"
			],
			filenames: [],
			tmScope: "source.json.comments",
			aliases: ["jsonc"],
			codemirrorMode: "javascript",
			codemirrorMimeType: "text/javascript",
			group: "JSON",
			parsers: ["jsonc"],
			vscodeLanguageIds: ["jsonc"],
			linguistLanguageId: 423
		},
		{
			name: "JSON5",
			type: "data",
			aceMode: "json5",
			extensions: [".json5"],
			tmScope: "source.js",
			codemirrorMode: "javascript",
			codemirrorMimeType: "application/json",
			parsers: ["json5"],
			vscodeLanguageIds: ["json5"],
			linguistLanguageId: 175
		}
	];
	yo = {};
	Co(yo, {
		estree: () => Si,
		"estree-json": () => ay
	});
	Yp = sn({
		JsonRoot: ["node"],
		ArrayExpression: ["elements"],
		ObjectExpression: ["properties"],
		ObjectProperty: ["key", "value"],
		UnaryExpression: ["argument"],
		NullLiteral: [],
		BooleanLiteral: [],
		StringLiteral: [],
		NumericLiteral: [],
		Identifier: [],
		TemplateLiteral: ["quasis"],
		TemplateElement: []
	});
	uy = /* @__PURE__ */ new Set([
		"start",
		"end",
		"loc",
		"comments",
		"leadingComments",
		"trailingComments",
		"innerComments",
		"errors",
		"range",
		"tokens"
	]);
	Pi.ignoredProperties = uy;
	ay = {
		massageAstNode: Pi,
		print: Ii,
		getVisitorKeys: Yp
	};
	hr = {
		bracketSpacing: {
			category: "Common",
			type: "boolean",
			default: !0,
			description: "Print spaces between brackets.",
			oppositeDescription: "Do not print spaces between brackets."
		},
		objectWrap: {
			category: "Common",
			type: "choice",
			default: "preserve",
			description: "How to wrap object literals.",
			choices: [{
				value: "preserve",
				description: "Keep as multi-line, if there is a newline between the opening brace and first property."
			}, {
				value: "collapse",
				description: "Fit to a single line when possible."
			}]
		},
		singleQuote: {
			category: "Common",
			type: "boolean",
			default: !1,
			description: "Use single quotes instead of double quotes."
		},
		proseWrap: {
			category: "Common",
			type: "choice",
			default: "preserve",
			description: "How to wrap prose.",
			choices: [
				{
					value: "always",
					description: "Wrap prose if it exceeds the print width."
				},
				{
					value: "never",
					description: "Do not wrap prose."
				},
				{
					value: "preserve",
					description: "Wrap prose as-is."
				}
			]
		},
		bracketSameLine: {
			category: "Common",
			type: "boolean",
			default: !1,
			description: "Put > of opening tags on the last line instead of on a new line."
		},
		singleAttributePerLine: {
			category: "Common",
			type: "boolean",
			default: !1,
			description: "Enforce single attribute per line in HTML, Vue and JSX."
		}
	};
	Rt = "JavaScript";
	Xp = {
		arrowParens: {
			category: Rt,
			type: "choice",
			default: "always",
			description: "Include parentheses around a sole arrow function parameter.",
			choices: [{
				value: "always",
				description: "Always include parens. Example: `(x) => x`"
			}, {
				value: "avoid",
				description: "Omit parens when possible. Example: `x => x`"
			}]
		},
		bracketSameLine: hr.bracketSameLine,
		objectWrap: hr.objectWrap,
		bracketSpacing: hr.bracketSpacing,
		jsxBracketSameLine: {
			category: Rt,
			type: "boolean",
			description: "Put > on the last line instead of at a new line.",
			deprecated: "2.4.0"
		},
		semi: {
			category: Rt,
			type: "boolean",
			default: !0,
			description: "Print semicolons.",
			oppositeDescription: "Do not print semicolons, except at the beginning of lines which may need them."
		},
		experimentalOperatorPosition: {
			category: Rt,
			type: "choice",
			default: "end",
			description: "Where to print operators when binary expressions wrap lines.",
			choices: [{
				value: "start",
				description: "Print operators at the start of new lines."
			}, {
				value: "end",
				description: "Print operators at the end of previous lines."
			}]
		},
		experimentalTernaries: {
			category: Rt,
			type: "boolean",
			default: !1,
			description: "Use curious ternaries, with the question mark after the condition.",
			oppositeDescription: "Default behavior of ternaries; keep question marks on the same line as the consequent."
		},
		singleQuote: hr.singleQuote,
		jsxSingleQuote: {
			category: Rt,
			type: "boolean",
			default: !1,
			description: "Use single quotes in JSX."
		},
		quoteProps: {
			category: Rt,
			type: "choice",
			default: "as-needed",
			description: "Change when properties in objects are quoted.",
			choices: [
				{
					value: "as-needed",
					description: "Only add quotes around object properties where required."
				},
				{
					value: "consistent",
					description: "If at least one property in an object requires quotes, quote all properties."
				},
				{
					value: "preserve",
					description: "Respect the input use of quotes in object properties."
				}
			]
		},
		trailingComma: {
			category: Rt,
			type: "choice",
			default: "all",
			description: "Print trailing commas wherever possible when multi-line.",
			choices: [
				{
					value: "all",
					description: "Trailing commas wherever possible (including function arguments)."
				},
				{
					value: "es5",
					description: "Trailing commas where valid in ES5 (objects, arrays, etc.)"
				},
				{
					value: "none",
					description: "No trailing commas."
				}
			]
		},
		singleAttributePerLine: hr.singleAttributePerLine
	};
	cy = {
		...Bi,
		...yo
	};
	ly = [...Mi, ...bi];
}))();
export { Vp as default, ly as languages, Xp as options, cy as printers };
