@mpen/rerouter 0.1.9 → 0.3.1

package/dist/angular--Iqdw9UJ.js

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