@prismicio/cli 0.0.1 → 0.0.2-alpha.xru-fix-npx-install-warnings.2

package/dist/angular-B-6Sdz-P.js

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