@builder.io/fusion 0.0.1

package/angular-CgPQvf1n.js

@@ -0,0 +1,3718 @@
+import { n as e } from "./chunk-hvVJRdgc.js";
+//#region ../../node_modules/prettier/plugins/angular.mjs
+function t(e) {
+	return typeof e == "string" ? (t) => t === e : (t) => e.test(t);
+}
+function n(e, n, r) {
+	let i = t(n);
+	for (let t = r; t < e.length; t++) {
+		let n = e[t];
+		if (i(n)) return t;
+	}
+	throw Error(`Cannot find character ${n} from index ${r} in ${JSON.stringify(e)}`);
+}
+function r(e) {
+	return e.slice(0, 1).toLowerCase() + e.slice(1);
+}
+function i(e) {
+	let { start: t, end: n } = e;
+	return {
+		start: t,
+		end: n,
+		range: [t, n]
+	};
+}
+function a(e) {
+	return !!e.extra?.parenthesized;
+}
+function o(e) {
+	return e.type === "TSNonNullExpression" && !a(e) ? o(e.expression) : (e.type === "OptionalCallExpression" || e.type === "OptionalMemberExpression") && !a(e);
+}
+function s(e, t) {
+	return e == null || t == null ? e == t : e.isEquivalent(t);
+}
+function c(e, t, n) {
+	let r = e.length;
+	if (r !== t.length) return !1;
+	for (let i = 0; i < r; i++) if (!n(e[i], t[i])) return !1;
+	return !0;
+}
+function l(e, t) {
+	return c(e, t, (e, t) => e.isEquivalent(t));
+}
+function ee(e) {
+	return e >= Kt && e <= Zt || e == Mn;
+}
+function u(e) {
+	return pn <= e && e <= mn;
+}
+function d(e) {
+	return e >= xn && e <= kn || e >= hn && e <= _n;
+}
+function f(e) {
+	return e === an || e === $t || e === Nn;
+}
+function p(e, t, n) {
+	return new Y(e, t, q.Character, n, String.fromCharCode(n));
+}
+function te(e, t, n) {
+	return new Y(e, t, q.Identifier, 0, n);
+}
+function ne(e, t, n) {
+	return new Y(e, t, q.PrivateIdentifier, 0, n);
+}
+function re(e, t, n) {
+	return new Y(e, t, q.Keyword, 0, n);
+}
+function m(e, t, n) {
+	return new Y(e, t, q.Operator, 0, n);
+}
+function ie(e, t, n) {
+	return new Y(e, t, q.Number, n, "");
+}
+function ae(e, t, n) {
+	return new Y(e, t, q.Error, 0, n);
+}
+function oe(e, t, n) {
+	return new Y(e, t, q.RegExpBody, 0, n);
+}
+function se(e, t, n) {
+	return new Y(e, t, q.RegExpFlags, 0, n);
+}
+function ce(e) {
+	return xn <= e && e <= kn || hn <= e && e <= _n || e == bn || e == tn;
+}
+function le(e) {
+	return d(e) || u(e) || e == bn || e == tn;
+}
+function ue(e) {
+	return e == Sn || e == gn;
+}
+function de(e) {
+	return e == cn || e == sn;
+}
+function fe(e) {
+	switch (e) {
+		case wn: return qt;
+		case Cn: return Yt;
+		case Tn: return Xt;
+		case En: return Kt;
+		case On: return Jt;
+		default: return e;
+	}
+}
+function pe(e) {
+	let t = parseInt(e);
+	if (isNaN(t)) throw Error("Invalid integer literal when parsing " + e);
+	return t;
+}
+function h(e) {
+	return e.start.toString() || "(unknown)";
+}
+function g(e, t, n, r) {
+	n.length > 0 && (n = ` ${n} `);
+	let i = h(r);
+	return new Rn(r, `Parser Error: ${e}${n}[${t}] in ${i}`);
+}
+function me(e) {
+	let t = /* @__PURE__ */ new Map(), n = 0, r = 0, i = 0;
+	for (; i < e.length;) {
+		let a = e[i];
+		if (a.type === 9) {
+			let [e, t] = a.parts;
+			n += t.length, r += e.length;
+		} else {
+			let e = a.parts.reduce((e, t) => e + t.length, 0);
+			r += e, n += e;
+		}
+		t.set(r, n), i++;
+	}
+	return t;
+}
+function he(e) {
+	let t = new Fn(e, Mr), n = new Pn(t, 0, 0, 0), r = n.moveBy(e.length);
+	return {
+		text: e,
+		file: t,
+		start: n,
+		end: r,
+		sourceSpan: new In(n, r)
+	};
+}
+function ge() {
+	return Nr ??= new Sr(new gr());
+}
+function _e(e) {
+	let t = Pr(e);
+	return t === null ? [] : [{
+		type: "CommentLine",
+		value: e.slice(t + 2),
+		...i({
+			start: t,
+			end: e.length
+		})
+	}];
+}
+function ve(e) {
+	let { result: t } = e;
+	if (t.errors.length !== 0) {
+		let [n] = t.errors;
+		if (!(n instanceof Rn)) throw n;
+		let { message: r } = n;
+		{
+			let e = r.match(/ in .*?@\d+:\d+$/);
+			e && (r = r.slice(0, e.index));
+		}
+		let i = e.start;
+		{
+			let e = r.match(/at column (?<index>\d+)/);
+			e && (r = r.slice(0, e.index), i = i.moveBy(Number(e.groups.index)));
+		}
+		let a = SyntaxError(r.trim(), { cause: n });
+		throw Object.assign(a, {
+			location: i,
+			span: n.span
+		}), a.cause ??= n, a;
+	}
+	return e;
+}
+function ye(e) {
+	return this[e < 0 ? this.length + e : e];
+}
+function be(e) {
+	return e instanceof Vt;
+}
+function xe(e) {
+	return e instanceof Bt;
+}
+function Se(e, t) {
+	return new Ki(e, t).expressions;
+}
+function Ce(e) {
+	let t = e.range?.[0] ?? e.start, n = (e.declaration?.decorators ?? e.decorators)?.[0];
+	return n ? Math.min(Ce(n), t) : t;
+}
+function we(e) {
+	return e.range?.[1] ?? e.end;
+}
+function Te(e) {
+	return {
+		astFormat: "estree",
+		parse(t) {
+			let n = e(t), { comments: r } = n;
+			return delete n.comments, e === Ji && n.type !== "NGChainedExpression" && (n = {
+				...n,
+				type: "NGChainedExpression",
+				expressions: [n]
+			}), {
+				type: "NGRoot",
+				node: n,
+				comments: r
+			};
+		},
+		locStart: Ce,
+		locEnd: we
+	};
+}
+var Ee, De, Oe, ke, Ae, je, _, Me, Ne, v, Pe, Fe, Ie, Le, Re, ze, y, Be, Ve, He, Ue, We, Ge, Ke, qe, b, x, Je, Ye, Xe, Ze, Qe, $e, et, tt, S, nt, rt, it, at, ot, st, ct, lt, ut, C, w, dt, ft, T, E, pt, D, mt, ht, gt, _t, vt, yt, bt, xt, St, Ct, O, wt, Tt, Et, Dt, k, Ot, kt, At, jt, Mt, Nt, Pt, Ft, It, Lt, Rt, zt, A, j, Bt, Vt, Ht, Ut, Wt, M, Gt, N, Kt, qt, Jt, Yt, Xt, Zt, Qt, $t, en, tn, nn, rn, an, P, F, on, sn, I, cn, L, ln, R, z, un, B, dn, fn, pn, mn, hn, gn, _n, V, vn, H, yn, bn, xn, Sn, Cn, wn, Tn, En, Dn, On, kn, An, jn, U, Mn, Nn, Pn, Fn, In, Ln, Rn, zn, Bn, Vn, Hn, Un, Wn, Gn, Kn, qn, Jn, Yn, Xn, Zn, Qn, W, $n, er, tr, nr, G, rr, ir, ar, or, K, sr, cr, lr, ur, dr, fr, pr, mr, q, J, hr, gr, Y, _r, vr, yr, br, xr, Sr, Cr, wr, X, Tr, Er, Dr, Or, kr, Ar, jr, Mr, Nr, Pr, Fr, Ir, Lr, Rr, zr, Br, Vr, Hr, Ur, Wr, Gr, Kr, qr, Jr, Yr, Xr, Zr, Qr, $r, ei, ti, ni, ri, ii, ai, oi, si, ci, li, ui, di, fi, pi, mi, hi, gi, _i, vi, yi, bi, xi, Si, Ci, wi, Ti, Ei, Di, Oi, ki, Ai, ji, Mi, Ni, Pi, Fi, Ii, Z, Q, Li, $, Ri, zi, Bi, Vi, Hi, Ui, Wi, Gi, Ki, qi, Ji, Yi, Xi, Zi, Qi, $i, ea, ta;
+//#endregion
+e((() => {
+	Ee = Object.defineProperty, De = Object.getPrototypeOf, Oe = Reflect.get, ke = (e) => {
+		throw TypeError(e);
+	}, Ae = (e, t) => {
+		for (var n in t) Ee(e, n, {
+			get: t[n],
+			enumerable: !0
+		});
+	}, je = (e, t, n) => t.has(e) || ke("Cannot " + n), _ = (e, t, n) => (je(e, t, "read from private field"), n ? n.call(e) : t.get(e)), Me = (e, t, n) => t.has(e) ? ke("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), Ne = (e, t, n, r) => (je(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), v = (e, t, n) => (je(e, t, "access private method"), n), Pe = (e, t, n) => Oe(De(e), n, t), Fe = {}, Ae(Fe, { parsers: () => Ie }), Ie = {}, Ae(Ie, {
+		__ng_action: () => Qi,
+		__ng_binding: () => $i,
+		__ng_directive: () => ta,
+		__ng_interpolation: () => ea
+	}), (function(e) {
+		e[e.Emulated = 0] = "Emulated", e[e.None = 2] = "None", e[e.ShadowDom = 3] = "ShadowDom", e[e.ExperimentalIsolatedShadowDom = 4] = "ExperimentalIsolatedShadowDom";
+	})(Le ||= {}), (function(e) {
+		e[e.OnPush = 0] = "OnPush", e[e.Default = 1] = "Default";
+	})(Re ||= {}), (function(e) {
+		e[e.None = 0] = "None", e[e.SignalBased = 1] = "SignalBased", e[e.HasDecoratorInputTransform = 2] = "HasDecoratorInputTransform";
+	})(ze ||= {}), (function(e) {
+		e[e.NONE = 0] = "NONE", e[e.HTML = 1] = "HTML", e[e.STYLE = 2] = "STYLE", e[e.SCRIPT = 3] = "SCRIPT", e[e.URL = 4] = "URL", e[e.RESOURCE_URL = 5] = "RESOURCE_URL", e[e.ATTRIBUTE_NO_BINDING = 6] = "ATTRIBUTE_NO_BINDING";
+	})(y ||= {}), (function(e) {
+		e[e.Error = 0] = "Error", e[e.Warning = 1] = "Warning", e[e.Ignore = 2] = "Ignore";
+	})(Be ||= {}), (function(e) {
+		e[e.Directive = 0] = "Directive", e[e.Component = 1] = "Component", e[e.Injectable = 2] = "Injectable", e[e.Pipe = 3] = "Pipe", e[e.NgModule = 4] = "NgModule";
+	})(Ve ||= {}), (function(e) {
+		e[e.Directive = 0] = "Directive", e[e.Pipe = 1] = "Pipe", e[e.NgModule = 2] = "NgModule";
+	})(He ||= {}), (function(e) {
+		e[e.Emulated = 0] = "Emulated", e[e.None = 2] = "None", e[e.ShadowDom = 3] = "ShadowDom", e[e.ExperimentalIsolatedShadowDom = 4] = "ExperimentalIsolatedShadowDom";
+	})(Ue ||= {}), (function(e) {
+		e[e.Little = 0] = "Little", e[e.Big = 1] = "Big";
+	})(We ||= {}), (function(e) {
+		e[e.None = 0] = "None", e[e.Const = 1] = "Const";
+	})(Ge ||= {}), (function(e) {
+		e[e.Dynamic = 0] = "Dynamic", e[e.Bool = 1] = "Bool", e[e.String = 2] = "String", e[e.Int = 3] = "Int", e[e.Number = 4] = "Number", e[e.Function = 5] = "Function", e[e.Inferred = 6] = "Inferred", e[e.None = 7] = "None";
+	})(Ke ||= {}), (function(e) {
+		e[e.Minus = 0] = "Minus", e[e.Plus = 1] = "Plus";
+	})(qe ||= {}), (function(e) {
+		e[e.Equals = 0] = "Equals", e[e.NotEquals = 1] = "NotEquals", e[e.Assign = 2] = "Assign", e[e.Identical = 3] = "Identical", e[e.NotIdentical = 4] = "NotIdentical", e[e.Minus = 5] = "Minus", e[e.Plus = 6] = "Plus", e[e.Divide = 7] = "Divide", e[e.Multiply = 8] = "Multiply", e[e.Modulo = 9] = "Modulo", e[e.And = 10] = "And", e[e.Or = 11] = "Or", e[e.BitwiseOr = 12] = "BitwiseOr", e[e.BitwiseAnd = 13] = "BitwiseAnd", e[e.Lower = 14] = "Lower", e[e.LowerEquals = 15] = "LowerEquals", e[e.Bigger = 16] = "Bigger", e[e.BiggerEquals = 17] = "BiggerEquals", e[e.NullishCoalesce = 18] = "NullishCoalesce", e[e.Exponentiation = 19] = "Exponentiation", e[e.In = 20] = "In", e[e.AdditionAssignment = 21] = "AdditionAssignment", e[e.SubtractionAssignment = 22] = "SubtractionAssignment", e[e.MultiplicationAssignment = 23] = "MultiplicationAssignment", e[e.DivisionAssignment = 24] = "DivisionAssignment", e[e.RemainderAssignment = 25] = "RemainderAssignment", e[e.ExponentiationAssignment = 26] = "ExponentiationAssignment", e[e.AndAssignment = 27] = "AndAssignment", e[e.OrAssignment = 28] = "OrAssignment", e[e.NullishCoalesceAssignment = 29] = "NullishCoalesceAssignment";
+	})(b ||= {}), x = class {
+		type;
+		sourceSpan;
+		constructor(e, t) {
+			this.type = e || null, this.sourceSpan = t || null;
+		}
+		prop(e, t) {
+			return new nt(this, e, null, t);
+		}
+		key(e, t, n) {
+			return new rt(this, e, t, n);
+		}
+		callFn(e, t, n) {
+			return new Xe(this, e, null, t, n);
+		}
+		instantiate(e, t, n) {
+			return new Ze(this, e, t, n);
+		}
+		conditional(e, t = null, n) {
+			return new tt(this, e, t, null, n);
+		}
+		equals(e, t) {
+			return new S(b.Equals, this, e, null, t);
+		}
+		notEquals(e, t) {
+			return new S(b.NotEquals, this, e, null, t);
+		}
+		identical(e, t) {
+			return new S(b.Identical, this, e, null, t);
+		}
+		notIdentical(e, t) {
+			return new S(b.NotIdentical, this, e, null, t);
+		}
+		minus(e, t) {
+			return new S(b.Minus, this, e, null, t);
+		}
+		plus(e, t) {
+			return new S(b.Plus, this, e, null, t);
+		}
+		divide(e, t) {
+			return new S(b.Divide, this, e, null, t);
+		}
+		multiply(e, t) {
+			return new S(b.Multiply, this, e, null, t);
+		}
+		modulo(e, t) {
+			return new S(b.Modulo, this, e, null, t);
+		}
+		power(e, t) {
+			return new S(b.Exponentiation, this, e, null, t);
+		}
+		and(e, t) {
+			return new S(b.And, this, e, null, t);
+		}
+		bitwiseOr(e, t) {
+			return new S(b.BitwiseOr, this, e, null, t);
+		}
+		bitwiseAnd(e, t) {
+			return new S(b.BitwiseAnd, this, e, null, t);
+		}
+		or(e, t) {
+			return new S(b.Or, this, e, null, t);
+		}
+		lower(e, t) {
+			return new S(b.Lower, this, e, null, t);
+		}
+		lowerEquals(e, t) {
+			return new S(b.LowerEquals, this, e, null, t);
+		}
+		bigger(e, t) {
+			return new S(b.Bigger, this, e, null, t);
+		}
+		biggerEquals(e, t) {
+			return new S(b.BiggerEquals, this, e, null, t);
+		}
+		isBlank(e) {
+			return this.equals(TYPED_NULL_EXPR, e);
+		}
+		nullishCoalesce(e, t) {
+			return new S(b.NullishCoalesce, this, e, null, t);
+		}
+		toStmt() {
+			return new ut(this, null);
+		}
+	}, Je = class e extends x {
+		name;
+		constructor(e, t, n) {
+			super(t, n), this.name = e;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.name === t.name;
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitReadVarExpr(this, t);
+		}
+		clone() {
+			return new e(this.name, this.type, this.sourceSpan);
+		}
+		set(e) {
+			return new S(b.Assign, this, e, null, this.sourceSpan);
+		}
+	}, Ye = class e extends x {
+		expr;
+		constructor(e, t, n) {
+			super(t, n), this.expr = e;
+		}
+		visitExpression(e, t) {
+			return e.visitTypeofExpr(this, t);
+		}
+		isEquivalent(t) {
+			return t instanceof e && t.expr.isEquivalent(this.expr);
+		}
+		isConstant() {
+			return this.expr.isConstant();
+		}
+		clone() {
+			return new e(this.expr.clone());
+		}
+	}, Xe = class e extends x {
+		fn;
+		args;
+		pure;
+		constructor(e, t, n, r, i = !1) {
+			super(n, r), this.fn = e, this.args = t, this.pure = i;
+		}
+		get receiver() {
+			return this.fn;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.fn.isEquivalent(t.fn) && l(this.args, t.args) && this.pure === t.pure;
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitInvokeFunctionExpr(this, t);
+		}
+		clone() {
+			return new e(this.fn.clone(), this.args.map((e) => e.clone()), this.type, this.sourceSpan, this.pure);
+		}
+	}, Ze = class e extends x {
+		classExpr;
+		args;
+		constructor(e, t, n, r) {
+			super(n, r), this.classExpr = e, this.args = t;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.classExpr.isEquivalent(t.classExpr) && l(this.args, t.args);
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitInstantiateExpr(this, t);
+		}
+		clone() {
+			return new e(this.classExpr.clone(), this.args.map((e) => e.clone()), this.type, this.sourceSpan);
+		}
+	}, Qe = class e extends x {
+		body;
+		flags;
+		constructor(e, t, n) {
+			super(null, n), this.body = e, this.flags = t;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.body === t.body && this.flags === t.flags;
+		}
+		isConstant() {
+			return !0;
+		}
+		visitExpression(e, t) {
+			return e.visitRegularExpressionLiteral(this, t);
+		}
+		clone() {
+			return new e(this.body, this.flags, this.sourceSpan);
+		}
+	}, $e = class e extends x {
+		value;
+		constructor(e, t, n) {
+			super(t, n), this.value = e;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.value === t.value;
+		}
+		isConstant() {
+			return !0;
+		}
+		visitExpression(e, t) {
+			return e.visitLiteralExpr(this, t);
+		}
+		clone() {
+			return new e(this.value, this.type, this.sourceSpan);
+		}
+	}, et = class e extends x {
+		value;
+		typeParams;
+		constructor(e, t, n = null, r) {
+			super(t, r), this.value = e, this.typeParams = n;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.value.name === t.value.name && this.value.moduleName === t.value.moduleName;
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitExternalExpr(this, t);
+		}
+		clone() {
+			return new e(this.value, this.type, this.typeParams, this.sourceSpan);
+		}
+	}, tt = class e extends x {
+		condition;
+		falseCase;
+		trueCase;
+		constructor(e, t, n = null, r, i) {
+			super(r || t.type, i), this.condition = e, this.falseCase = n, this.trueCase = t;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.condition.isEquivalent(t.condition) && this.trueCase.isEquivalent(t.trueCase) && s(this.falseCase, t.falseCase);
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitConditionalExpr(this, t);
+		}
+		clone() {
+			return new e(this.condition.clone(), this.trueCase.clone(), this.falseCase?.clone(), this.type, this.sourceSpan);
+		}
+	}, S = class e extends x {
+		operator;
+		rhs;
+		lhs;
+		constructor(e, t, n, r, i) {
+			super(r || t.type, i), this.operator = e, this.rhs = n, this.lhs = t;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.operator === t.operator && this.lhs.isEquivalent(t.lhs) && this.rhs.isEquivalent(t.rhs);
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitBinaryOperatorExpr(this, t);
+		}
+		clone() {
+			return new e(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan);
+		}
+		isAssignment() {
+			let e = this.operator;
+			return e === b.Assign || e === b.AdditionAssignment || e === b.SubtractionAssignment || e === b.MultiplicationAssignment || e === b.DivisionAssignment || e === b.RemainderAssignment || e === b.ExponentiationAssignment || e === b.AndAssignment || e === b.OrAssignment || e === b.NullishCoalesceAssignment;
+		}
+	}, nt = class e extends x {
+		receiver;
+		name;
+		constructor(e, t, n, r) {
+			super(n, r), this.receiver = e, this.name = t;
+		}
+		get index() {
+			return this.name;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.receiver.isEquivalent(t.receiver) && this.name === t.name;
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitReadPropExpr(this, t);
+		}
+		set(e) {
+			return new S(b.Assign, this.receiver.prop(this.name), e, null, this.sourceSpan);
+		}
+		clone() {
+			return new e(this.receiver.clone(), this.name, this.type, this.sourceSpan);
+		}
+	}, rt = class e extends x {
+		receiver;
+		index;
+		constructor(e, t, n, r) {
+			super(n, r), this.receiver = e, this.index = t;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.receiver.isEquivalent(t.receiver) && this.index.isEquivalent(t.index);
+		}
+		isConstant() {
+			return !1;
+		}
+		visitExpression(e, t) {
+			return e.visitReadKeyExpr(this, t);
+		}
+		set(e) {
+			return new S(b.Assign, this.receiver.key(this.index), e, null, this.sourceSpan);
+		}
+		clone() {
+			return new e(this.receiver.clone(), this.index.clone(), this.type, this.sourceSpan);
+		}
+	}, it = class e extends x {
+		entries;
+		constructor(e, t, n) {
+			super(t, n), this.entries = e;
+		}
+		isConstant() {
+			return this.entries.every((e) => e.isConstant());
+		}
+		isEquivalent(t) {
+			return t instanceof e && l(this.entries, t.entries);
+		}
+		visitExpression(e, t) {
+			return e.visitLiteralArrayExpr(this, t);
+		}
+		clone() {
+			return new e(this.entries.map((e) => e.clone()), this.type, this.sourceSpan);
+		}
+	}, at = class e {
+		expression;
+		constructor(e) {
+			this.expression = e;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.expression.isEquivalent(t.expression);
+		}
+		clone() {
+			return new e(this.expression.clone());
+		}
+		isConstant() {
+			return this.expression.isConstant();
+		}
+	}, ot = class e extends x {
+		entries;
+		valueType = null;
+		constructor(e, t, n) {
+			super(t, n), this.entries = e, t && (this.valueType = t.valueType);
+		}
+		isEquivalent(t) {
+			return t instanceof e && l(this.entries, t.entries);
+		}
+		isConstant() {
+			return this.entries.every((e) => e.isConstant());
+		}
+		visitExpression(e, t) {
+			return e.visitLiteralMapExpr(this, t);
+		}
+		clone() {
+			return new e(this.entries.map((e) => e.clone()), this.type, this.sourceSpan);
+		}
+	}, st = class e extends x {
+		expression;
+		constructor(e, t) {
+			super(null, t), this.expression = e;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.expression.isEquivalent(t.expression);
+		}
+		isConstant() {
+			return this.expression.isConstant();
+		}
+		visitExpression(e, t) {
+			return e.visitSpreadElementExpr(this, t);
+		}
+		clone() {
+			return new e(this.expression.clone(), this.sourceSpan);
+		}
+	}, (function(e) {
+		e[e.None = 0] = "None", e[e.Final = 1] = "Final", e[e.Private = 2] = "Private", e[e.Exported = 4] = "Exported", e[e.Static = 8] = "Static";
+	})(ct ||= {}), lt = class {
+		modifiers;
+		sourceSpan;
+		leadingComments;
+		constructor(e = ct.None, t = null, n) {
+			this.modifiers = e, this.sourceSpan = t, this.leadingComments = n;
+		}
+		hasModifier(e) {
+			return (this.modifiers & e) !== 0;
+		}
+		addLeadingComment(e) {
+			this.leadingComments = this.leadingComments ?? [], this.leadingComments.push(e);
+		}
+	}, ut = class e extends lt {
+		expr;
+		constructor(e, t, n) {
+			super(ct.None, t, n), this.expr = e;
+		}
+		isEquivalent(t) {
+			return t instanceof e && this.expr.isEquivalent(t.expr);
+		}
+		visitStatement(e, t) {
+			return e.visitExpressionStmt(this, t);
+		}
+	}, class e {
+		static INSTANCE = new e();
+		keyOf(e) {
+			if (e instanceof $e && typeof e.value == "string") return `"${e.value}"`;
+			if (e instanceof $e) return String(e.value);
+			if (e instanceof Qe) return `/${e.body}/${e.flags ?? ""}`;
+			if (e instanceof it) {
+				let t = [];
+				for (let n of e.entries) t.push(this.keyOf(n));
+				return `[${t.join(",")}]`;
+			} else if (e instanceof ot) {
+				let t = [];
+				for (let n of e.entries) if (n instanceof at) t.push("..." + this.keyOf(n.expression));
+				else {
+					let e = n.key;
+					n.quoted && (e = `"${e}"`), t.push(e + ":" + this.keyOf(n.value));
+				}
+				return `{${t.join(",")}}`;
+			} else {
+				if (e instanceof et) return `import("${e.value.moduleName}", ${e.value.name})`;
+				if (e instanceof Je) return `read(${e.name})`;
+				if (e instanceof Ye) return `typeof(${this.keyOf(e.expr)})`;
+				if (e instanceof st) return `...${this.keyOf(e.expression)}`;
+				throw Error(`${this.constructor.name} does not handle expressions of type ${e.constructor.name}`);
+			}
+		}
+	}, C = "@angular/core", w = class {
+		static NEW_METHOD = "factory";
+		static TRANSFORM_METHOD = "transform";
+		static PATCH_DEPS = "patchedDeps";
+		static core = {
+			name: null,
+			moduleName: C
+		};
+		static namespaceHTML = {
+			name: "ɵɵnamespaceHTML",
+			moduleName: C
+		};
+		static namespaceMathML = {
+			name: "ɵɵnamespaceMathML",
+			moduleName: C
+		};
+		static namespaceSVG = {
+			name: "ɵɵnamespaceSVG",
+			moduleName: C
+		};
+		static element = {
+			name: "ɵɵelement",
+			moduleName: C
+		};
+		static elementStart = {
+			name: "ɵɵelementStart",
+			moduleName: C
+		};
+		static elementEnd = {
+			name: "ɵɵelementEnd",
+			moduleName: C
+		};
+		static domElement = {
+			name: "ɵɵdomElement",
+			moduleName: C
+		};
+		static domElementStart = {
+			name: "ɵɵdomElementStart",
+			moduleName: C
+		};
+		static domElementEnd = {
+			name: "ɵɵdomElementEnd",
+			moduleName: C
+		};
+		static domElementContainer = {
+			name: "ɵɵdomElementContainer",
+			moduleName: C
+		};
+		static domElementContainerStart = {
+			name: "ɵɵdomElementContainerStart",
+			moduleName: C
+		};
+		static domElementContainerEnd = {
+			name: "ɵɵdomElementContainerEnd",
+			moduleName: C
+		};
+		static domTemplate = {
+			name: "ɵɵdomTemplate",
+			moduleName: C
+		};
+		static domListener = {
+			name: "ɵɵdomListener",
+			moduleName: C
+		};
+		static advance = {
+			name: "ɵɵadvance",
+			moduleName: C
+		};
+		static syntheticHostProperty = {
+			name: "ɵɵsyntheticHostProperty",
+			moduleName: C
+		};
+		static syntheticHostListener = {
+			name: "ɵɵsyntheticHostListener",
+			moduleName: C
+		};
+		static attribute = {
+			name: "ɵɵattribute",
+			moduleName: C
+		};
+		static classProp = {
+			name: "ɵɵclassProp",
+			moduleName: C
+		};
+		static elementContainerStart = {
+			name: "ɵɵelementContainerStart",
+			moduleName: C
+		};
+		static elementContainerEnd = {
+			name: "ɵɵelementContainerEnd",
+			moduleName: C
+		};
+		static elementContainer = {
+			name: "ɵɵelementContainer",
+			moduleName: C
+		};
+		static styleMap = {
+			name: "ɵɵstyleMap",
+			moduleName: C
+		};
+		static classMap = {
+			name: "ɵɵclassMap",
+			moduleName: C
+		};
+		static styleProp = {
+			name: "ɵɵstyleProp",
+			moduleName: C
+		};
+		static interpolate = {
+			name: "ɵɵinterpolate",
+			moduleName: C
+		};
+		static interpolate1 = {
+			name: "ɵɵinterpolate1",
+			moduleName: C
+		};
+		static interpolate2 = {
+			name: "ɵɵinterpolate2",
+			moduleName: C
+		};
+		static interpolate3 = {
+			name: "ɵɵinterpolate3",
+			moduleName: C
+		};
+		static interpolate4 = {
+			name: "ɵɵinterpolate4",
+			moduleName: C
+		};
+		static interpolate5 = {
+			name: "ɵɵinterpolate5",
+			moduleName: C
+		};
+		static interpolate6 = {
+			name: "ɵɵinterpolate6",
+			moduleName: C
+		};
+		static interpolate7 = {
+			name: "ɵɵinterpolate7",
+			moduleName: C
+		};
+		static interpolate8 = {
+			name: "ɵɵinterpolate8",
+			moduleName: C
+		};
+		static interpolateV = {
+			name: "ɵɵinterpolateV",
+			moduleName: C
+		};
+		static nextContext = {
+			name: "ɵɵnextContext",
+			moduleName: C
+		};
+		static resetView = {
+			name: "ɵɵresetView",
+			moduleName: C
+		};
+		static templateCreate = {
+			name: "ɵɵtemplate",
+			moduleName: C
+		};
+		static defer = {
+			name: "ɵɵdefer",
+			moduleName: C
+		};
+		static deferWhen = {
+			name: "ɵɵdeferWhen",
+			moduleName: C
+		};
+		static deferOnIdle = {
+			name: "ɵɵdeferOnIdle",
+			moduleName: C
+		};
+		static deferOnImmediate = {
+			name: "ɵɵdeferOnImmediate",
+			moduleName: C
+		};
+		static deferOnTimer = {
+			name: "ɵɵdeferOnTimer",
+			moduleName: C
+		};
+		static deferOnHover = {
+			name: "ɵɵdeferOnHover",
+			moduleName: C
+		};
+		static deferOnInteraction = {
+			name: "ɵɵdeferOnInteraction",
+			moduleName: C
+		};
+		static deferOnViewport = {
+			name: "ɵɵdeferOnViewport",
+			moduleName: C
+		};
+		static deferPrefetchWhen = {
+			name: "ɵɵdeferPrefetchWhen",
+			moduleName: C
+		};
+		static deferPrefetchOnIdle = {
+			name: "ɵɵdeferPrefetchOnIdle",
+			moduleName: C
+		};
+		static deferPrefetchOnImmediate = {
+			name: "ɵɵdeferPrefetchOnImmediate",
+			moduleName: C
+		};
+		static deferPrefetchOnTimer = {
+			name: "ɵɵdeferPrefetchOnTimer",
+			moduleName: C
+		};
+		static deferPrefetchOnHover = {
+			name: "ɵɵdeferPrefetchOnHover",
+			moduleName: C
+		};
+		static deferPrefetchOnInteraction = {
+			name: "ɵɵdeferPrefetchOnInteraction",
+			moduleName: C
+		};
+		static deferPrefetchOnViewport = {
+			name: "ɵɵdeferPrefetchOnViewport",
+			moduleName: C
+		};
+		static deferHydrateWhen = {
+			name: "ɵɵdeferHydrateWhen",
+			moduleName: C
+		};
+		static deferHydrateNever = {
+			name: "ɵɵdeferHydrateNever",
+			moduleName: C
+		};
+		static deferHydrateOnIdle = {
+			name: "ɵɵdeferHydrateOnIdle",
+			moduleName: C
+		};
+		static deferHydrateOnImmediate = {
+			name: "ɵɵdeferHydrateOnImmediate",
+			moduleName: C
+		};
+		static deferHydrateOnTimer = {
+			name: "ɵɵdeferHydrateOnTimer",
+			moduleName: C
+		};
+		static deferHydrateOnHover = {
+			name: "ɵɵdeferHydrateOnHover",
+			moduleName: C
+		};
+		static deferHydrateOnInteraction = {
+			name: "ɵɵdeferHydrateOnInteraction",
+			moduleName: C
+		};
+		static deferHydrateOnViewport = {
+			name: "ɵɵdeferHydrateOnViewport",
+			moduleName: C
+		};
+		static deferEnableTimerScheduling = {
+			name: "ɵɵdeferEnableTimerScheduling",
+			moduleName: C
+		};
+		static conditionalCreate = {
+			name: "ɵɵconditionalCreate",
+			moduleName: C
+		};
+		static conditionalBranchCreate = {
+			name: "ɵɵconditionalBranchCreate",
+			moduleName: C
+		};
+		static conditional = {
+			name: "ɵɵconditional",
+			moduleName: C
+		};
+		static repeater = {
+			name: "ɵɵrepeater",
+			moduleName: C
+		};
+		static repeaterCreate = {
+			name: "ɵɵrepeaterCreate",
+			moduleName: C
+		};
+		static repeaterTrackByIndex = {
+			name: "ɵɵrepeaterTrackByIndex",
+			moduleName: C
+		};
+		static repeaterTrackByIdentity = {
+			name: "ɵɵrepeaterTrackByIdentity",
+			moduleName: C
+		};
+		static componentInstance = {
+			name: "ɵɵcomponentInstance",
+			moduleName: C
+		};
+		static text = {
+			name: "ɵɵtext",
+			moduleName: C
+		};
+		static enableBindings = {
+			name: "ɵɵenableBindings",
+			moduleName: C
+		};
+		static disableBindings = {
+			name: "ɵɵdisableBindings",
+			moduleName: C
+		};
+		static getCurrentView = {
+			name: "ɵɵgetCurrentView",
+			moduleName: C
+		};
+		static textInterpolate = {
+			name: "ɵɵtextInterpolate",
+			moduleName: C
+		};
+		static textInterpolate1 = {
+			name: "ɵɵtextInterpolate1",
+			moduleName: C
+		};
+		static textInterpolate2 = {
+			name: "ɵɵtextInterpolate2",
+			moduleName: C
+		};
+		static textInterpolate3 = {
+			name: "ɵɵtextInterpolate3",
+			moduleName: C
+		};
+		static textInterpolate4 = {
+			name: "ɵɵtextInterpolate4",
+			moduleName: C
+		};
+		static textInterpolate5 = {
+			name: "ɵɵtextInterpolate5",
+			moduleName: C
+		};
+		static textInterpolate6 = {
+			name: "ɵɵtextInterpolate6",
+			moduleName: C
+		};
+		static textInterpolate7 = {
+			name: "ɵɵtextInterpolate7",
+			moduleName: C
+		};
+		static textInterpolate8 = {
+			name: "ɵɵtextInterpolate8",
+			moduleName: C
+		};
+		static textInterpolateV = {
+			name: "ɵɵtextInterpolateV",
+			moduleName: C
+		};
+		static restoreView = {
+			name: "ɵɵrestoreView",
+			moduleName: C
+		};
+		static pureFunction0 = {
+			name: "ɵɵpureFunction0",
+			moduleName: C
+		};
+		static pureFunction1 = {
+			name: "ɵɵpureFunction1",
+			moduleName: C
+		};
+		static pureFunction2 = {
+			name: "ɵɵpureFunction2",
+			moduleName: C
+		};
+		static pureFunction3 = {
+			name: "ɵɵpureFunction3",
+			moduleName: C
+		};
+		static pureFunction4 = {
+			name: "ɵɵpureFunction4",
+			moduleName: C
+		};
+		static pureFunction5 = {
+			name: "ɵɵpureFunction5",
+			moduleName: C
+		};
+		static pureFunction6 = {
+			name: "ɵɵpureFunction6",
+			moduleName: C
+		};
+		static pureFunction7 = {
+			name: "ɵɵpureFunction7",
+			moduleName: C
+		};
+		static pureFunction8 = {
+			name: "ɵɵpureFunction8",
+			moduleName: C
+		};
+		static pureFunctionV = {
+			name: "ɵɵpureFunctionV",
+			moduleName: C
+		};
+		static pipeBind1 = {
+			name: "ɵɵpipeBind1",
+			moduleName: C
+		};
+		static pipeBind2 = {
+			name: "ɵɵpipeBind2",
+			moduleName: C
+		};
+		static pipeBind3 = {
+			name: "ɵɵpipeBind3",
+			moduleName: C
+		};
+		static pipeBind4 = {
+			name: "ɵɵpipeBind4",
+			moduleName: C
+		};
+		static pipeBindV = {
+			name: "ɵɵpipeBindV",
+			moduleName: C
+		};
+		static domProperty = {
+			name: "ɵɵdomProperty",
+			moduleName: C
+		};
+		static ariaProperty = {
+			name: "ɵɵariaProperty",
+			moduleName: C
+		};
+		static property = {
+			name: "ɵɵproperty",
+			moduleName: C
+		};
+		static control = {
+			name: "ɵɵcontrol",
+			moduleName: C
+		};
+		static controlCreate = {
+			name: "ɵɵcontrolCreate",
+			moduleName: C
+		};
+		static animationEnterListener = {
+			name: "ɵɵanimateEnterListener",
+			moduleName: C
+		};
+		static animationLeaveListener = {
+			name: "ɵɵanimateLeaveListener",
+			moduleName: C
+		};
+		static animationEnter = {
+			name: "ɵɵanimateEnter",
+			moduleName: C
+		};
+		static animationLeave = {
+			name: "ɵɵanimateLeave",
+			moduleName: C
+		};
+		static i18n = {
+			name: "ɵɵi18n",
+			moduleName: C
+		};
+		static i18nAttributes = {
+			name: "ɵɵi18nAttributes",
+			moduleName: C
+		};
+		static i18nExp = {
+			name: "ɵɵi18nExp",
+			moduleName: C
+		};
+		static i18nStart = {
+			name: "ɵɵi18nStart",
+			moduleName: C
+		};
+		static i18nEnd = {
+			name: "ɵɵi18nEnd",
+			moduleName: C
+		};
+		static i18nApply = {
+			name: "ɵɵi18nApply",
+			moduleName: C
+		};
+		static i18nPostprocess = {
+			name: "ɵɵi18nPostprocess",
+			moduleName: C
+		};
+		static pipe = {
+			name: "ɵɵpipe",
+			moduleName: C
+		};
+		static projection = {
+			name: "ɵɵprojection",
+			moduleName: C
+		};
+		static projectionDef = {
+			name: "ɵɵprojectionDef",
+			moduleName: C
+		};
+		static reference = {
+			name: "ɵɵreference",
+			moduleName: C
+		};
+		static inject = {
+			name: "ɵɵinject",
+			moduleName: C
+		};
+		static injectAttribute = {
+			name: "ɵɵinjectAttribute",
+			moduleName: C
+		};
+		static directiveInject = {
+			name: "ɵɵdirectiveInject",
+			moduleName: C
+		};
+		static invalidFactory = {
+			name: "ɵɵinvalidFactory",
+			moduleName: C
+		};
+		static invalidFactoryDep = {
+			name: "ɵɵinvalidFactoryDep",
+			moduleName: C
+		};
+		static templateRefExtractor = {
+			name: "ɵɵtemplateRefExtractor",
+			moduleName: C
+		};
+		static forwardRef = {
+			name: "forwardRef",
+			moduleName: C
+		};
+		static resolveForwardRef = {
+			name: "resolveForwardRef",
+			moduleName: C
+		};
+		static replaceMetadata = {
+			name: "ɵɵreplaceMetadata",
+			moduleName: C
+		};
+		static getReplaceMetadataURL = {
+			name: "ɵɵgetReplaceMetadataURL",
+			moduleName: C
+		};
+		static ɵɵdefineInjectable = {
+			name: "ɵɵdefineInjectable",
+			moduleName: C
+		};
+		static declareInjectable = {
+			name: "ɵɵngDeclareInjectable",
+			moduleName: C
+		};
+		static InjectableDeclaration = {
+			name: "ɵɵInjectableDeclaration",
+			moduleName: C
+		};
+		static resolveWindow = {
+			name: "ɵɵresolveWindow",
+			moduleName: C
+		};
+		static resolveDocument = {
+			name: "ɵɵresolveDocument",
+			moduleName: C
+		};
+		static resolveBody = {
+			name: "ɵɵresolveBody",
+			moduleName: C
+		};
+		static getComponentDepsFactory = {
+			name: "ɵɵgetComponentDepsFactory",
+			moduleName: C
+		};
+		static defineComponent = {
+			name: "ɵɵdefineComponent",
+			moduleName: C
+		};
+		static declareComponent = {
+			name: "ɵɵngDeclareComponent",
+			moduleName: C
+		};
+		static setComponentScope = {
+			name: "ɵɵsetComponentScope",
+			moduleName: C
+		};
+		static ChangeDetectionStrategy = {
+			name: "ChangeDetectionStrategy",
+			moduleName: C
+		};
+		static ViewEncapsulation = {
+			name: "ViewEncapsulation",
+			moduleName: C
+		};
+		static ComponentDeclaration = {
+			name: "ɵɵComponentDeclaration",
+			moduleName: C
+		};
+		static FactoryDeclaration = {
+			name: "ɵɵFactoryDeclaration",
+			moduleName: C
+		};
+		static declareFactory = {
+			name: "ɵɵngDeclareFactory",
+			moduleName: C
+		};
+		static FactoryTarget = {
+			name: "ɵɵFactoryTarget",
+			moduleName: C
+		};
+		static defineDirective = {
+			name: "ɵɵdefineDirective",
+			moduleName: C
+		};
+		static declareDirective = {
+			name: "ɵɵngDeclareDirective",
+			moduleName: C
+		};
+		static DirectiveDeclaration = {
+			name: "ɵɵDirectiveDeclaration",
+			moduleName: C
+		};
+		static InjectorDef = {
+			name: "ɵɵInjectorDef",
+			moduleName: C
+		};
+		static InjectorDeclaration = {
+			name: "ɵɵInjectorDeclaration",
+			moduleName: C
+		};
+		static defineInjector = {
+			name: "ɵɵdefineInjector",
+			moduleName: C
+		};
+		static declareInjector = {
+			name: "ɵɵngDeclareInjector",
+			moduleName: C
+		};
+		static NgModuleDeclaration = {
+			name: "ɵɵNgModuleDeclaration",
+			moduleName: C
+		};
+		static ModuleWithProviders = {
+			name: "ModuleWithProviders",
+			moduleName: C
+		};
+		static defineNgModule = {
+			name: "ɵɵdefineNgModule",
+			moduleName: C
+		};
+		static declareNgModule = {
+			name: "ɵɵngDeclareNgModule",
+			moduleName: C
+		};
+		static setNgModuleScope = {
+			name: "ɵɵsetNgModuleScope",
+			moduleName: C
+		};
+		static registerNgModuleType = {
+			name: "ɵɵregisterNgModuleType",
+			moduleName: C
+		};
+		static PipeDeclaration = {
+			name: "ɵɵPipeDeclaration",
+			moduleName: C
+		};
+		static definePipe = {
+			name: "ɵɵdefinePipe",
+			moduleName: C
+		};
+		static declarePipe = {
+			name: "ɵɵngDeclarePipe",
+			moduleName: C
+		};
+		static declareClassMetadata = {
+			name: "ɵɵngDeclareClassMetadata",
+			moduleName: C
+		};
+		static declareClassMetadataAsync = {
+			name: "ɵɵngDeclareClassMetadataAsync",
+			moduleName: C
+		};
+		static setClassMetadata = {
+			name: "ɵsetClassMetadata",
+			moduleName: C
+		};
+		static setClassMetadataAsync = {
+			name: "ɵsetClassMetadataAsync",
+			moduleName: C
+		};
+		static setClassDebugInfo = {
+			name: "ɵsetClassDebugInfo",
+			moduleName: C
+		};
+		static queryRefresh = {
+			name: "ɵɵqueryRefresh",
+			moduleName: C
+		};
+		static viewQuery = {
+			name: "ɵɵviewQuery",
+			moduleName: C
+		};
+		static loadQuery = {
+			name: "ɵɵloadQuery",
+			moduleName: C
+		};
+		static contentQuery = {
+			name: "ɵɵcontentQuery",
+			moduleName: C
+		};
+		static viewQuerySignal = {
+			name: "ɵɵviewQuerySignal",
+			moduleName: C
+		};
+		static contentQuerySignal = {
+			name: "ɵɵcontentQuerySignal",
+			moduleName: C
+		};
+		static queryAdvance = {
+			name: "ɵɵqueryAdvance",
+			moduleName: C
+		};
+		static twoWayProperty = {
+			name: "ɵɵtwoWayProperty",
+			moduleName: C
+		};
+		static twoWayBindingSet = {
+			name: "ɵɵtwoWayBindingSet",
+			moduleName: C
+		};
+		static twoWayListener = {
+			name: "ɵɵtwoWayListener",
+			moduleName: C
+		};
+		static declareLet = {
+			name: "ɵɵdeclareLet",
+			moduleName: C
+		};
+		static storeLet = {
+			name: "ɵɵstoreLet",
+			moduleName: C
+		};
+		static readContextLet = {
+			name: "ɵɵreadContextLet",
+			moduleName: C
+		};
+		static attachSourceLocations = {
+			name: "ɵɵattachSourceLocations",
+			moduleName: C
+		};
+		static NgOnChangesFeature = {
+			name: "ɵɵNgOnChangesFeature",
+			moduleName: C
+		};
+		static InheritDefinitionFeature = {
+			name: "ɵɵInheritDefinitionFeature",
+			moduleName: C
+		};
+		static ProvidersFeature = {
+			name: "ɵɵProvidersFeature",
+			moduleName: C
+		};
+		static HostDirectivesFeature = {
+			name: "ɵɵHostDirectivesFeature",
+			moduleName: C
+		};
+		static ExternalStylesFeature = {
+			name: "ɵɵExternalStylesFeature",
+			moduleName: C
+		};
+		static listener = {
+			name: "ɵɵlistener",
+			moduleName: C
+		};
+		static getInheritedFactory = {
+			name: "ɵɵgetInheritedFactory",
+			moduleName: C
+		};
+		static sanitizeHtml = {
+			name: "ɵɵsanitizeHtml",
+			moduleName: C
+		};
+		static sanitizeStyle = {
+			name: "ɵɵsanitizeStyle",
+			moduleName: C
+		};
+		static validateAttribute = {
+			name: "ɵɵvalidateAttribute",
+			moduleName: C
+		};
+		static sanitizeResourceUrl = {
+			name: "ɵɵsanitizeResourceUrl",
+			moduleName: C
+		};
+		static sanitizeScript = {
+			name: "ɵɵsanitizeScript",
+			moduleName: C
+		};
+		static sanitizeUrl = {
+			name: "ɵɵsanitizeUrl",
+			moduleName: C
+		};
+		static sanitizeUrlOrResourceUrl = {
+			name: "ɵɵsanitizeUrlOrResourceUrl",
+			moduleName: C
+		};
+		static trustConstantHtml = {
+			name: "ɵɵtrustConstantHtml",
+			moduleName: C
+		};
+		static trustConstantResourceUrl = {
+			name: "ɵɵtrustConstantResourceUrl",
+			moduleName: C
+		};
+		static inputDecorator = {
+			name: "Input",
+			moduleName: C
+		};
+		static outputDecorator = {
+			name: "Output",
+			moduleName: C
+		};
+		static viewChildDecorator = {
+			name: "ViewChild",
+			moduleName: C
+		};
+		static viewChildrenDecorator = {
+			name: "ViewChildren",
+			moduleName: C
+		};
+		static contentChildDecorator = {
+			name: "ContentChild",
+			moduleName: C
+		};
+		static contentChildrenDecorator = {
+			name: "ContentChildren",
+			moduleName: C
+		};
+		static InputSignalBrandWriteType = {
+			name: "ɵINPUT_SIGNAL_BRAND_WRITE_TYPE",
+			moduleName: C
+		};
+		static UnwrapDirectiveSignalInputs = {
+			name: "ɵUnwrapDirectiveSignalInputs",
+			moduleName: C
+		};
+		static unwrapWritableSignal = {
+			name: "ɵunwrapWritableSignal",
+			moduleName: C
+		};
+		static assertType = {
+			name: "ɵassertType",
+			moduleName: C
+		};
+	}, dt = class {
+		full;
+		major;
+		minor;
+		patch;
+		constructor(e) {
+			this.full = e;
+			let t = e.split(".");
+			this.major = t[0], this.minor = t[1], this.patch = t.slice(2).join(".");
+		}
+	}, new Map([
+		[b.And, "&&"],
+		[b.Bigger, ">"],
+		[b.BiggerEquals, ">="],
+		[b.BitwiseOr, "|"],
+		[b.BitwiseAnd, "&"],
+		[b.Divide, "/"],
+		[b.Assign, "="],
+		[b.Equals, "=="],
+		[b.Identical, "==="],
+		[b.Lower, "<"],
+		[b.LowerEquals, "<="],
+		[b.Minus, "-"],
+		[b.Modulo, "%"],
+		[b.Exponentiation, "**"],
+		[b.Multiply, "*"],
+		[b.NotEquals, "!="],
+		[b.NotIdentical, "!=="],
+		[b.NullishCoalesce, "??"],
+		[b.Or, "||"],
+		[b.Plus, "+"],
+		[b.In, "in"],
+		[b.AdditionAssignment, "+="],
+		[b.SubtractionAssignment, "-="],
+		[b.MultiplicationAssignment, "*="],
+		[b.DivisionAssignment, "/="],
+		[b.RemainderAssignment, "%="],
+		[b.ExponentiationAssignment, "**="],
+		[b.AndAssignment, "&&="],
+		[b.OrAssignment, "||="],
+		[b.NullishCoalesceAssignment, "??="]
+	]), (function(e) {
+		e[e.Class = 0] = "Class", e[e.Function = 1] = "Function";
+	})(ft ||= {}), T = class {
+		start;
+		end;
+		constructor(e, t) {
+			this.start = e, this.end = t;
+		}
+		toAbsolute(e) {
+			return new A(e + this.start, e + this.end);
+		}
+	}, E = class {
+		span;
+		sourceSpan;
+		constructor(e, t) {
+			this.span = e, this.sourceSpan = t;
+		}
+		toString() {
+			return "AST";
+		}
+	}, pt = class extends E {
+		nameSpan;
+		constructor(e, t, n) {
+			super(e, t), this.nameSpan = n;
+		}
+	}, D = class extends E {
+		visit(e, t = null) {}
+	}, mt = class extends E {
+		visit(e, t = null) {
+			return e.visitImplicitReceiver(this, t);
+		}
+	}, ht = class extends E {
+		visit(e, t = null) {
+			return e.visitThisReceiver?.(this, t);
+		}
+	}, gt = class extends E {
+		expressions;
+		constructor(e, t, n) {
+			super(e, t), this.expressions = n;
+		}
+		visit(e, t = null) {
+			return e.visitChain(this, t);
+		}
+	}, _t = class extends E {
+		condition;
+		trueExp;
+		falseExp;
+		constructor(e, t, n, r, i) {
+			super(e, t), this.condition = n, this.trueExp = r, this.falseExp = i;
+		}
+		visit(e, t = null) {
+			return e.visitConditional(this, t);
+		}
+	}, vt = class extends pt {
+		receiver;
+		name;
+		constructor(e, t, n, r, i) {
+			super(e, t, n), this.receiver = r, this.name = i;
+		}
+		visit(e, t = null) {
+			return e.visitPropertyRead(this, t);
+		}
+	}, yt = class extends pt {
+		receiver;
+		name;
+		constructor(e, t, n, r, i) {
+			super(e, t, n), this.receiver = r, this.name = i;
+		}
+		visit(e, t = null) {
+			return e.visitSafePropertyRead(this, t);
+		}
+	}, bt = class extends E {
+		receiver;
+		key;
+		constructor(e, t, n, r) {
+			super(e, t), this.receiver = n, this.key = r;
+		}
+		visit(e, t = null) {
+			return e.visitKeyedRead(this, t);
+		}
+	}, xt = class extends E {
+		receiver;
+		key;
+		constructor(e, t, n, r) {
+			super(e, t), this.receiver = n, this.key = r;
+		}
+		visit(e, t = null) {
+			return e.visitSafeKeyedRead(this, t);
+		}
+	}, (function(e) {
+		e[e.ReferencedByName = 0] = "ReferencedByName", e[e.ReferencedDirectly = 1] = "ReferencedDirectly";
+	})(St ||= {}), Ct = class extends pt {
+		exp;
+		name;
+		args;
+		type;
+		constructor(e, t, n, r, i, a, o) {
+			super(e, t, o), this.exp = n, this.name = r, this.args = i, this.type = a;
+		}
+		visit(e, t = null) {
+			return e.visitPipe(this, t);
+		}
+	}, O = class extends E {
+		value;
+		constructor(e, t, n) {
+			super(e, t), this.value = n;
+		}
+		visit(e, t = null) {
+			return e.visitLiteralPrimitive(this, t);
+		}
+	}, wt = class extends E {
+		expressions;
+		constructor(e, t, n) {
+			super(e, t), this.expressions = n;
+		}
+		visit(e, t = null) {
+			return e.visitLiteralArray(this, t);
+		}
+	}, Tt = class extends E {
+		expression;
+		constructor(e, t, n) {
+			super(e, t), this.expression = n;
+		}
+		visit(e, t = null) {
+			return e.visitSpreadElement(this, t);
+		}
+	}, Et = class extends E {
+		keys;
+		values;
+		constructor(e, t, n, r) {
+			super(e, t), this.keys = n, this.values = r;
+		}
+		visit(e, t = null) {
+			return e.visitLiteralMap(this, t);
+		}
+	}, Dt = class extends E {
+		strings;
+		expressions;
+		constructor(e, t, n, r) {
+			super(e, t), this.strings = n, this.expressions = r;
+		}
+		visit(e, t = null) {
+			return e.visitInterpolation(this, t);
+		}
+	}, k = class extends E {
+		operation;
+		left;
+		right;
+		constructor(e, t, n, r, i) {
+			super(e, t), this.operation = n, this.left = r, this.right = i;
+		}
+		visit(e, t = null) {
+			return e.visitBinary(this, t);
+		}
+		static isAssignmentOperation(e) {
+			return e === "=" || e === "+=" || e === "-=" || e === "*=" || e === "/=" || e === "%=" || e === "**=" || e === "&&=" || e === "||=" || e === "??=";
+		}
+	}, Ot = class e extends k {
+		operator;
+		expr;
+		left = null;
+		right = null;
+		operation = null;
+		static createMinus(t, n, r) {
+			return new e(t, n, "-", r, "-", new O(t, n, 0), r);
+		}
+		static createPlus(t, n, r) {
+			return new e(t, n, "+", r, "-", r, new O(t, n, 0));
+		}
+		constructor(e, t, n, r, i, a, o) {
+			super(e, t, i, a, o), this.operator = n, this.expr = r;
+		}
+		visit(e, t = null) {
+			return e.visitUnary === void 0 ? e.visitBinary(this, t) : e.visitUnary(this, t);
+		}
+	}, kt = class extends E {
+		expression;
+		constructor(e, t, n) {
+			super(e, t), this.expression = n;
+		}
+		visit(e, t = null) {
+			return e.visitPrefixNot(this, t);
+		}
+	}, At = class extends E {
+		expression;
+		constructor(e, t, n) {
+			super(e, t), this.expression = n;
+		}
+		visit(e, t = null) {
+			return e.visitTypeofExpression(this, t);
+		}
+	}, jt = class extends E {
+		expression;
+		constructor(e, t, n) {
+			super(e, t), this.expression = n;
+		}
+		visit(e, t = null) {
+			return e.visitVoidExpression(this, t);
+		}
+	}, Mt = class extends E {
+		expression;
+		constructor(e, t, n) {
+			super(e, t), this.expression = n;
+		}
+		visit(e, t = null) {
+			return e.visitNonNullAssert(this, t);
+		}
+	}, Nt = class extends E {
+		receiver;
+		args;
+		argumentSpan;
+		constructor(e, t, n, r, i) {
+			super(e, t), this.receiver = n, this.args = r, this.argumentSpan = i;
+		}
+		visit(e, t = null) {
+			return e.visitCall(this, t);
+		}
+	}, Pt = class extends E {
+		receiver;
+		args;
+		argumentSpan;
+		constructor(e, t, n, r, i) {
+			super(e, t), this.receiver = n, this.args = r, this.argumentSpan = i;
+		}
+		visit(e, t = null) {
+			return e.visitSafeCall(this, t);
+		}
+	}, Ft = class extends E {
+		tag;
+		template;
+		constructor(e, t, n, r) {
+			super(e, t), this.tag = n, this.template = r;
+		}
+		visit(e, t) {
+			return e.visitTaggedTemplateLiteral(this, t);
+		}
+	}, It = class extends E {
+		elements;
+		expressions;
+		constructor(e, t, n, r) {
+			super(e, t), this.elements = n, this.expressions = r;
+		}
+		visit(e, t) {
+			return e.visitTemplateLiteral(this, t);
+		}
+	}, Lt = class extends E {
+		text;
+		constructor(e, t, n) {
+			super(e, t), this.text = n;
+		}
+		visit(e, t) {
+			return e.visitTemplateLiteralElement(this, t);
+		}
+	}, Rt = class extends E {
+		expression;
+		constructor(e, t, n) {
+			super(e, t), this.expression = n;
+		}
+		visit(e, t) {
+			return e.visitParenthesizedExpression(this, t);
+		}
+	}, zt = class extends E {
+		body;
+		flags;
+		constructor(e, t, n, r) {
+			super(e, t), this.body = n, this.flags = r;
+		}
+		visit(e, t) {
+			return e.visitRegularExpressionLiteral(this, t);
+		}
+	}, A = class {
+		start;
+		end;
+		constructor(e, t) {
+			this.start = e, this.end = t;
+		}
+	}, j = class extends E {
+		ast;
+		source;
+		location;
+		errors;
+		constructor(e, t, n, r, i) {
+			super(new T(0, t === null ? 0 : t.length), new A(r, t === null ? r : r + t.length)), this.ast = e, this.source = t, this.location = n, this.errors = i;
+		}
+		visit(e, t = null) {
+			return e.visitASTWithSource ? e.visitASTWithSource(this, t) : this.ast.visit(e, t);
+		}
+		toString() {
+			return `${this.source} in ${this.location}`;
+		}
+	}, Bt = class {
+		sourceSpan;
+		key;
+		value;
+		constructor(e, t, n) {
+			this.sourceSpan = e, this.key = t, this.value = n;
+		}
+	}, Vt = class {
+		sourceSpan;
+		key;
+		value;
+		constructor(e, t, n) {
+			this.sourceSpan = e, this.key = t, this.value = n;
+		}
+	}, Ht = class {
+		visit(e, t) {
+			e.visit(this, t);
+		}
+		visitUnary(e, t) {
+			this.visit(e.expr, t);
+		}
+		visitBinary(e, t) {
+			this.visit(e.left, t), this.visit(e.right, t);
+		}
+		visitChain(e, t) {
+			this.visitAll(e.expressions, t);
+		}
+		visitConditional(e, t) {
+			this.visit(e.condition, t), this.visit(e.trueExp, t), this.visit(e.falseExp, t);
+		}
+		visitPipe(e, t) {
+			this.visit(e.exp, t), this.visitAll(e.args, t);
+		}
+		visitImplicitReceiver(e, t) {}
+		visitThisReceiver(e, t) {}
+		visitInterpolation(e, t) {
+			this.visitAll(e.expressions, t);
+		}
+		visitKeyedRead(e, t) {
+			this.visit(e.receiver, t), this.visit(e.key, t);
+		}
+		visitLiteralArray(e, t) {
+			this.visitAll(e.expressions, t);
+		}
+		visitLiteralMap(e, t) {
+			this.visitAll(e.values, t);
+		}
+		visitLiteralPrimitive(e, t) {}
+		visitPrefixNot(e, t) {
+			this.visit(e.expression, t);
+		}
+		visitTypeofExpression(e, t) {
+			this.visit(e.expression, t);
+		}
+		visitVoidExpression(e, t) {
+			this.visit(e.expression, t);
+		}
+		visitNonNullAssert(e, t) {
+			this.visit(e.expression, t);
+		}
+		visitPropertyRead(e, t) {
+			this.visit(e.receiver, t);
+		}
+		visitSafePropertyRead(e, t) {
+			this.visit(e.receiver, t);
+		}
+		visitSafeKeyedRead(e, t) {
+			this.visit(e.receiver, t), this.visit(e.key, t);
+		}
+		visitCall(e, t) {
+			this.visit(e.receiver, t), this.visitAll(e.args, t);
+		}
+		visitSafeCall(e, t) {
+			this.visit(e.receiver, t), this.visitAll(e.args, t);
+		}
+		visitTemplateLiteral(e, t) {
+			for (let n = 0; n < e.elements.length; n++) {
+				this.visit(e.elements[n], t);
+				let r = n < e.expressions.length ? e.expressions[n] : null;
+				r !== null && this.visit(r, t);
+			}
+		}
+		visitTemplateLiteralElement(e, t) {}
+		visitTaggedTemplateLiteral(e, t) {
+			this.visit(e.tag, t), this.visit(e.template, t);
+		}
+		visitParenthesizedExpression(e, t) {
+			this.visit(e.expression, t);
+		}
+		visitRegularExpressionLiteral(e, t) {}
+		visitSpreadElement(e, t) {
+			this.visit(e.expression, t);
+		}
+		visitAll(e, t) {
+			for (let n of e) this.visit(n, t);
+		}
+	}, (function(e) {
+		e[e.DEFAULT = 0] = "DEFAULT", e[e.LITERAL_ATTR = 1] = "LITERAL_ATTR", e[e.LEGACY_ANIMATION = 2] = "LEGACY_ANIMATION", e[e.TWO_WAY = 3] = "TWO_WAY", e[e.ANIMATION = 4] = "ANIMATION";
+	})(Ut ||= {}), (function(e) {
+		e[e.Regular = 0] = "Regular", e[e.LegacyAnimation = 1] = "LegacyAnimation", e[e.TwoWay = 2] = "TwoWay", e[e.Animation = 3] = "Animation";
+	})(Wt ||= {}), (function(e) {
+		e[e.Property = 0] = "Property", e[e.Attribute = 1] = "Attribute", e[e.Class = 2] = "Class", e[e.Style = 3] = "Style", e[e.LegacyAnimation = 4] = "LegacyAnimation", e[e.TwoWay = 5] = "TwoWay", e[e.Animation = 6] = "Animation";
+	})(M ||= {}), (function(e) {
+		e[e.RAW_TEXT = 0] = "RAW_TEXT", e[e.ESCAPABLE_RAW_TEXT = 1] = "ESCAPABLE_RAW_TEXT", e[e.PARSABLE_DATA = 2] = "PARSABLE_DATA";
+	})(Gt ||= {}), N = 0, Kt = 9, qt = 10, Jt = 11, Yt = 12, Xt = 13, Zt = 32, Qt = 33, $t = 34, en = 35, tn = 36, nn = 37, rn = 38, an = 39, P = 40, F = 41, on = 42, sn = 43, I = 44, cn = 45, L = 46, ln = 47, R = 58, z = 59, un = 60, B = 61, dn = 62, fn = 63, pn = 48, mn = 57, hn = 65, gn = 69, _n = 90, V = 91, vn = 92, H = 93, yn = 94, bn = 95, xn = 97, Sn = 101, Cn = 102, wn = 110, Tn = 114, En = 116, Dn = 117, On = 118, kn = 122, An = 123, jn = 124, U = 125, Mn = 160, Nn = 96, Pn = class e {
+		file;
+		offset;
+		line;
+		col;
+		constructor(e, t, n, r) {
+			this.file = e, this.offset = t, this.line = n, this.col = r;
+		}
+		toString() {
+			return this.offset == null ? this.file.url : `${this.file.url}@${this.line}:${this.col}`;
+		}
+		moveBy(t) {
+			let n = this.file.content, r = n.length, i = this.offset, a = this.line, o = this.col;
+			for (; i > 0 && t < 0;) if (i--, t++, n.charCodeAt(i) == qt) {
+				a--;
+				let e = n.substring(0, i - 1).lastIndexOf(String.fromCharCode(qt));
+				o = e > 0 ? i - e : i;
+			} else o--;
+			for (; i < r && t > 0;) {
+				let e = n.charCodeAt(i);
+				i++, t--, e == qt ? (a++, o = 0) : o++;
+			}
+			return new e(this.file, i, a, o);
+		}
+		getContext(e, t) {
+			let n = this.file.content, r = this.offset;
+			if (r != null) {
+				r > n.length - 1 && (r = n.length - 1);
+				let i = r, a = 0, o = 0;
+				for (; a < e && r > 0 && (r--, a++, !(n[r] == "\n" && ++o == t)););
+				for (a = 0, o = 0; a < e && i < n.length - 1 && (i++, a++, !(n[i] == "\n" && ++o == t)););
+				return {
+					before: n.substring(r, this.offset),
+					after: n.substring(this.offset, i + 1)
+				};
+			}
+			return null;
+		}
+	}, Fn = class {
+		content;
+		url;
+		constructor(e, t) {
+			this.content = e, this.url = t;
+		}
+	}, In = class {
+		start;
+		end;
+		fullStart;
+		details;
+		constructor(e, t, n = e, r = null) {
+			this.start = e, this.end = t, this.fullStart = n, this.details = r;
+		}
+		toString() {
+			return this.start.file.content.substring(this.start.offset, this.end.offset);
+		}
+	}, (function(e) {
+		e[e.WARNING = 0] = "WARNING", e[e.ERROR = 1] = "ERROR";
+	})(Ln ||= {}), Rn = class extends Error {
+		span;
+		msg;
+		level;
+		relatedError;
+		constructor(e, t, n = Ln.ERROR, r) {
+			super(t), this.span = e, this.msg = t, this.level = n, this.relatedError = r, Object.setPrototypeOf(this, new.target.prototype);
+		}
+		contextualMessage() {
+			let e = this.span.start.getContext(100, 3);
+			return e ? `${this.msg} ("${e.before}[${Ln[this.level]} ->]${e.after}")` : this.msg;
+		}
+		toString() {
+			let e = this.span.details ? `, ${this.span.details}` : "";
+			return `${this.contextualMessage()}: ${this.span.start}${e}`;
+		}
+	}, (function(e) {
+		e[e.Inline = 0] = "Inline", e[e.SideEffect = 1] = "SideEffect", e[e.Omit = 2] = "Omit";
+	})(zn ||= {}), (function(e) {
+		e[e.Global = 0] = "Global", e[e.Local = 1] = "Local";
+	})(Bn ||= {}), (function(e) {
+		e[e.Directive = 0] = "Directive", e[e.Pipe = 1] = "Pipe", e[e.NgModule = 2] = "NgModule";
+	})(Vn ||= {}), Hn = "(:(where|is)\\()?", Un = "-shadowcsshost", Wn = "-shadowcsscontext", Gn = "[^)(]*", Kn = `(?:\\((${`(?:\\(${`(?:\\(${Gn}\\)|${Gn})+?`}\\)|${Gn})+?`})\\))`, RegExp("(:nth-[-\\w]+)" + Kn, "g"), RegExp(Un + Kn + "?([^,{]*)", "gim"), qn = Wn + Kn + "?([^{]*)", RegExp(`${Hn}(${qn})`, "gim"), Jn = Un + "-no-combinator", RegExp(`${Jn}(?![^(]*\\))`, "g"), Yn = "%COMMENT%", new RegExp(Yn, "g"), RegExp(`(\\s*(?:${Yn}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`, "g"), Xn = "%COMMA_IN_PLACEHOLDER%", Zn = "%SEMI_IN_PLACEHOLDER%", Qn = "%COLON_IN_PLACEHOLDER%", new RegExp(Xn, "g"), new RegExp(Zn, "g"), new RegExp(Qn, "g"), (function(e) {
+		e[e.ListEnd = 0] = "ListEnd", e[e.Statement = 1] = "Statement", e[e.Variable = 2] = "Variable", e[e.ElementStart = 3] = "ElementStart", e[e.Element = 4] = "Element", e[e.Template = 5] = "Template", e[e.ElementEnd = 6] = "ElementEnd", e[e.ContainerStart = 7] = "ContainerStart", e[e.Container = 8] = "Container", e[e.ContainerEnd = 9] = "ContainerEnd", e[e.DisableBindings = 10] = "DisableBindings", e[e.ConditionalCreate = 11] = "ConditionalCreate", e[e.ConditionalBranchCreate = 12] = "ConditionalBranchCreate", e[e.Conditional = 13] = "Conditional", e[e.EnableBindings = 14] = "EnableBindings", e[e.Text = 15] = "Text", e[e.Listener = 16] = "Listener", e[e.InterpolateText = 17] = "InterpolateText", e[e.Binding = 18] = "Binding", e[e.Property = 19] = "Property", e[e.StyleProp = 20] = "StyleProp", e[e.ClassProp = 21] = "ClassProp", e[e.StyleMap = 22] = "StyleMap", e[e.ClassMap = 23] = "ClassMap", e[e.Advance = 24] = "Advance", e[e.Pipe = 25] = "Pipe", e[e.Attribute = 26] = "Attribute", e[e.ExtractedAttribute = 27] = "ExtractedAttribute", e[e.Defer = 28] = "Defer", e[e.DeferOn = 29] = "DeferOn", e[e.DeferWhen = 30] = "DeferWhen", e[e.I18nMessage = 31] = "I18nMessage", e[e.DomProperty = 32] = "DomProperty", e[e.Namespace = 33] = "Namespace", e[e.ProjectionDef = 34] = "ProjectionDef", e[e.Projection = 35] = "Projection", e[e.RepeaterCreate = 36] = "RepeaterCreate", e[e.Repeater = 37] = "Repeater", e[e.TwoWayProperty = 38] = "TwoWayProperty", e[e.TwoWayListener = 39] = "TwoWayListener", e[e.DeclareLet = 40] = "DeclareLet", e[e.StoreLet = 41] = "StoreLet", e[e.I18nStart = 42] = "I18nStart", e[e.I18n = 43] = "I18n", e[e.I18nEnd = 44] = "I18nEnd", e[e.I18nExpression = 45] = "I18nExpression", e[e.I18nApply = 46] = "I18nApply", e[e.IcuStart = 47] = "IcuStart", e[e.IcuEnd = 48] = "IcuEnd", e[e.IcuPlaceholder = 49] = "IcuPlaceholder", e[e.I18nContext = 50] = "I18nContext", e[e.I18nAttributes = 51] = "I18nAttributes", e[e.SourceLocation = 52] = "SourceLocation", e[e.Animation = 53] = "Animation", e[e.AnimationString = 54] = "AnimationString", e[e.AnimationBinding = 55] = "AnimationBinding", e[e.AnimationListener = 56] = "AnimationListener", e[e.Control = 57] = "Control", e[e.ControlCreate = 58] = "ControlCreate";
+	})(W ||= {}), (function(e) {
+		e[e.LexicalRead = 0] = "LexicalRead", e[e.Context = 1] = "Context", e[e.TrackContext = 2] = "TrackContext", e[e.ReadVariable = 3] = "ReadVariable", e[e.NextContext = 4] = "NextContext", e[e.Reference = 5] = "Reference", e[e.StoreLet = 6] = "StoreLet", e[e.ContextLetReference = 7] = "ContextLetReference", e[e.GetCurrentView = 8] = "GetCurrentView", e[e.RestoreView = 9] = "RestoreView", e[e.ResetView = 10] = "ResetView", e[e.PureFunctionExpr = 11] = "PureFunctionExpr", e[e.PureFunctionParameterExpr = 12] = "PureFunctionParameterExpr", e[e.PipeBinding = 13] = "PipeBinding", e[e.PipeBindingVariadic = 14] = "PipeBindingVariadic", e[e.SafePropertyRead = 15] = "SafePropertyRead", e[e.SafeKeyedRead = 16] = "SafeKeyedRead", e[e.SafeInvokeFunction = 17] = "SafeInvokeFunction", e[e.SafeTernaryExpr = 18] = "SafeTernaryExpr", e[e.EmptyExpr = 19] = "EmptyExpr", e[e.AssignTemporaryExpr = 20] = "AssignTemporaryExpr", e[e.ReadTemporaryExpr = 21] = "ReadTemporaryExpr", e[e.SlotLiteralExpr = 22] = "SlotLiteralExpr", e[e.ConditionalCase = 23] = "ConditionalCase", e[e.ConstCollected = 24] = "ConstCollected", e[e.TwoWayBindingSet = 25] = "TwoWayBindingSet";
+	})($n ||= {}), (function(e) {
+		e[e.None = 0] = "None", e[e.AlwaysInline = 1] = "AlwaysInline";
+	})(er ||= {}), (function(e) {
+		e[e.Context = 0] = "Context", e[e.Identifier = 1] = "Identifier", e[e.SavedView = 2] = "SavedView", e[e.Alias = 3] = "Alias";
+	})(tr ||= {}), (function(e) {
+		e[e.Normal = 0] = "Normal", e[e.TemplateDefinitionBuilder = 1] = "TemplateDefinitionBuilder";
+	})(nr ||= {}), (function(e) {
+		e[e.Attribute = 0] = "Attribute", e[e.ClassName = 1] = "ClassName", e[e.StyleProperty = 2] = "StyleProperty", e[e.Property = 3] = "Property", e[e.Template = 4] = "Template", e[e.I18n = 5] = "I18n", e[e.LegacyAnimation = 6] = "LegacyAnimation", e[e.TwoWayProperty = 7] = "TwoWayProperty", e[e.Animation = 8] = "Animation";
+	})(G ||= {}), (function(e) {
+		e[e.Creation = 0] = "Creation", e[e.Postproccessing = 1] = "Postproccessing";
+	})(rr ||= {}), (function(e) {
+		e[e.I18nText = 0] = "I18nText", e[e.I18nAttribute = 1] = "I18nAttribute";
+	})(ir ||= {}), (function(e) {
+		e[e.None = 0] = "None", e[e.ElementTag = 1] = "ElementTag", e[e.TemplateTag = 2] = "TemplateTag", e[e.OpenTag = 4] = "OpenTag", e[e.CloseTag = 8] = "CloseTag", e[e.ExpressionIndex = 16] = "ExpressionIndex";
+	})(ar ||= {}), (function(e) {
+		e[e.HTML = 0] = "HTML", e[e.SVG = 1] = "SVG", e[e.Math = 2] = "Math";
+	})(or ||= {}), (function(e) {
+		e[e.Idle = 0] = "Idle", e[e.Immediate = 1] = "Immediate", e[e.Timer = 2] = "Timer", e[e.Hover = 3] = "Hover", e[e.Interaction = 4] = "Interaction", e[e.Viewport = 5] = "Viewport", e[e.Never = 6] = "Never";
+	})(K ||= {}), (function(e) {
+		e[e.RootI18n = 0] = "RootI18n", e[e.Icu = 1] = "Icu", e[e.Attr = 2] = "Attr";
+	})(sr ||= {}), (function(e) {
+		e[e.NgTemplate = 0] = "NgTemplate", e[e.Structural = 1] = "Structural", e[e.Block = 2] = "Block";
+	})(cr ||= {}), (function(e) {
+		e[e.None = 0] = "None", e[e.InChildOperation = 1] = "InChildOperation";
+	})(lr ||= {}), new Set([
+		W.Element,
+		W.ElementStart,
+		W.Container,
+		W.ContainerStart,
+		W.Template,
+		W.RepeaterCreate,
+		W.ConditionalCreate,
+		W.ConditionalBranchCreate
+	]), (function(e) {
+		e[e.Tmpl = 0] = "Tmpl", e[e.Host = 1] = "Host", e[e.Both = 2] = "Both";
+	})(ur ||= {}), (function(e) {
+		e[e.Full = 0] = "Full", e[e.DomOnly = 1] = "DomOnly";
+	})(dr ||= {}), new Map([
+		[w.ariaProperty, w.ariaProperty],
+		[w.attribute, w.attribute],
+		[w.classProp, w.classProp],
+		[w.element, w.element],
+		[w.elementContainer, w.elementContainer],
+		[w.elementContainerEnd, w.elementContainerEnd],
+		[w.elementContainerStart, w.elementContainerStart],
+		[w.elementEnd, w.elementEnd],
+		[w.elementStart, w.elementStart],
+		[w.domProperty, w.domProperty],
+		[w.i18nExp, w.i18nExp],
+		[w.listener, w.listener],
+		[w.listener, w.listener],
+		[w.property, w.property],
+		[w.styleProp, w.styleProp],
+		[w.syntheticHostListener, w.syntheticHostListener],
+		[w.syntheticHostProperty, w.syntheticHostProperty],
+		[w.templateCreate, w.templateCreate],
+		[w.twoWayProperty, w.twoWayProperty],
+		[w.twoWayListener, w.twoWayListener],
+		[w.declareLet, w.declareLet],
+		[w.conditionalCreate, w.conditionalBranchCreate],
+		[w.conditionalBranchCreate, w.conditionalBranchCreate],
+		[w.domElement, w.domElement],
+		[w.domElementStart, w.domElementStart],
+		[w.domElementEnd, w.domElementEnd],
+		[w.domElementContainer, w.domElementContainer],
+		[w.domElementContainerStart, w.domElementContainerStart],
+		[w.domElementContainerEnd, w.domElementContainerEnd],
+		[w.domListener, w.domListener],
+		[w.domTemplate, w.domTemplate],
+		[w.animationEnter, w.animationEnter],
+		[w.animationLeave, w.animationLeave],
+		[w.animationEnterListener, w.animationEnterListener],
+		[w.animationLeaveListener, w.animationLeaveListener]
+	]), new Map([
+		["&&", b.And],
+		[">", b.Bigger],
+		[">=", b.BiggerEquals],
+		["|", b.BitwiseOr],
+		["&", b.BitwiseAnd],
+		["/", b.Divide],
+		["=", b.Assign],
+		["==", b.Equals],
+		["===", b.Identical],
+		["<", b.Lower],
+		["<=", b.LowerEquals],
+		["-", b.Minus],
+		["%", b.Modulo],
+		["**", b.Exponentiation],
+		["*", b.Multiply],
+		["!=", b.NotEquals],
+		["!==", b.NotIdentical],
+		["??", b.NullishCoalesce],
+		["||", b.Or],
+		["+", b.Plus],
+		["in", b.In],
+		["+=", b.AdditionAssignment],
+		["-=", b.SubtractionAssignment],
+		["*=", b.MultiplicationAssignment],
+		["/=", b.DivisionAssignment],
+		["%=", b.RemainderAssignment],
+		["**=", b.ExponentiationAssignment],
+		["&&=", b.AndAssignment],
+		["||=", b.OrAssignment],
+		["??=", b.NullishCoalesceAssignment]
+	]), Object.freeze([]), new Map([
+		[W.ElementEnd, [W.ElementStart, W.Element]],
+		[W.ContainerEnd, [W.ContainerStart, W.Container]],
+		[W.I18nEnd, [W.I18nStart, W.I18n]]
+	]), new Set([W.Pipe]), fr = {}, fr.ngsp = "", (function(e) {
+		e.HEX = "hexadecimal", e.DEC = "decimal";
+	})(pr ||= {}), mr = " \f\n\r	\v ᠎ - \u2028\u2029  　", RegExp(`[^${mr}]`), RegExp(`[${mr}]{2,}`, "g"), (function(e) {
+		e[e.Character = 0] = "Character", e[e.Identifier = 1] = "Identifier", e[e.PrivateIdentifier = 2] = "PrivateIdentifier", e[e.Keyword = 3] = "Keyword", e[e.String = 4] = "String", e[e.Operator = 5] = "Operator", e[e.Number = 6] = "Number", e[e.RegExpBody = 7] = "RegExpBody", e[e.RegExpFlags = 8] = "RegExpFlags", e[e.Error = 9] = "Error";
+	})(q ||= {}), (function(e) {
+		e[e.Plain = 0] = "Plain", e[e.TemplateLiteralPart = 1] = "TemplateLiteralPart", e[e.TemplateLiteralEnd = 2] = "TemplateLiteralEnd";
+	})(J ||= {}), hr = [
+		"var",
+		"let",
+		"as",
+		"null",
+		"undefined",
+		"true",
+		"false",
+		"if",
+		"else",
+		"this",
+		"typeof",
+		"void",
+		"in"
+	], gr = class {
+		tokenize(e) {
+			return new yr(e).scan();
+		}
+	}, Y = class {
+		index;
+		end;
+		type;
+		numValue;
+		strValue;
+		constructor(e, t, n, r, i) {
+			this.index = e, this.end = t, this.type = n, this.numValue = r, this.strValue = i;
+		}
+		isCharacter(e) {
+			return this.type === q.Character && this.numValue === e;
+		}
+		isNumber() {
+			return this.type === q.Number;
+		}
+		isString() {
+			return this.type === q.String;
+		}
+		isOperator(e) {
+			return this.type === q.Operator && this.strValue === e;
+		}
+		isIdentifier() {
+			return this.type === q.Identifier;
+		}
+		isPrivateIdentifier() {
+			return this.type === q.PrivateIdentifier;
+		}
+		isKeyword() {
+			return this.type === q.Keyword;
+		}
+		isKeywordLet() {
+			return this.type === q.Keyword && this.strValue === "let";
+		}
+		isKeywordAs() {
+			return this.type === q.Keyword && this.strValue === "as";
+		}
+		isKeywordNull() {
+			return this.type === q.Keyword && this.strValue === "null";
+		}
+		isKeywordUndefined() {
+			return this.type === q.Keyword && this.strValue === "undefined";
+		}
+		isKeywordTrue() {
+			return this.type === q.Keyword && this.strValue === "true";
+		}
+		isKeywordFalse() {
+			return this.type === q.Keyword && this.strValue === "false";
+		}
+		isKeywordThis() {
+			return this.type === q.Keyword && this.strValue === "this";
+		}
+		isKeywordTypeof() {
+			return this.type === q.Keyword && this.strValue === "typeof";
+		}
+		isKeywordVoid() {
+			return this.type === q.Keyword && this.strValue === "void";
+		}
+		isKeywordIn() {
+			return this.type === q.Keyword && this.strValue === "in";
+		}
+		isError() {
+			return this.type === q.Error;
+		}
+		isRegExpBody() {
+			return this.type === q.RegExpBody;
+		}
+		isRegExpFlags() {
+			return this.type === q.RegExpFlags;
+		}
+		toNumber() {
+			return this.type === q.Number ? this.numValue : -1;
+		}
+		isTemplateLiteralPart() {
+			return this.isString() && this.kind === J.TemplateLiteralPart;
+		}
+		isTemplateLiteralEnd() {
+			return this.isString() && this.kind === J.TemplateLiteralEnd;
+		}
+		isTemplateLiteralInterpolationStart() {
+			return this.isOperator("${");
+		}
+		toString() {
+			switch (this.type) {
+				case q.Character:
+				case q.Identifier:
+				case q.Keyword:
+				case q.Operator:
+				case q.PrivateIdentifier:
+				case q.String:
+				case q.Error:
+				case q.RegExpBody:
+				case q.RegExpFlags: return this.strValue;
+				case q.Number: return this.numValue.toString();
+				default: return null;
+			}
+		}
+	}, _r = class extends Y {
+		kind;
+		constructor(e, t, n, r) {
+			super(e, t, q.String, 0, n), this.kind = r;
+		}
+	}, vr = new Y(-1, -1, q.Character, 0, ""), yr = class {
+		input;
+		tokens = [];
+		length;
+		peek = 0;
+		index = -1;
+		braceStack = [];
+		constructor(e) {
+			this.input = e, this.length = e.length, this.advance();
+		}
+		scan() {
+			let e = this.scanToken();
+			for (; e !== null;) this.tokens.push(e), e = this.scanToken();
+			return this.tokens;
+		}
+		advance() {
+			this.peek = ++this.index >= this.length ? N : this.input.charCodeAt(this.index);
+		}
+		scanToken() {
+			let e = this.input, t = this.length, n = this.peek, r = this.index;
+			for (; n <= Zt;) if (++r >= t) {
+				n = N;
+				break;
+			} else n = e.charCodeAt(r);
+			if (this.peek = n, this.index = r, r >= t) return null;
+			if (ce(n)) return this.scanIdentifier();
+			if (u(n)) return this.scanNumber(r);
+			let i = r;
+			switch (n) {
+				case L: return this.advance(), u(this.peek) ? this.scanNumber(i) : this.peek === L ? (this.advance(), this.peek === L ? (this.advance(), m(i, this.index, "...")) : this.error(`Unexpected character [${String.fromCharCode(n)}]`, 0)) : p(i, this.index, L);
+				case P:
+				case F:
+				case V:
+				case H:
+				case I:
+				case R:
+				case z: return this.scanCharacter(i, n);
+				case An: return this.scanOpenBrace(i, n);
+				case U: return this.scanCloseBrace(i, n);
+				case an:
+				case $t: return this.scanString();
+				case Nn: return this.advance(), this.scanTemplateLiteralPart(i);
+				case en: return this.scanPrivateIdentifier();
+				case sn: return this.scanComplexOperator(i, "+", B, "=");
+				case cn: return this.scanComplexOperator(i, "-", B, "=");
+				case ln: return this.isStartOfRegex() ? this.scanRegex(r) : this.scanComplexOperator(i, "/", B, "=");
+				case nn: return this.scanComplexOperator(i, "%", B, "=");
+				case yn: return this.scanOperator(i, "^");
+				case on: return this.scanStar(i);
+				case fn: return this.scanQuestion(i);
+				case un:
+				case dn: return this.scanComplexOperator(i, String.fromCharCode(n), B, "=");
+				case Qt:
+				case B: return this.scanComplexOperator(i, String.fromCharCode(n), B, "=", B, "=");
+				case rn: return this.scanComplexOperator(i, "&", rn, "&", B, "=");
+				case jn: return this.scanComplexOperator(i, "|", jn, "|", B, "=");
+				case Mn:
+					for (; ee(this.peek);) this.advance();
+					return this.scanToken();
+			}
+			return this.advance(), this.error(`Unexpected character [${String.fromCharCode(n)}]`, 0);
+		}
+		scanCharacter(e, t) {
+			return this.advance(), p(e, this.index, t);
+		}
+		scanOperator(e, t) {
+			return this.advance(), m(e, this.index, t);
+		}
+		scanOpenBrace(e, t) {
+			return this.braceStack.push("expression"), this.advance(), p(e, this.index, t);
+		}
+		scanCloseBrace(e, t) {
+			return this.advance(), this.braceStack.pop() === "interpolation" ? (this.tokens.push(p(e, this.index, U)), this.scanTemplateLiteralPart(this.index)) : p(e, this.index, t);
+		}
+		scanComplexOperator(e, t, n, r, i, a) {
+			this.advance();
+			let o = t;
+			return this.peek == n && (this.advance(), o += r), i != null && this.peek == i && (this.advance(), o += a), m(e, this.index, o);
+		}
+		scanIdentifier() {
+			let e = this.index;
+			for (this.advance(); le(this.peek);) this.advance();
+			let t = this.input.substring(e, this.index);
+			return hr.indexOf(t) > -1 ? re(e, this.index, t) : te(e, this.index, t);
+		}
+		scanPrivateIdentifier() {
+			let e = this.index;
+			if (this.advance(), !ce(this.peek)) return this.error("Invalid character [#]", -1);
+			for (; le(this.peek);) this.advance();
+			let t = this.input.substring(e, this.index);
+			return ne(e, this.index, t);
+		}
+		scanNumber(e) {
+			let t = this.index === e, n = !1;
+			for (this.advance();;) {
+				if (!u(this.peek)) if (this.peek === bn) {
+					if (!u(this.input.charCodeAt(this.index - 1)) || !u(this.input.charCodeAt(this.index + 1))) return this.error("Invalid numeric separator", 0);
+					n = !0;
+				} else if (this.peek === L) t = !1;
+				else if (ue(this.peek)) {
+					if (this.advance(), de(this.peek) && this.advance(), !u(this.peek)) return this.error("Invalid exponent", -1);
+					t = !1;
+				} else break;
+				this.advance();
+			}
+			let r = this.input.substring(e, this.index);
+			n && (r = r.replace(/_/g, ""));
+			let i = t ? pe(r) : parseFloat(r);
+			return ie(e, this.index, i);
+		}
+		scanString() {
+			let e = this.index, t = this.peek;
+			this.advance();
+			let n = "", r = this.index, i = this.input;
+			for (; this.peek != t;) if (this.peek == vn) {
+				let e = this.scanStringBackslash(n, r);
+				if (typeof e != "string") return e;
+				n = e, r = this.index;
+			} else {
+				if (this.peek == N) return this.error("Unterminated quote", 0);
+				this.advance();
+			}
+			let a = i.substring(r, this.index);
+			return this.advance(), new _r(e, this.index, n + a, J.Plain);
+		}
+		scanQuestion(e) {
+			this.advance();
+			let t = "?";
+			return this.peek === fn ? (t += "?", this.advance(), this.peek === B && (t += "=", this.advance())) : this.peek === L && (t += ".", this.advance()), m(e, this.index, t);
+		}
+		scanTemplateLiteralPart(e) {
+			let t = "", n = this.index;
+			for (; this.peek !== Nn;) if (this.peek === vn) {
+				let e = this.scanStringBackslash(t, n);
+				if (typeof e != "string") return e;
+				t = e, n = this.index;
+			} else if (this.peek === tn) {
+				let r = this.index;
+				if (this.advance(), this.peek === An) return this.braceStack.push("interpolation"), this.tokens.push(new _r(e, r, t + this.input.substring(n, r), J.TemplateLiteralPart)), this.advance(), m(r, this.index, this.input.substring(r, this.index));
+			} else {
+				if (this.peek === N) return this.error("Unterminated template literal", 0);
+				this.advance();
+			}
+			let r = this.input.substring(n, this.index);
+			return this.advance(), new _r(e, this.index, t + r, J.TemplateLiteralEnd);
+		}
+		error(e, t) {
+			let n = this.index + t;
+			return ae(n, this.index, `Lexer Error: ${e} at column ${n} in expression [${this.input}]`);
+		}
+		scanStringBackslash(e, t) {
+			e += this.input.substring(t, this.index);
+			let n;
+			if (this.advance(), this.peek === Dn) {
+				let e = this.input.substring(this.index + 1, this.index + 5);
+				if (/^[0-9a-f]+$/i.test(e)) n = parseInt(e, 16);
+				else return this.error(`Invalid unicode escape [\\u${e}]`, 0);
+				for (let e = 0; e < 5; e++) this.advance();
+			} else n = fe(this.peek), this.advance();
+			return e += String.fromCharCode(n), e;
+		}
+		scanStar(e) {
+			this.advance();
+			let t = "*";
+			return this.peek === on ? (t += "*", this.advance(), this.peek === B && (t += "=", this.advance())) : this.peek === B && (t += "=", this.advance()), m(e, this.index, t);
+		}
+		isStartOfRegex() {
+			if (this.tokens.length === 0) return !0;
+			let e = this.tokens[this.tokens.length - 1];
+			if (e.isOperator("!")) {
+				let e = this.tokens.length > 1 ? this.tokens[this.tokens.length - 2] : null;
+				return e === null || e.type !== q.Identifier && !e.isCharacter(F) && !e.isCharacter(H);
+			}
+			return e.type === q.Operator || e.isCharacter(P) || e.isCharacter(V) || e.isCharacter(I) || e.isCharacter(R);
+		}
+		scanRegex(e) {
+			this.advance();
+			let t = this.index, n = !1, r = !1;
+			for (;;) {
+				let e = this.peek;
+				if (e === N) return this.error("Unterminated regular expression", 0);
+				if (n) n = !1;
+				else if (e === vn) n = !0;
+				else if (e === V) r = !0;
+				else if (e === H) r = !1;
+				else if (e === ln && !r) break;
+				this.advance();
+			}
+			let i = this.input.substring(t, this.index);
+			this.advance();
+			let a = oe(e, this.index, i), o = this.scanRegexFlags(this.index);
+			return o === null ? a : (this.tokens.push(a), o);
+		}
+		scanRegexFlags(e) {
+			if (!d(this.peek)) return null;
+			for (; d(this.peek);) this.advance();
+			return se(e, this.index, this.input.substring(e, this.index));
+		}
+	}, br = class {
+		strings;
+		expressions;
+		offsets;
+		constructor(e, t, n) {
+			this.strings = e, this.expressions = t, this.offsets = n;
+		}
+	}, xr = class {
+		templateBindings;
+		warnings;
+		errors;
+		constructor(e, t, n) {
+			this.templateBindings = e, this.warnings = t, this.errors = n;
+		}
+	}, Sr = class {
+		_lexer;
+		_supportsDirectPipeReferences;
+		constructor(e, t = !1) {
+			this._lexer = e, this._supportsDirectPipeReferences = t;
+		}
+		parseAction(e, t, n) {
+			let r = [];
+			this._checkNoInterpolation(r, e, t);
+			let { stripped: i } = this._stripComments(e);
+			return new j(new X(e, t, n, this._lexer.tokenize(i), 1, r, 0, this._supportsDirectPipeReferences).parseChain(), e, h(t), n, r);
+		}
+		parseBinding(e, t, n) {
+			let r = [];
+			return new j(this._parseBindingAst(e, t, n, r), e, h(t), n, r);
+		}
+		checkSimpleExpression(e) {
+			let t = new Tr();
+			return e.visit(t), t.errors;
+		}
+		parseSimpleBinding(e, t, n) {
+			let r = [], i = this._parseBindingAst(e, t, n, r), a = this.checkSimpleExpression(i);
+			return a.length > 0 && r.push(g(`Host binding expression cannot contain ${a.join(" ")}`, e, "", t)), new j(i, e, h(t), n, r);
+		}
+		_parseBindingAst(e, t, n, r) {
+			this._checkNoInterpolation(r, e, t);
+			let { stripped: i } = this._stripComments(e);
+			return new X(e, t, n, this._lexer.tokenize(i), 0, r, 0, this._supportsDirectPipeReferences).parseChain();
+		}
+		parseTemplateBindings(e, t, n, r, i) {
+			return new X(t, n, i, this._lexer.tokenize(t), 0, [], 0, this._supportsDirectPipeReferences).parseTemplateBindings({
+				source: e,
+				span: new A(r, r + e.length)
+			});
+		}
+		parseInterpolation(e, t, n, r) {
+			let i = [], { strings: a, expressions: o, offsets: s } = this.splitInterpolation(e, t, i, r);
+			if (o.length === 0) return null;
+			let c = [];
+			for (let a = 0; a < o.length; ++a) {
+				let l = r?.[a * 2 + 1]?.sourceSpan, ee = o[a].text, { stripped: u, hasComments: d } = this._stripComments(ee), f = this._lexer.tokenize(u);
+				if (d && u.trim().length === 0 && f.length === 0) {
+					i.push(g("Interpolation expression cannot only contain a comment", e, `at column ${o[a].start} in`, t));
+					continue;
+				}
+				let p = new X(l ? ee : e, l || t, n, f, 0, i, s[a], this._supportsDirectPipeReferences).parseChain();
+				c.push(p);
+			}
+			return this.createInterpolationAst(a.map((e) => e.text), c, e, h(t), n, i);
+		}
+		parseInterpolationExpression(e, t, n) {
+			let { stripped: r } = this._stripComments(e), i = this._lexer.tokenize(r), a = [], o = new X(e, t, n, i, 0, a, 0, this._supportsDirectPipeReferences).parseChain();
+			return this.createInterpolationAst(["", ""], [o], e, h(t), n, a);
+		}
+		createInterpolationAst(e, t, n, r, i, a) {
+			let o = new T(0, n.length);
+			return new j(new Dt(o, o.toAbsolute(i), e, t), n, r, i, a);
+		}
+		splitInterpolation(e, t, n, r) {
+			let i = [], a = [], o = [], s = r ? me(r) : null, c = 0, l = !1, ee = !1;
+			for (; c < e.length;) if (l) {
+				let r = c, i = r + 2, u = this._getInterpolationEndIndex(e, "}}", i);
+				if (u === -1) {
+					l = !1, ee = !0;
+					break;
+				}
+				let d = u + 2, f = e.substring(i, u);
+				f.trim().length === 0 && n.push(g("Blank expressions are not allowed in interpolated strings", e, `at column ${c} in`, t)), a.push({
+					text: f,
+					start: r,
+					end: d
+				});
+				let p = (s?.get(r) ?? r) + 2;
+				o.push(p), c = d, l = !1;
+			} else {
+				let t = c;
+				c = e.indexOf("{{", c), c === -1 && (c = e.length);
+				let n = e.substring(t, c);
+				i.push({
+					text: n,
+					start: t,
+					end: c
+				}), l = !0;
+			}
+			if (!l) if (ee) {
+				let t = i[i.length - 1];
+				t.text += e.substring(c), t.end = e.length;
+			} else i.push({
+				text: e.substring(c),
+				start: c,
+				end: e.length
+			});
+			return new br(i, a, o);
+		}
+		wrapLiteralPrimitive(e, t, n) {
+			let r = new T(0, e == null ? 0 : e.length);
+			return new j(new O(r, r.toAbsolute(n), e), e, typeof t == "string" ? t : h(t), n, []);
+		}
+		_stripComments(e) {
+			let t = this._commentStart(e);
+			return t == null ? {
+				stripped: e,
+				hasComments: !1
+			} : {
+				stripped: e.substring(0, t),
+				hasComments: !0
+			};
+		}
+		_commentStart(e) {
+			let t = null;
+			for (let n = 0; n < e.length - 1; n++) {
+				let r = e.charCodeAt(n), i = e.charCodeAt(n + 1);
+				if (r === ln && i == ln && t == null) return n;
+				t === r ? t = null : t == null && f(r) && (t = r);
+			}
+			return null;
+		}
+		_checkNoInterpolation(e, t, n) {
+			let r = -1, i = -1;
+			for (let e of this._forEachUnquotedChar(t, 0)) if (r === -1) t.startsWith("{{") && (r = e);
+			else if (i = this._getInterpolationEndIndex(t, "}}", e), i > -1) break;
+			r > -1 && i > -1 && e.push(g("Got interpolation ({{}}) where expression was expected", t, `at column ${r} in`, n));
+		}
+		_getInterpolationEndIndex(e, t, n) {
+			for (let r of this._forEachUnquotedChar(e, n)) {
+				if (e.startsWith(t, r)) return r;
+				if (e.startsWith("//", r)) return e.indexOf(t, r);
+			}
+			return -1;
+		}
+		*_forEachUnquotedChar(e, t) {
+			let n = null, r = 0;
+			for (let i = t; i < e.length; i++) {
+				let t = e[i];
+				f(e.charCodeAt(i)) && (n === null || n === t) && r % 2 == 0 ? n = n === null ? t : null : n === null && (yield i), r = t === "\\" ? r + 1 : 0;
+			}
+		}
+	}, (function(e) {
+		e[e.None = 0] = "None", e[e.Writable = 1] = "Writable";
+	})(Cr ||= {}), wr = new Set([
+		"d",
+		"g",
+		"i",
+		"m",
+		"s",
+		"u",
+		"v",
+		"y"
+	]), X = class {
+		input;
+		parseSourceSpan;
+		absoluteOffset;
+		tokens;
+		parseFlags;
+		errors;
+		offset;
+		supportsDirectPipeReferences;
+		rparensExpected = 0;
+		rbracketsExpected = 0;
+		rbracesExpected = 0;
+		context = Cr.None;
+		sourceSpanCache = /* @__PURE__ */ new Map();
+		index = 0;
+		constructor(e, t, n, r, i, a, o, s) {
+			this.input = e, this.parseSourceSpan = t, this.absoluteOffset = n, this.tokens = r, this.parseFlags = i, this.errors = a, this.offset = o, this.supportsDirectPipeReferences = s;
+		}
+		peek(e) {
+			let t = this.index + e;
+			return t < this.tokens.length ? this.tokens[t] : vr;
+		}
+		get next() {
+			return this.peek(0);
+		}
+		get atEOF() {
+			return this.index >= this.tokens.length;
+		}
+		get inputIndex() {
+			return this.atEOF ? this.currentEndIndex : this.next.index + this.offset;
+		}
+		get currentEndIndex() {
+			return this.index > 0 ? this.peek(-1).end + this.offset : this.tokens.length === 0 ? this.input.length + this.offset : this.next.index + this.offset;
+		}
+		get currentAbsoluteOffset() {
+			return this.absoluteOffset + this.inputIndex;
+		}
+		span(e, t) {
+			let n = this.currentEndIndex;
+			if (t !== void 0 && t > this.currentEndIndex && (n = t), e > n) {
+				let t = n;
+				n = e, e = t;
+			}
+			return new T(e, n);
+		}
+		sourceSpan(e, t) {
+			let n = `${e}@${this.inputIndex}:${t}`;
+			return this.sourceSpanCache.has(n) || this.sourceSpanCache.set(n, this.span(e, t).toAbsolute(this.absoluteOffset)), this.sourceSpanCache.get(n);
+		}
+		advance() {
+			this.index++;
+		}
+		withContext(e, t) {
+			this.context |= e;
+			let n = t();
+			return this.context ^= e, n;
+		}
+		consumeOptionalCharacter(e) {
+			return this.next.isCharacter(e) ? (this.advance(), !0) : !1;
+		}
+		peekKeywordLet() {
+			return this.next.isKeywordLet();
+		}
+		peekKeywordAs() {
+			return this.next.isKeywordAs();
+		}
+		expectCharacter(e) {
+			this.consumeOptionalCharacter(e) || this.error(`Missing expected ${String.fromCharCode(e)}`);
+		}
+		consumeOptionalOperator(e) {
+			return this.next.isOperator(e) ? (this.advance(), !0) : !1;
+		}
+		isAssignmentOperator(e) {
+			return e.type === q.Operator && k.isAssignmentOperation(e.strValue);
+		}
+		expectOperator(e) {
+			this.consumeOptionalOperator(e) || this.error(`Missing expected operator ${e}`);
+		}
+		prettyPrintToken(e) {
+			return e === vr ? "end of input" : `token ${e}`;
+		}
+		expectIdentifierOrKeyword() {
+			let e = this.next;
+			return !e.isIdentifier() && !e.isKeyword() ? (e.isPrivateIdentifier() ? this._reportErrorForPrivateIdentifier(e, "expected identifier or keyword") : this.error(`Unexpected ${this.prettyPrintToken(e)}, expected identifier or keyword`), null) : (this.advance(), e.toString());
+		}
+		expectIdentifierOrKeywordOrString() {
+			let e = this.next;
+			return !e.isIdentifier() && !e.isKeyword() && !e.isString() ? (e.isPrivateIdentifier() ? this._reportErrorForPrivateIdentifier(e, "expected identifier, keyword or string") : this.error(`Unexpected ${this.prettyPrintToken(e)}, expected identifier, keyword, or string`), "") : (this.advance(), e.toString());
+		}
+		parseChain() {
+			let e = [], t = this.inputIndex;
+			for (; this.index < this.tokens.length;) {
+				let t = this.parsePipe();
+				if (e.push(t), this.consumeOptionalCharacter(z)) for (this.parseFlags & 1 || this.error("Binding expression cannot contain chained expression"); this.consumeOptionalCharacter(z););
+				else if (this.index < this.tokens.length) {
+					let e = this.index;
+					if (this.error(`Unexpected token '${this.next}'`), this.index === e) break;
+				}
+			}
+			if (e.length === 0) {
+				let e = this.offset, t = this.offset + this.input.length;
+				return new D(this.span(e, t), this.sourceSpan(e, t));
+			}
+			return e.length == 1 ? e[0] : new gt(this.span(t), this.sourceSpan(t), e);
+		}
+		parsePipe() {
+			let e = this.inputIndex, t = this.parseExpression();
+			if (this.consumeOptionalOperator("|")) {
+				this.parseFlags & 1 && this.error("Cannot have a pipe in an action expression");
+				do {
+					let n = this.inputIndex, r = this.expectIdentifierOrKeyword(), i, a;
+					r === null ? (r = "", a = this.next.index === -1 ? this.input.length + this.offset : this.next.index, i = new T(a, a).toAbsolute(this.absoluteOffset)) : i = this.sourceSpan(n);
+					let o = [];
+					for (; this.consumeOptionalCharacter(R);) o.push(this.parseExpression());
+					let s;
+					if (this.supportsDirectPipeReferences) {
+						let e = r.charCodeAt(0);
+						s = e === bn || e >= hn && e <= _n ? St.ReferencedDirectly : St.ReferencedByName;
+					} else s = St.ReferencedByName;
+					t = new Ct(this.span(e), this.sourceSpan(e, a), t, r, o, s, i);
+				} while (this.consumeOptionalOperator("|"));
+			}
+			return t;
+		}
+		parseExpression() {
+			return this.parseConditional();
+		}
+		parseConditional() {
+			let e = this.inputIndex, t = this.parseLogicalOr();
+			if (this.consumeOptionalOperator("?")) {
+				let n = this.parsePipe(), r;
+				if (this.consumeOptionalCharacter(R)) r = this.parsePipe();
+				else {
+					let t = this.inputIndex, n = this.input.substring(e, t);
+					this.error(`Conditional expression ${n} requires all 3 expressions`), r = new D(this.span(e), this.sourceSpan(e));
+				}
+				return new _t(this.span(e), this.sourceSpan(e), t, n, r);
+			} else return t;
+		}
+		parseLogicalOr() {
+			let e = this.inputIndex, t = this.parseLogicalAnd();
+			for (; this.consumeOptionalOperator("||");) {
+				let n = this.parseLogicalAnd();
+				t = new k(this.span(e), this.sourceSpan(e), "||", t, n);
+			}
+			return t;
+		}
+		parseLogicalAnd() {
+			let e = this.inputIndex, t = this.parseNullishCoalescing();
+			for (; this.consumeOptionalOperator("&&");) {
+				let n = this.parseNullishCoalescing();
+				t = new k(this.span(e), this.sourceSpan(e), "&&", t, n);
+			}
+			return t;
+		}
+		parseNullishCoalescing() {
+			let e = this.inputIndex, t = this.parseEquality();
+			for (; this.consumeOptionalOperator("??");) {
+				let n = this.parseEquality();
+				t = new k(this.span(e), this.sourceSpan(e), "??", t, n);
+			}
+			return t;
+		}
+		parseEquality() {
+			let e = this.inputIndex, t = this.parseRelational();
+			for (; this.next.type == q.Operator;) {
+				let n = this.next.strValue;
+				switch (n) {
+					case "==":
+					case "===":
+					case "!=":
+					case "!==":
+						this.advance();
+						let r = this.parseRelational();
+						t = new k(this.span(e), this.sourceSpan(e), n, t, r);
+						continue;
+				}
+				break;
+			}
+			return t;
+		}
+		parseRelational() {
+			let e = this.inputIndex, t = this.parseAdditive();
+			for (; this.next.type == q.Operator || this.next.isKeywordIn;) {
+				let n = this.next.strValue;
+				switch (n) {
+					case "<":
+					case ">":
+					case "<=":
+					case ">=":
+					case "in":
+						this.advance();
+						let r = this.parseAdditive();
+						t = new k(this.span(e), this.sourceSpan(e), n, t, r);
+						continue;
+				}
+				break;
+			}
+			return t;
+		}
+		parseAdditive() {
+			let e = this.inputIndex, t = this.parseMultiplicative();
+			for (; this.next.type == q.Operator;) {
+				let n = this.next.strValue;
+				switch (n) {
+					case "+":
+					case "-":
+						this.advance();
+						let r = this.parseMultiplicative();
+						t = new k(this.span(e), this.sourceSpan(e), n, t, r);
+						continue;
+				}
+				break;
+			}
+			return t;
+		}
+		parseMultiplicative() {
+			let e = this.inputIndex, t = this.parseExponentiation();
+			for (; this.next.type == q.Operator;) {
+				let n = this.next.strValue;
+				switch (n) {
+					case "*":
+					case "%":
+					case "/":
+						this.advance();
+						let r = this.parseExponentiation();
+						t = new k(this.span(e), this.sourceSpan(e), n, t, r);
+						continue;
+				}
+				break;
+			}
+			return t;
+		}
+		parseExponentiation() {
+			let e = this.inputIndex, t = this.parsePrefix();
+			for (; this.next.type == q.Operator && this.next.strValue === "**";) {
+				(t instanceof Ot || t instanceof kt || t instanceof At || t instanceof jt) && this.error("Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence"), this.advance();
+				let n = this.parseExponentiation();
+				t = new k(this.span(e), this.sourceSpan(e), "**", t, n);
+			}
+			return t;
+		}
+		parsePrefix() {
+			if (this.next.type == q.Operator) {
+				let e = this.inputIndex, t = this.next.strValue, n;
+				switch (t) {
+					case "+": return this.advance(), n = this.parsePrefix(), Ot.createPlus(this.span(e), this.sourceSpan(e), n);
+					case "-": return this.advance(), n = this.parsePrefix(), Ot.createMinus(this.span(e), this.sourceSpan(e), n);
+					case "!": return this.advance(), n = this.parsePrefix(), new kt(this.span(e), this.sourceSpan(e), n);
+				}
+			} else if (this.next.isKeywordTypeof()) {
+				let e = this.inputIndex;
+				this.advance();
+				let t = this.parsePrefix();
+				return new At(this.span(e), this.sourceSpan(e), t);
+			} else if (this.next.isKeywordVoid()) {
+				let e = this.inputIndex;
+				this.advance();
+				let t = this.parsePrefix();
+				return new jt(this.span(e), this.sourceSpan(e), t);
+			}
+			return this.parseCallChain();
+		}
+		parseCallChain() {
+			let e = this.inputIndex, t = this.parsePrimary();
+			for (;;) if (this.consumeOptionalCharacter(L)) t = this.parseAccessMember(t, e, !1);
+			else if (this.consumeOptionalOperator("?.")) t = this.consumeOptionalCharacter(P) ? this.parseCall(t, e, !0) : this.consumeOptionalCharacter(V) ? this.parseKeyedReadOrWrite(t, e, !0) : this.parseAccessMember(t, e, !0);
+			else if (this.consumeOptionalCharacter(V)) t = this.parseKeyedReadOrWrite(t, e, !1);
+			else if (this.consumeOptionalCharacter(P)) t = this.parseCall(t, e, !1);
+			else if (this.consumeOptionalOperator("!")) t = new Mt(this.span(e), this.sourceSpan(e), t);
+			else if (this.next.isTemplateLiteralEnd()) t = this.parseNoInterpolationTaggedTemplateLiteral(t, e);
+			else if (this.next.isTemplateLiteralPart()) t = this.parseTaggedTemplateLiteral(t, e);
+			else return t;
+		}
+		parsePrimary() {
+			let e = this.inputIndex;
+			if (this.consumeOptionalCharacter(P)) {
+				this.rparensExpected++;
+				let t = this.parsePipe();
+				return this.consumeOptionalCharacter(F) || (this.error("Missing closing parentheses"), this.consumeOptionalCharacter(F)), this.rparensExpected--, new Rt(this.span(e), this.sourceSpan(e), t);
+			} else {
+				if (this.next.isKeywordNull()) return this.advance(), new O(this.span(e), this.sourceSpan(e), null);
+				if (this.next.isKeywordUndefined()) return this.advance(), new O(this.span(e), this.sourceSpan(e), void 0);
+				if (this.next.isKeywordTrue()) return this.advance(), new O(this.span(e), this.sourceSpan(e), !0);
+				if (this.next.isKeywordFalse()) return this.advance(), new O(this.span(e), this.sourceSpan(e), !1);
+				if (this.next.isKeywordIn()) return this.advance(), new O(this.span(e), this.sourceSpan(e), "in");
+				if (this.next.isKeywordThis()) return this.advance(), new ht(this.span(e), this.sourceSpan(e));
+				if (this.consumeOptionalCharacter(V)) return this.parseLiteralArray(e);
+				if (this.next.isCharacter(An)) return this.parseLiteralMap();
+				if (this.next.isIdentifier()) return this.parseAccessMember(new mt(this.span(e), this.sourceSpan(e)), e, !1);
+				if (this.next.isNumber()) {
+					let t = this.next.toNumber();
+					return this.advance(), new O(this.span(e), this.sourceSpan(e), t);
+				} else {
+					if (this.next.isTemplateLiteralEnd()) return this.parseNoInterpolationTemplateLiteral();
+					if (this.next.isTemplateLiteralPart()) return this.parseTemplateLiteral();
+					if (this.next.isString() && this.next.kind === J.Plain) {
+						let t = this.next.toString();
+						return this.advance(), new O(this.span(e), this.sourceSpan(e), t);
+					} else return this.next.isPrivateIdentifier() ? (this._reportErrorForPrivateIdentifier(this.next, null), new D(this.span(e), this.sourceSpan(e))) : this.next.isRegExpBody() ? this.parseRegularExpressionLiteral() : this.index >= this.tokens.length ? (this.error(`Unexpected end of expression: ${this.input}`), new D(this.span(e), this.sourceSpan(e))) : (this.error(`Unexpected token ${this.next}`), new D(this.span(e), this.sourceSpan(e)));
+				}
+			}
+		}
+		parseLiteralArray(e) {
+			this.rbracketsExpected++;
+			let t = [];
+			do
+				if (this.next.isOperator("...")) t.push(this.parseSpreadElement());
+				else if (!this.next.isCharacter(H)) t.push(this.parsePipe());
+				else break;
+			while (this.consumeOptionalCharacter(I));
+			return this.rbracketsExpected--, this.expectCharacter(H), new wt(this.span(e), this.sourceSpan(e), t);
+		}
+		parseLiteralMap() {
+			let e = [], t = [], n = this.inputIndex;
+			if (this.expectCharacter(An), !this.consumeOptionalCharacter(U)) {
+				this.rbracesExpected++;
+				do {
+					let n = this.inputIndex;
+					if (this.next.isOperator("...")) {
+						this.advance(), e.push({
+							kind: "spread",
+							span: this.span(n),
+							sourceSpan: this.sourceSpan(n)
+						}), t.push(this.parsePipe());
+						continue;
+					}
+					let r = this.next.isString(), i = this.expectIdentifierOrKeywordOrString(), a = this.span(n), o = this.sourceSpan(n), s = {
+						kind: "property",
+						key: i,
+						quoted: r,
+						span: a,
+						sourceSpan: o
+					};
+					e.push(s), r ? (this.expectCharacter(R), t.push(this.parsePipe())) : this.consumeOptionalCharacter(R) ? t.push(this.parsePipe()) : (s.isShorthandInitialized = !0, t.push(new vt(a, o, o, new mt(a, o), i)));
+				} while (this.consumeOptionalCharacter(I) && !this.next.isCharacter(U));
+				this.rbracesExpected--, this.expectCharacter(U);
+			}
+			return new Et(this.span(n), this.sourceSpan(n), e, t);
+		}
+		parseAccessMember(e, t, n) {
+			let r = this.inputIndex, i = this.withContext(Cr.Writable, () => {
+				let t = this.expectIdentifierOrKeyword() ?? "";
+				return t.length === 0 && this.error("Expected identifier for property access", e.span.end), t;
+			}), a = this.sourceSpan(r);
+			if (n) return this.isAssignmentOperator(this.next) ? (this.advance(), this.error("The '?.' operator cannot be used in the assignment"), new D(this.span(t), this.sourceSpan(t))) : new yt(this.span(t), this.sourceSpan(t), a, e, i);
+			if (this.isAssignmentOperator(this.next)) {
+				let n = this.next.strValue;
+				if (!(this.parseFlags & 1)) return this.advance(), this.error("Bindings cannot contain assignments"), new D(this.span(t), this.sourceSpan(t));
+				let r = new vt(this.span(t), this.sourceSpan(t), a, e, i);
+				this.advance();
+				let o = this.parseConditional();
+				return new k(this.span(t), this.sourceSpan(t), n, r, o);
+			} else return new vt(this.span(t), this.sourceSpan(t), a, e, i);
+		}
+		parseCall(e, t, n) {
+			let r = this.inputIndex;
+			this.rparensExpected++;
+			let i = this.parseCallArguments(), a = this.span(r, this.inputIndex).toAbsolute(this.absoluteOffset);
+			this.expectCharacter(F), this.rparensExpected--;
+			let o = this.span(t), s = this.sourceSpan(t);
+			return n ? new Pt(o, s, e, i, a) : new Nt(o, s, e, i, a);
+		}
+		parseCallArguments() {
+			if (this.next.isCharacter(F)) return [];
+			let e = [];
+			do
+				e.push(this.next.isOperator("...") ? this.parseSpreadElement() : this.parsePipe());
+			while (this.consumeOptionalCharacter(I));
+			return e;
+		}
+		parseSpreadElement() {
+			this.next.isOperator("...") || this.error("Spread element must start with '...' operator");
+			let e = this.inputIndex;
+			this.advance();
+			let t = this.parsePipe();
+			return new Tt(this.span(e), this.sourceSpan(e), t);
+		}
+		expectTemplateBindingKey() {
+			let e = "", t = !1, n = this.currentAbsoluteOffset;
+			do
+				e += this.expectIdentifierOrKeywordOrString(), t = this.consumeOptionalOperator("-"), t && (e += "-");
+			while (t);
+			return {
+				source: e,
+				span: new A(n, n + e.length)
+			};
+		}
+		parseTemplateBindings(e) {
+			let t = [];
+			for (t.push(...this.parseDirectiveKeywordBindings(e)); this.index < this.tokens.length;) {
+				let n = this.parseLetBinding();
+				if (n) t.push(n);
+				else {
+					let n = this.expectTemplateBindingKey(), r = this.parseAsBinding(n);
+					r ? t.push(r) : (n.source = e.source + n.source.charAt(0).toUpperCase() + n.source.substring(1), t.push(...this.parseDirectiveKeywordBindings(n)));
+				}
+				this.consumeStatementTerminator();
+			}
+			return new xr(t, [], this.errors);
+		}
+		parseKeyedReadOrWrite(e, t, n) {
+			return this.withContext(Cr.Writable, () => {
+				this.rbracketsExpected++;
+				let r = this.parsePipe();
+				if (r instanceof D && this.error("Key access cannot be empty"), this.rbracketsExpected--, this.expectCharacter(H), this.isAssignmentOperator(this.next)) {
+					let i = this.next.strValue;
+					if (n) this.advance(), this.error("The '?.' operator cannot be used in the assignment");
+					else {
+						let n = new bt(this.span(t), this.sourceSpan(t), e, r);
+						this.advance();
+						let a = this.parseConditional();
+						return new k(this.span(t), this.sourceSpan(t), i, n, a);
+					}
+				} else return n ? new xt(this.span(t), this.sourceSpan(t), e, r) : new bt(this.span(t), this.sourceSpan(t), e, r);
+				return new D(this.span(t), this.sourceSpan(t));
+			});
+		}
+		parseDirectiveKeywordBindings(e) {
+			let t = [];
+			this.consumeOptionalCharacter(R);
+			let n = this.getDirectiveBoundTarget(), r = this.currentAbsoluteOffset, i = this.parseAsBinding(e);
+			i || (this.consumeStatementTerminator(), r = this.currentAbsoluteOffset);
+			let a = new A(e.span.start, r);
+			return t.push(new Vt(a, e, n)), i && t.push(i), t;
+		}
+		getDirectiveBoundTarget() {
+			if (this.next === vr || this.peekKeywordAs() || this.peekKeywordLet()) return null;
+			let e = this.parsePipe(), { start: t, end: n } = e.span;
+			return new j(e, this.input.substring(t, n), h(this.parseSourceSpan), this.absoluteOffset + t, this.errors);
+		}
+		parseAsBinding(e) {
+			if (!this.peekKeywordAs()) return null;
+			this.advance();
+			let t = this.expectTemplateBindingKey();
+			return this.consumeStatementTerminator(), new Bt(new A(e.span.start, this.currentAbsoluteOffset), t, e);
+		}
+		parseLetBinding() {
+			if (!this.peekKeywordLet()) return null;
+			let e = this.currentAbsoluteOffset;
+			this.advance();
+			let t = this.expectTemplateBindingKey(), n = null;
+			return this.consumeOptionalOperator("=") && (n = this.expectTemplateBindingKey()), this.consumeStatementTerminator(), new Bt(new A(e, this.currentAbsoluteOffset), t, n);
+		}
+		parseNoInterpolationTaggedTemplateLiteral(e, t) {
+			let n = this.parseNoInterpolationTemplateLiteral();
+			return new Ft(this.span(t), this.sourceSpan(t), e, n);
+		}
+		parseNoInterpolationTemplateLiteral() {
+			let e = this.next.strValue, t = this.inputIndex;
+			this.advance();
+			let n = this.span(t), r = this.sourceSpan(t);
+			return new It(n, r, [new Lt(n, r, e)], []);
+		}
+		parseTaggedTemplateLiteral(e, t) {
+			let n = this.parseTemplateLiteral();
+			return new Ft(this.span(t), this.sourceSpan(t), e, n);
+		}
+		parseTemplateLiteral() {
+			let e = [], t = [], n = this.inputIndex;
+			for (; this.next !== vr;) {
+				let n = this.next;
+				if (n.isTemplateLiteralPart() || n.isTemplateLiteralEnd()) {
+					let t = this.inputIndex;
+					if (this.advance(), e.push(new Lt(this.span(t), this.sourceSpan(t), n.strValue)), n.isTemplateLiteralEnd()) break;
+				} else if (n.isTemplateLiteralInterpolationStart()) {
+					this.advance(), this.rbracesExpected++;
+					let e = this.parsePipe();
+					e instanceof D ? this.error("Template literal interpolation cannot be empty") : t.push(e), this.rbracesExpected--;
+				} else this.advance();
+			}
+			return new It(this.span(n), this.sourceSpan(n), e, t);
+		}
+		parseRegularExpressionLiteral() {
+			let e = this.next;
+			if (this.advance(), !e.isRegExpBody()) return new D(this.span(this.inputIndex), this.sourceSpan(this.inputIndex));
+			let t = null;
+			if (this.next.isRegExpFlags()) {
+				t = this.next, this.advance();
+				let e = /* @__PURE__ */ new Set();
+				for (let n = 0; n < t.strValue.length; n++) {
+					let r = t.strValue[n];
+					wr.has(r) ? e.has(r) ? this.error(`Duplicate regular expression flag "${r}"`, t.index + n) : e.add(r) : this.error(`Unsupported regular expression flag "${r}". The supported flags are: ` + Array.from(wr, (e) => `"${e}"`).join(", "), t.index + n);
+				}
+			}
+			let n = e.index, r = t ? t.end : e.end;
+			return new zt(this.span(n, r), this.sourceSpan(n, r), e.strValue, t ? t.strValue : null);
+		}
+		consumeStatementTerminator() {
+			this.consumeOptionalCharacter(z) || this.consumeOptionalCharacter(I);
+		}
+		error(e, t = this.index) {
+			this.errors.push(g(e, this.input, this.getErrorLocationText(t), this.parseSourceSpan)), this.skip();
+		}
+		getErrorLocationText(e) {
+			return e < this.tokens.length ? `at column ${this.tokens[e].index + 1} in` : "at the end of the expression";
+		}
+		_reportErrorForPrivateIdentifier(e, t) {
+			let n = `Private identifiers are not supported. Unexpected private identifier: ${e}`;
+			t !== null && (n += `, ${t}`), this.error(n);
+		}
+		skip() {
+			let e = this.next;
+			for (; this.index < this.tokens.length && !e.isCharacter(z) && !e.isOperator("|") && (this.rparensExpected <= 0 || !e.isCharacter(F)) && (this.rbracesExpected <= 0 || !e.isCharacter(U)) && (this.rbracketsExpected <= 0 || !e.isCharacter(H)) && (!(this.context & Cr.Writable) || !this.isAssignmentOperator(e));) this.next.isError() && this.errors.push(g(this.next.toString(), this.input, this.getErrorLocationText(this.next.index), this.parseSourceSpan)), this.advance(), e = this.next;
+		}
+	}, Tr = class extends Ht {
+		errors = [];
+		visitPipe() {
+			this.errors.push("pipes");
+		}
+	}, Er = new Map(Object.entries({
+		class: "className",
+		for: "htmlFor",
+		formaction: "formAction",
+		innerHtml: "innerHTML",
+		readonly: "readOnly",
+		tabindex: "tabIndex",
+		"aria-activedescendant": "ariaActiveDescendantElement",
+		"aria-atomic": "ariaAtomic",
+		"aria-autocomplete": "ariaAutoComplete",
+		"aria-busy": "ariaBusy",
+		"aria-checked": "ariaChecked",
+		"aria-colcount": "ariaColCount",
+		"aria-colindex": "ariaColIndex",
+		"aria-colindextext": "ariaColIndexText",
+		"aria-colspan": "ariaColSpan",
+		"aria-controls": "ariaControlsElements",
+		"aria-current": "ariaCurrent",
+		"aria-describedby": "ariaDescribedByElements",
+		"aria-description": "ariaDescription",
+		"aria-details": "ariaDetailsElements",
+		"aria-disabled": "ariaDisabled",
+		"aria-errormessage": "ariaErrorMessageElements",
+		"aria-expanded": "ariaExpanded",
+		"aria-flowto": "ariaFlowToElements",
+		"aria-haspopup": "ariaHasPopup",
+		"aria-hidden": "ariaHidden",
+		"aria-invalid": "ariaInvalid",
+		"aria-keyshortcuts": "ariaKeyShortcuts",
+		"aria-label": "ariaLabel",
+		"aria-labelledby": "ariaLabelledByElements",
+		"aria-level": "ariaLevel",
+		"aria-live": "ariaLive",
+		"aria-modal": "ariaModal",
+		"aria-multiline": "ariaMultiLine",
+		"aria-multiselectable": "ariaMultiSelectable",
+		"aria-orientation": "ariaOrientation",
+		"aria-owns": "ariaOwnsElements",
+		"aria-placeholder": "ariaPlaceholder",
+		"aria-posinset": "ariaPosInSet",
+		"aria-pressed": "ariaPressed",
+		"aria-readonly": "ariaReadOnly",
+		"aria-required": "ariaRequired",
+		"aria-roledescription": "ariaRoleDescription",
+		"aria-rowcount": "ariaRowCount",
+		"aria-rowindex": "ariaRowIndex",
+		"aria-rowindextext": "ariaRowIndexText",
+		"aria-rowspan": "ariaRowSpan",
+		"aria-selected": "ariaSelected",
+		"aria-setsize": "ariaSetSize",
+		"aria-sort": "ariaSort",
+		"aria-valuemax": "ariaValueMax",
+		"aria-valuemin": "ariaValueMin",
+		"aria-valuenow": "ariaValueNow",
+		"aria-valuetext": "ariaValueText"
+	})), Array.from(Er).reduce((e, [t, n]) => (e.set(t, n), e), /* @__PURE__ */ new Map()), new Sr(new gr()), W.StyleMap, W.ClassMap, W.StyleProp, W.ClassProp, W.Attribute, W.Property, W.Attribute, W.Control, W.DomProperty, W.DomProperty, W.Attribute, W.StyleMap, W.ClassMap, W.StyleProp, W.ClassProp, new Set([
+		W.Listener,
+		W.TwoWayListener,
+		W.AnimationListener,
+		W.StyleMap,
+		W.ClassMap,
+		W.StyleProp,
+		W.ClassProp,
+		W.Property,
+		W.TwoWayProperty,
+		W.DomProperty,
+		W.Attribute,
+		W.Animation,
+		W.Control
+	]), new Map([
+		[K.Idle, {
+			none: w.deferOnIdle,
+			prefetch: w.deferPrefetchOnIdle,
+			hydrate: w.deferHydrateOnIdle
+		}],
+		[K.Immediate, {
+			none: w.deferOnImmediate,
+			prefetch: w.deferPrefetchOnImmediate,
+			hydrate: w.deferHydrateOnImmediate
+		}],
+		[K.Timer, {
+			none: w.deferOnTimer,
+			prefetch: w.deferPrefetchOnTimer,
+			hydrate: w.deferHydrateOnTimer
+		}],
+		[K.Hover, {
+			none: w.deferOnHover,
+			prefetch: w.deferPrefetchOnHover,
+			hydrate: w.deferHydrateOnHover
+		}],
+		[K.Interaction, {
+			none: w.deferOnInteraction,
+			prefetch: w.deferPrefetchOnInteraction,
+			hydrate: w.deferHydrateOnInteraction
+		}],
+		[K.Viewport, {
+			none: w.deferOnViewport,
+			prefetch: w.deferPrefetchOnViewport,
+			hydrate: w.deferHydrateOnViewport
+		}],
+		[K.Never, {
+			none: w.deferHydrateNever,
+			prefetch: w.deferHydrateNever,
+			hydrate: w.deferHydrateNever
+		}]
+	]), w.pipeBind1, w.pipeBind2, w.pipeBind3, w.pipeBind4, w.interpolate, w.interpolate1, w.interpolate2, w.interpolate3, w.interpolate4, w.interpolate5, w.interpolate6, w.interpolate7, w.interpolate8, w.interpolateV, new Map([
+		["window", w.resolveWindow],
+		["document", w.resolveDocument],
+		["body", w.resolveBody]
+	]), new Map([
+		[y.HTML, w.sanitizeHtml],
+		[y.RESOURCE_URL, w.sanitizeResourceUrl],
+		[y.SCRIPT, w.sanitizeScript],
+		[y.STYLE, w.sanitizeStyle],
+		[y.URL, w.sanitizeUrl],
+		[y.ATTRIBUTE_NO_BINDING, w.validateAttribute]
+	]), new Map([[y.HTML, w.trustConstantHtml], [y.RESOURCE_URL, w.trustConstantResourceUrl]]), (function(e) {
+		e[e.None = 0] = "None", e[e.ViewContextRead = 1] = "ViewContextRead", e[e.ViewContextWrite = 2] = "ViewContextWrite", e[e.SideEffectful = 4] = "SideEffectful";
+	})(Dr ||= {}), new Map([
+		[M.Property, G.Property],
+		[M.TwoWay, G.TwoWayProperty],
+		[M.Attribute, G.Attribute],
+		[M.Class, G.ClassName],
+		[M.Style, G.StyleProperty],
+		[M.LegacyAnimation, G.LegacyAnimation],
+		[M.Animation, G.Animation]
+	]), (function(e) {
+		e[e.NG_CONTENT = 0] = "NG_CONTENT", e[e.STYLE = 1] = "STYLE", e[e.STYLESHEET = 2] = "STYLESHEET", e[e.SCRIPT = 3] = "SCRIPT", e[e.OTHER = 4] = "OTHER";
+	})(Or ||= {}), (function(e) {
+		e.IDLE = "idle", e.TIMER = "timer", e.INTERACTION = "interaction", e.IMMEDIATE = "immediate", e.HOVER = "hover", e.VIEWPORT = "viewport", e.NEVER = "never";
+	})(kr ||= {}), Ar = "%COMP%", `${Ar}`, `${Ar}`, (function(e) {
+		e[e.Extract = 0] = "Extract", e[e.Merge = 1] = "Merge";
+	})(jr ||= {}), new dt("21.1.0"), Mr = "test.html", Pr = (e) => Sr.prototype._commentStart(e), Fr = (e) => (t) => {
+		let n = he(t);
+		return ve({
+			...n,
+			result: ge()[e](t, n.sourceSpan, 0),
+			comments: _e(t)
+		});
+	}, Ir = Fr("parseAction"), Lr = Fr("parseBinding"), Rr = Fr("parseSimpleBinding"), zr = Fr("parseInterpolationExpression"), Br = (e) => {
+		let t = he(e);
+		return ve({
+			...t,
+			result: ge().parseTemplateBindings("", e, t.sourceSpan, 0, 0),
+			comments: []
+		});
+	}, Vr = class {
+		text;
+		constructor(e) {
+			this.text = e;
+		}
+		getCharacterIndex(e, t) {
+			return n(this.text, e, t);
+		}
+		transformSpan(e) {
+			return i(e);
+		}
+		createNode(e, t) {
+			let n = e.start, r = e.end, i = e.range;
+			if (t && (Array.isArray(t) ? ([n, r] = t, i = t) : ({start: n, end: r} = t.sourceSpan ?? t, i = [n, r])), i ? [n, r] = i : typeof n == "number" && typeof r == "number" && (i = [n, r]), !(typeof n == "number" && typeof r == "number" && i)) throw Error("Missing location information");
+			let a = {
+				...e,
+				start: n,
+				end: r,
+				range: i
+			};
+			switch (a.type) {
+				case "NumericLiteral":
+				case "StringLiteral":
+				case "RegExpLiteral": {
+					let e = this.text.slice(n, r), { value: t } = a;
+					a.extra = {
+						...a.extra,
+						raw: e,
+						rawValue: t
+					};
+					break;
+				}
+			}
+			return a;
+		}
+	}, Hr = Object.defineProperty, Ur = (e, t) => {
+		let n = {};
+		for (var r in e) Hr(n, r, {
+			get: e[r],
+			enumerable: !0
+		});
+		return t && Hr(n, Symbol.toStringTag, { value: "Module" }), n;
+	}, Wr = (e, t) => ({
+		type: "ArrayExpression",
+		elements: t.transformChildren(e.expressions)
+	}), Gr = (e, t) => t.transformChild(e.ast), Kr = (e) => e === "&&" || e === "||" || e === "??", qr = (e, t) => {
+		let { operation: n } = e, [r, i] = t.transformChildren([e.left, e.right]);
+		return Kr(n) ? {
+			type: "LogicalExpression",
+			operator: n,
+			left: r,
+			right: i
+		} : k.isAssignmentOperation(n) ? {
+			type: "AssignmentExpression",
+			left: r,
+			right: i,
+			operator: n
+		} : {
+			left: r,
+			right: i,
+			type: "BinaryExpression",
+			operator: n
+		};
+	}, Jr = { optional: !1 }, Yr = { optional: !0 }, Xr = ({ optional: e }) => (t, n) => {
+		let r = n.transformChildren(t.args), i = n.transformChild(t.receiver);
+		return e || o(i) ? {
+			type: "OptionalCallExpression",
+			callee: i,
+			arguments: r,
+			optional: e
+		} : {
+			type: "CallExpression",
+			callee: i,
+			arguments: r
+		};
+	}, Zr = Xr(Jr), Qr = Xr(Yr), $r = (e, t) => ({
+		type: "NGChainedExpression",
+		expressions: t.transformChildren(e.expressions)
+	}), ei = (e, t) => {
+		let [n, r, i] = t.transformChildren([
+			e.condition,
+			e.trueExp,
+			e.falseExp
+		]);
+		return {
+			type: "ConditionalExpression",
+			test: n,
+			consequent: r,
+			alternate: i
+		};
+	}, ti = (e, t) => {
+		let { expressions: n } = e;
+		if (n.length !== 1) throw Error("Unexpected 'Interpolation'");
+		return t.transformChild(n[0]);
+	}, ni = (e) => {
+		let { value: t } = e;
+		switch (typeof t) {
+			case "boolean": return {
+				type: "BooleanLiteral",
+				value: t
+			};
+			case "number": return {
+				type: "NumericLiteral",
+				value: t
+			};
+			case "object": return { type: "NullLiteral" };
+			case "string": return {
+				type: "StringLiteral",
+				value: t
+			};
+			case "undefined": return {
+				type: "Identifier",
+				name: "undefined"
+			};
+			default: throw Error(`Unexpected 'LiteralPrimitive' value type ${typeof t}`);
+		}
+	}, ri = (e) => ({
+		type: "RegExpLiteral",
+		pattern: e.body,
+		flags: e.flags ?? ""
+	}), ii = {
+		computed: !0,
+		optional: !1
+	}, ai = {
+		computed: !0,
+		optional: !0
+	}, oi = {
+		computed: !1,
+		optional: !1
+	}, si = {
+		computed: !1,
+		optional: !0
+	}, ci = ({ computed: e, optional: t }) => (n, r) => {
+		let { receiver: i } = n, a;
+		if (e) {
+			let { key: e } = n;
+			a = r.transformChild(e);
+		} else {
+			let e = i instanceof mt, { name: t, nameSpan: o } = n;
+			if (a = r.create({
+				type: "Identifier",
+				name: t
+			}, o, e ? r.ancestors : []), e) return a;
+		}
+		let s = r.transformChild(i);
+		return t || o(s) ? {
+			type: "OptionalMemberExpression",
+			optional: t,
+			property: a,
+			object: s,
+			computed: e
+		} : {
+			type: "MemberExpression",
+			property: a,
+			object: s,
+			computed: e
+		};
+	}, li = ci(ii), ui = ci(ai), di = ci(oi), fi = ci(si), pi = (e, t) => ({
+		type: "TSNonNullExpression",
+		expression: t.transformChild(e.expression)
+	}), mi = (e, t) => {
+		let { keys: n, values: r } = e, i = (n, r = e) => t.create(n, r, [e, ...t.ancestors]);
+		return {
+			type: "ObjectExpression",
+			properties: n.map((e, n) => {
+				let a = r[n], o = [e.sourceSpan.start, a.sourceSpan.end];
+				if (e.kind === "spread") return i({
+					type: "SpreadElement",
+					argument: t.transformChild(a)
+				}, o);
+				let s = !!e.isShorthandInitialized;
+				return i({
+					type: "ObjectProperty",
+					key: i(e.quoted ? {
+						type: "StringLiteral",
+						value: e.key
+					} : {
+						type: "Identifier",
+						name: e.key
+					}, e.sourceSpan),
+					value: t.transformChild(a),
+					shorthand: s,
+					computed: !1,
+					method: !1
+				}, o);
+			})
+		};
+	}, hi = (e, t) => t.transformChild(e.expression), gi = (e, t) => ({
+		type: "NGPipeExpression",
+		left: t.transformChild(e.exp),
+		right: t.create({
+			type: "Identifier",
+			name: e.name
+		}, e.nameSpan),
+		arguments: t.transformChildren(e.args)
+	}), _i = (e, t) => ({
+		type: "SpreadElement",
+		argument: t.transformChild(e.expression)
+	}), vi = (e, t) => ({
+		type: "TaggedTemplateExpression",
+		tag: t.transformChild(e.tag),
+		quasi: t.transformChild(e.template)
+	}), yi = (e, t) => ({
+		type: "TemplateLiteral",
+		quasis: t.transformChildren(e.elements),
+		expressions: t.transformChildren(e.expressions)
+	}), bi = (e, t) => {
+		let [n] = t.ancestors, { elements: r } = n, i = r.indexOf(e), a = i === 0, o = i === r.length - 1, s = e.sourceSpan.end - (o ? 1 : 0), c = e.sourceSpan.start + (a ? 1 : 0), l = t.text.slice(c, s);
+		return {
+			type: "TemplateElement",
+			value: {
+				cooked: e.text,
+				raw: l
+			},
+			tail: o,
+			range: [c, s]
+		};
+	}, xi = () => ({ type: "ThisExpression" }), Si = (e) => (t, n) => ({
+		type: "UnaryExpression",
+		prefix: !0,
+		operator: e,
+		argument: n.transformChild(t.expression)
+	}), Ci = Si("!"), wi = Si("typeof"), Ti = Si("void"), Ei = (e, t) => ({
+		type: "UnaryExpression",
+		prefix: !0,
+		argument: t.transformChild(e.expr),
+		operator: e.operator
+	}), Di = (e) => {
+		throw Error(`Unexpected node type '${e.constructor.name}'`);
+	}, Oi = Di, ki = Ur({
+		visitASTWithSource: () => Gr,
+		visitBinary: () => qr,
+		visitCall: () => Zr,
+		visitChain: () => $r,
+		visitConditional: () => ei,
+		visitImplicitReceiver: () => Oi,
+		visitInterpolation: () => ti,
+		visitKeyedRead: () => li,
+		visitLiteralArray: () => Wr,
+		visitLiteralMap: () => mi,
+		visitLiteralPrimitive: () => ni,
+		visitNonNullAssert: () => pi,
+		visitParenthesizedExpression: () => hi,
+		visitPipe: () => gi,
+		visitPrefixNot: () => Ci,
+		visitPropertyRead: () => di,
+		visitRegularExpressionLiteral: () => ri,
+		visitSafeCall: () => Qr,
+		visitSafeKeyedRead: () => ui,
+		visitSafePropertyRead: () => fi,
+		visitSpreadElement: () => _i,
+		visitTaggedTemplateLiteral: () => vi,
+		visitTemplateLiteral: () => yi,
+		visitTemplateLiteralElement: () => bi,
+		visitThisReceiver: () => xi,
+		visitTypeofExpression: () => wi,
+		visitUnary: () => Ei,
+		visitVoidExpression: () => Ti
+	}), Ai = class e extends Vr {
+		node;
+		ancestors;
+		constructor({ node: e, text: t, ancestors: n = [] }) {
+			super(t), this.node = e, this.ancestors = n;
+		}
+		create(e, t, n = this.ancestors) {
+			return n[0] instanceof Rt && (e.extra = {
+				...e.extra,
+				parenthesized: !0
+			}), super.createNode(e, e.range ?? t ?? this.node);
+		}
+		transformChild(t) {
+			return new e({
+				node: t,
+				ancestors: [this.node, ...this.ancestors],
+				text: this.text
+			}).transform();
+		}
+		transformChildren(e) {
+			return e.map((e) => this.transformChild(e));
+		}
+		transform() {
+			let { node: e } = this;
+			if (e instanceof D) return this.create({ type: "NGEmptyExpression" });
+			let t = e.visit(ki, this);
+			return this.create(t, this.node);
+		}
+		static transform(t, n) {
+			return new e({
+				node: t,
+				text: n,
+				ancestors: []
+			}).transform();
+		}
+	}, ji = class extends Ai {
+		constructor(e) {
+			super({
+				node: e,
+				text: e.source
+			});
+		}
+	}, Mi = (e, t) => Ai.transform(e, t), Ni = (e) => new ji(e).transform(), Pi = (e, t) => (n, r, ...i) => n | 1 && r == null ? void 0 : (t.call(r) ?? r[e]).apply(r, i), Fi = Pi("at", function() {
+		if (Array.isArray(this) || typeof this == "string") return ye;
+	}), Ki = (Gi = class extends Vr {
+		constructor(e, t) {
+			super(t), Me(this, Q), Me(this, Ii), Me(this, Z), Ne(this, Ii, e), Ne(this, Z, t);
+			for (let t of e) v(this, Q, Vi).call(this, t);
+		}
+		get expressions() {
+			return v(this, Q, Ui).call(this);
+		}
+	}, Ii = /* @__PURE__ */ new WeakMap(), Z = /* @__PURE__ */ new WeakMap(), Q = /* @__PURE__ */ new WeakSet(), Li = function() {
+		return _(this, Ii)[0].key;
+	}, $ = function(e, t) {
+		return Pe(Gi.prototype, this, "createNode").call(this, e, t);
+	}, Ri = function(e) {
+		return Mi(e, this.text);
+	}, zi = function(e) {
+		return r(e.slice(_(this, Q, Li).source.length));
+	}, Bi = function(e) {
+		let t = _(this, Z);
+		if (t[e.start] !== "\"" && t[e.start] !== "'") return;
+		let n = t[e.start], r = !1;
+		for (let i = e.start + 1; i < t.length; i++) switch (t[i]) {
+			case n: if (!r) {
+				e.end = i + 1;
+				return;
+			}
+			default:
+				r = !1;
+				break;
+			case "\\":
+				r = !r;
+				break;
+		}
+	}, Vi = function(e) {
+		v(this, Q, Bi).call(this, e.key.span), xe(e) && e.value && v(this, Q, Bi).call(this, e.value.span);
+	}, Hi = function(e) {
+		if (!e.value || e.value.source) return e.value;
+		let t = this.getCharacterIndex(/\S/, e.sourceSpan.start);
+		return {
+			source: "$implicit",
+			span: {
+				start: t,
+				end: t
+			}
+		};
+	}, Ui = function() {
+		let e = _(this, Ii), [t] = e, n = _(this, Z).slice(t.sourceSpan.start, t.sourceSpan.end).trim().length === 0 ? e.slice(1) : e, r = [], i = null;
+		for (let [e, t] of n.entries()) {
+			if (i && be(i) && xe(t) && t.value && t.value.source === i.key.source) {
+				let e = v(this, Q, $).call(this, {
+					type: "NGMicrosyntaxKey",
+					name: t.key.source
+				}, t.key.span), n = (e, t) => ({
+					...e,
+					...this.transformSpan({
+						start: e.start,
+						end: t
+					})
+				}), i = (t) => ({
+					...n(t, e.end),
+					alias: e
+				}), a = r.pop();
+				if (a.type === "NGMicrosyntaxExpression") r.push(i(a));
+				else if (a.type === "NGMicrosyntaxKeyedExpression") {
+					let e = i(a.expression);
+					r.push(n({
+						...a,
+						expression: e
+					}, e.end));
+				} else throw Error(`Unexpected type ${a.type}`);
+			} else r.push(v(this, Q, Wi).call(this, t, e));
+			i = t;
+		}
+		return v(this, Q, $).call(this, {
+			type: "NGMicrosyntax",
+			body: r
+		}, r.length === 0 ? e[0].sourceSpan : {
+			start: r[0].start,
+			end: Fi(0, r, -1).end
+		});
+	}, Wi = function(e, t) {
+		if (be(e)) {
+			let { key: n, value: r } = e;
+			return r ? t === 0 ? v(this, Q, $).call(this, {
+				type: "NGMicrosyntaxExpression",
+				expression: v(this, Q, Ri).call(this, r.ast),
+				alias: null
+			}, r) : v(this, Q, $).call(this, {
+				type: "NGMicrosyntaxKeyedExpression",
+				key: v(this, Q, $).call(this, {
+					type: "NGMicrosyntaxKey",
+					name: v(this, Q, zi).call(this, n.source)
+				}, n.span),
+				expression: v(this, Q, $).call(this, {
+					type: "NGMicrosyntaxExpression",
+					expression: v(this, Q, Ri).call(this, r.ast),
+					alias: null
+				}, r)
+			}, [n.span.start, r.sourceSpan.end]) : v(this, Q, $).call(this, {
+				type: "NGMicrosyntaxKey",
+				name: v(this, Q, zi).call(this, n.source)
+			}, n.span);
+		} else {
+			let { key: t, sourceSpan: n } = e;
+			if (/^let\s$/.test(_(this, Z).slice(n.start, n.start + 4))) {
+				let { value: r } = e;
+				return v(this, Q, $).call(this, {
+					type: "NGMicrosyntaxLet",
+					key: v(this, Q, $).call(this, {
+						type: "NGMicrosyntaxKey",
+						name: t.source
+					}, t.span),
+					value: r ? v(this, Q, $).call(this, {
+						type: "NGMicrosyntaxKey",
+						name: r.source
+					}, r.span) : null
+				}, [n.start, r ? r.span.end : t.span.end]);
+			} else {
+				let n = v(this, Q, Hi).call(this, e);
+				return v(this, Q, $).call(this, {
+					type: "NGMicrosyntaxAs",
+					key: v(this, Q, $).call(this, {
+						type: "NGMicrosyntaxKey",
+						name: n.source
+					}, n.span),
+					alias: v(this, Q, $).call(this, {
+						type: "NGMicrosyntaxKey",
+						name: t.source
+					}, t.span)
+				}, [n.span.start, t.span.end]);
+			}
+		}
+	}, Gi), qi = (e) => (t) => {
+		let { result: n, comments: r } = e(t);
+		return Object.assign(Ni(n), { comments: r });
+	}, Ji = qi(Ir), Yi = qi(Lr), qi(Rr), Xi = qi(zr), Zi = (e) => Se(Br(e).result.templateBindings, e), Qi = Te(Ji), $i = Te(Yi), ea = Te(Xi), ta = Te(Zi);
+}))();
+export { Fe as default, Ie as parsers };