(function (n) {
  function e() {
    var i = n();
    return i.default || i;
  }
  if (typeof exports == "object" && typeof module == "object")
    module.exports = e();
  else if (typeof define == "function" && define.amd) define(e);
  else {
    var t =
      typeof globalThis < "u"
        ? globalThis
        : typeof global < "u"
          ? global
          : typeof self < "u"
            ? self
            : this || {};
    (t.prettierPlugins = t.prettierPlugins || {}),
      (t.prettierPlugins.angular = e());
  }
})(function () {
  "use strict";
  var Ut = Object.defineProperty;
  var Je = Object.getOwnPropertyDescriptor;
  var Xe = Object.getOwnPropertyNames;
  var ts = Object.prototype.hasOwnProperty;
  var ae = (r) => {
    throw TypeError(r);
  };
  var oe = (r, t) => {
      for (var e in t) Ut(r, e, { get: t[e], enumerable: !0 });
    },
    es = (r, t, e, s) => {
      if ((t && typeof t == "object") || typeof t == "function")
        for (let i of Xe(t))
          !ts.call(r, i) &&
            i !== e &&
            Ut(r, i, {
              get: () => t[i],
              enumerable: !(s = Je(t, i)) || s.enumerable,
            });
      return r;
    };
  var ss = (r) => es(Ut({}, "__esModule", { value: !0 }), r);
  var Ft = (r, t, e) => t.has(r) || ae("Cannot " + e);
  var O = (r, t, e) => (
      Ft(r, t, "read from private field"), e ? e.call(r) : t.get(r)
    ),
    P = (r, t, e) =>
      t.has(r)
        ? ae("Cannot add the same private member more than once")
        : t instanceof WeakSet
          ? t.add(r)
          : t.set(r, e),
    Y = (r, t, e, s) => (
      Ft(r, t, "write to private field"), s ? s.call(r, e) : t.set(r, e), e
    ),
    c = (r, t, e) => (Ft(r, t, "access private method"), e);
  var rr = {};
  oe(rr, { parsers: () => ne });
  var ne = {};
  oe(ne, {
    __ng_action: () => Xs,
    __ng_binding: () => tr,
    __ng_directive: () => sr,
    __ng_interpolation: () => er,
  });
  var Z = class {
      constructor(t, e, s, i) {
        (this.input = e),
          (this.errLocation = s),
          (this.ctxLocation = i),
          (this.message = `Parser Error: ${t} ${s} [${e}] in ${i}`);
      }
    },
    b = class {
      constructor(t, e) {
        (this.start = t), (this.end = e);
      }
      toAbsolute(t) {
        return new L(t + this.start, t + this.end);
      }
    },
    m = class {
      constructor(t, e) {
        (this.span = t), (this.sourceSpan = e);
      }
      toString() {
        return "AST";
      }
    },
    J = class extends m {
      constructor(t, e, s) {
        super(t, e), (this.nameSpan = s);
      }
    },
    $ = class extends m {
      visit(t, e = null) {}
    },
    K = class extends m {
      visit(t, e = null) {
        return t.visitImplicitReceiver(this, e);
      }
    },
    Lt = class extends K {
      visit(t, e = null) {
        var s;
        return (s = t.visitThisReceiver) == null ? void 0 : s.call(t, this, e);
      }
    },
    X = class extends m {
      constructor(t, e, s) {
        super(t, e), (this.expressions = s);
      }
      visit(t, e = null) {
        return t.visitChain(this, e);
      }
    },
    tt = class extends m {
      constructor(t, e, s, i, n) {
        super(t, e),
          (this.condition = s),
          (this.trueExp = i),
          (this.falseExp = n);
      }
      visit(t, e = null) {
        return t.visitConditional(this, e);
      }
    },
    M = class extends J {
      constructor(t, e, s, i, n) {
        super(t, e, s), (this.receiver = i), (this.name = n);
      }
      visit(t, e = null) {
        return t.visitPropertyRead(this, e);
      }
    },
    et = class extends J {
      constructor(t, e, s, i, n, a) {
        super(t, e, s), (this.receiver = i), (this.name = n), (this.value = a);
      }
      visit(t, e = null) {
        return t.visitPropertyWrite(this, e);
      }
    },
    _ = class extends J {
      constructor(t, e, s, i, n) {
        super(t, e, s), (this.receiver = i), (this.name = n);
      }
      visit(t, e = null) {
        return t.visitSafePropertyRead(this, e);
      }
    },
    st = class extends m {
      constructor(t, e, s, i) {
        super(t, e), (this.receiver = s), (this.key = i);
      }
      visit(t, e = null) {
        return t.visitKeyedRead(this, e);
      }
    },
    U = class extends m {
      constructor(t, e, s, i) {
        super(t, e), (this.receiver = s), (this.key = i);
      }
      visit(t, e = null) {
        return t.visitSafeKeyedRead(this, e);
      }
    },
    rt = class extends m {
      constructor(t, e, s, i, n) {
        super(t, e), (this.receiver = s), (this.key = i), (this.value = n);
      }
      visit(t, e = null) {
        return t.visitKeyedWrite(this, e);
      }
    },
    it = class extends J {
      constructor(t, e, s, i, n, a) {
        super(t, e, a), (this.exp = s), (this.name = i), (this.args = n);
      }
      visit(t, e = null) {
        return t.visitPipe(this, e);
      }
    },
    E = class extends m {
      constructor(t, e, s) {
        super(t, e), (this.value = s);
      }
      visit(t, e = null) {
        return t.visitLiteralPrimitive(this, e);
      }
    },
    nt = class extends m {
      constructor(t, e, s) {
        super(t, e), (this.expressions = s);
      }
      visit(t, e = null) {
        return t.visitLiteralArray(this, e);
      }
    },
    at = class extends m {
      constructor(t, e, s, i) {
        super(t, e), (this.keys = s), (this.values = i);
      }
      visit(t, e = null) {
        return t.visitLiteralMap(this, e);
      }
    },
    ot = class extends m {
      constructor(t, e, s, i) {
        super(t, e), (this.strings = s), (this.expressions = i);
      }
      visit(t, e = null) {
        return t.visitInterpolation(this, e);
      }
    },
    A = class extends m {
      constructor(t, e, s, i, n) {
        super(t, e), (this.operation = s), (this.left = i), (this.right = n);
      }
      visit(t, e = null) {
        return t.visitBinary(this, e);
      }
    },
    F = class r extends A {
      static createMinus(t, e, s) {
        return new r(t, e, "-", s, "-", new E(t, e, 0), s);
      }
      static createPlus(t, e, s) {
        return new r(t, e, "+", s, "-", s, new E(t, e, 0));
      }
      constructor(t, e, s, i, n, a, o) {
        super(t, e, n, a, o),
          (this.operator = s),
          (this.expr = i),
          (this.left = null),
          (this.right = null),
          (this.operation = null);
      }
      visit(t, e = null) {
        return t.visitUnary !== void 0
          ? t.visitUnary(this, e)
          : t.visitBinary(this, e);
      }
    },
    ct = class extends m {
      constructor(t, e, s) {
        super(t, e), (this.expression = s);
      }
      visit(t, e = null) {
        return t.visitPrefixNot(this, e);
      }
    },
    ht = class extends m {
      constructor(t, e, s) {
        super(t, e), (this.expression = s);
      }
      visit(t, e = null) {
        return t.visitNonNullAssert(this, e);
      }
    },
    pt = class extends m {
      constructor(t, e, s, i, n) {
        super(t, e),
          (this.receiver = s),
          (this.args = i),
          (this.argumentSpan = n);
      }
      visit(t, e = null) {
        return t.visitCall(this, e);
      }
    },
    D = class extends m {
      constructor(t, e, s, i, n) {
        super(t, e),
          (this.receiver = s),
          (this.args = i),
          (this.argumentSpan = n);
      }
      visit(t, e = null) {
        return t.visitSafeCall(this, e);
      }
    },
    L = class {
      constructor(t, e) {
        (this.start = t), (this.end = e);
      }
    },
    R = class extends m {
      constructor(t, e, s, i, n) {
        super(
          new b(0, e === null ? 0 : e.length),
          new L(i, e === null ? i : i + e.length),
        ),
          (this.ast = t),
          (this.source = e),
          (this.location = s),
          (this.errors = n);
      }
      visit(t, e = null) {
        return t.visitASTWithSource
          ? t.visitASTWithSource(this, e)
          : this.ast.visit(t, e);
      }
      toString() {
        return `${this.source} in ${this.location}`;
      }
    },
    W = class {
      constructor(t, e, s) {
        (this.sourceSpan = t), (this.key = e), (this.value = s);
      }
    },
    ut = class {
      constructor(t, e, s) {
        (this.sourceSpan = t), (this.key = e), (this.value = s);
      }
    },
    Rt = class {
      visit(t, e) {
        t.visit(this, e);
      }
      visitUnary(t, e) {
        this.visit(t.expr, e);
      }
      visitBinary(t, e) {
        this.visit(t.left, e), this.visit(t.right, e);
      }
      visitChain(t, e) {
        this.visitAll(t.expressions, e);
      }
      visitConditional(t, e) {
        this.visit(t.condition, e),
          this.visit(t.trueExp, e),
          this.visit(t.falseExp, e);
      }
      visitPipe(t, e) {
        this.visit(t.exp, e), this.visitAll(t.args, e);
      }
      visitImplicitReceiver(t, e) {}
      visitThisReceiver(t, e) {}
      visitInterpolation(t, e) {
        this.visitAll(t.expressions, e);
      }
      visitKeyedRead(t, e) {
        this.visit(t.receiver, e), this.visit(t.key, e);
      }
      visitKeyedWrite(t, e) {
        this.visit(t.receiver, e), this.visit(t.key, e), this.visit(t.value, e);
      }
      visitLiteralArray(t, e) {
        this.visitAll(t.expressions, e);
      }
      visitLiteralMap(t, e) {
        this.visitAll(t.values, e);
      }
      visitLiteralPrimitive(t, e) {}
      visitPrefixNot(t, e) {
        this.visit(t.expression, e);
      }
      visitNonNullAssert(t, e) {
        this.visit(t.expression, e);
      }
      visitPropertyRead(t, e) {
        this.visit(t.receiver, e);
      }
      visitPropertyWrite(t, e) {
        this.visit(t.receiver, e), this.visit(t.value, e);
      }
      visitSafePropertyRead(t, e) {
        this.visit(t.receiver, e);
      }
      visitSafeKeyedRead(t, e) {
        this.visit(t.receiver, e), this.visit(t.key, e);
      }
      visitCall(t, e) {
        this.visit(t.receiver, e), this.visitAll(t.args, e);
      }
      visitSafeCall(t, e) {
        this.visit(t.receiver, e), this.visitAll(t.args, e);
      }
      visitAll(t, e) {
        for (let s of t) this.visit(s, e);
      }
    };
  var ce;
  (function (r) {
    (r[(r.DEFAULT = 0)] = "DEFAULT"),
      (r[(r.LITERAL_ATTR = 1)] = "LITERAL_ATTR"),
      (r[(r.ANIMATION = 2)] = "ANIMATION"),
      (r[(r.TWO_WAY = 3)] = "TWO_WAY");
  })(ce || (ce = {}));
  var he;
  (function (r) {
    (r[(r.Regular = 0)] = "Regular"),
      (r[(r.Animation = 1)] = "Animation"),
      (r[(r.TwoWay = 2)] = "TwoWay");
  })(he || (he = {}));
  var pe;
  (function (r) {
    (r[(r.Property = 0)] = "Property"),
      (r[(r.Attribute = 1)] = "Attribute"),
      (r[(r.Class = 2)] = "Class"),
      (r[(r.Style = 3)] = "Style"),
      (r[(r.Animation = 4)] = "Animation"),
      (r[(r.TwoWay = 5)] = "TwoWay");
  })(pe || (pe = {}));
  function ue(r) {
    return (r >= 9 && r <= 32) || r == 160;
  }
  function B(r) {
    return 48 <= r && r <= 57;
  }
  function le(r) {
    return (r >= 97 && r <= 122) || (r >= 65 && r <= 90);
  }
  function Dt(r) {
    return r === 39 || r === 34 || r === 96;
  }
  var l;
  (function (r) {
    (r[(r.Character = 0)] = "Character"),
      (r[(r.Identifier = 1)] = "Identifier"),
      (r[(r.PrivateIdentifier = 2)] = "PrivateIdentifier"),
      (r[(r.Keyword = 3)] = "Keyword"),
      (r[(r.String = 4)] = "String"),
      (r[(r.Operator = 5)] = "Operator"),
      (r[(r.Number = 6)] = "Number"),
      (r[(r.Error = 7)] = "Error");
  })(l || (l = {}));
  var Ps = [
      "var",
      "let",
      "as",
      "null",
      "undefined",
      "true",
      "false",
      "if",
      "else",
      "this",
    ],
    yt = class {
      tokenize(t) {
        let e = new Vt(t),
          s = [],
          i = e.scanToken();
        for (; i != null; ) s.push(i), (i = e.scanToken());
        return s;
      }
    },
    I = class {
      constructor(t, e, s, i, n) {
        (this.index = t),
          (this.end = e),
          (this.type = s),
          (this.numValue = i),
          (this.strValue = n);
      }
      isCharacter(t) {
        return this.type == l.Character && this.numValue == t;
      }
      isNumber() {
        return this.type == l.Number;
      }
      isString() {
        return this.type == l.String;
      }
      isOperator(t) {
        return this.type == l.Operator && this.strValue == t;
      }
      isIdentifier() {
        return this.type == l.Identifier;
      }
      isPrivateIdentifier() {
        return this.type == l.PrivateIdentifier;
      }
      isKeyword() {
        return this.type == l.Keyword;
      }
      isKeywordLet() {
        return this.type == l.Keyword && this.strValue == "let";
      }
      isKeywordAs() {
        return this.type == l.Keyword && this.strValue == "as";
      }
      isKeywordNull() {
        return this.type == l.Keyword && this.strValue == "null";
      }
      isKeywordUndefined() {
        return this.type == l.Keyword && this.strValue == "undefined";
      }
      isKeywordTrue() {
        return this.type == l.Keyword && this.strValue == "true";
      }
      isKeywordFalse() {
        return this.type == l.Keyword && this.strValue == "false";
      }
      isKeywordThis() {
        return this.type == l.Keyword && this.strValue == "this";
      }
      isError() {
        return this.type == l.Error;
      }
      toNumber() {
        return this.type == l.Number ? this.numValue : -1;
      }
      toString() {
        switch (this.type) {
          case l.Character:
          case l.Identifier:
          case l.Keyword:
          case l.Operator:
          case l.PrivateIdentifier:
          case l.String:
          case l.Error:
            return this.strValue;
          case l.Number:
            return this.numValue.toString();
          default:
            return null;
        }
      }
    };
  function ge(r, t, e) {
    return new I(r, t, l.Character, e, String.fromCharCode(e));
  }
  function bs(r, t, e) {
    return new I(r, t, l.Identifier, 0, e);
  }
  function Ks(r, t, e) {
    return new I(r, t, l.PrivateIdentifier, 0, e);
  }
  function Bs(r, t, e) {
    return new I(r, t, l.Keyword, 0, e);
  }
  function Gt(r, t, e) {
    return new I(r, t, l.Operator, 0, e);
  }
  function Ts(r, t, e) {
    return new I(r, t, l.String, 0, e);
  }
  function Ms(r, t, e) {
    return new I(r, t, l.Number, e, "");
  }
  function _s(r, t, e) {
    return new I(r, t, l.Error, 0, e);
  }
  var Bt = new I(-1, -1, l.Character, 0, ""),
    Vt = class {
      constructor(t) {
        (this.input = t),
          (this.peek = 0),
          (this.index = -1),
          (this.length = t.length),
          this.advance();
      }
      advance() {
        this.peek =
          ++this.index >= this.length ? 0 : this.input.charCodeAt(this.index);
      }
      scanToken() {
        let t = this.input,
          e = this.length,
          s = this.peek,
          i = this.index;
        for (; s <= 32; )
          if (++i >= e) {
            s = 0;
            break;
          } else s = t.charCodeAt(i);
        if (((this.peek = s), (this.index = i), i >= e)) return null;
        if (me(s)) return this.scanIdentifier();
        if (B(s)) return this.scanNumber(i);
        let n = i;
        switch (s) {
          case 46:
            return (
              this.advance(),
              B(this.peek) ? this.scanNumber(n) : ge(n, this.index, 46)
            );
          case 40:
          case 41:
          case 123:
          case 125:
          case 91:
          case 93:
          case 44:
          case 58:
          case 59:
            return this.scanCharacter(n, s);
          case 39:
          case 34:
            return this.scanString();
          case 35:
            return this.scanPrivateIdentifier();
          case 43:
          case 45:
          case 42:
          case 47:
          case 37:
          case 94:
            return this.scanOperator(n, String.fromCharCode(s));
          case 63:
            return this.scanQuestion(n);
          case 60:
          case 62:
            return this.scanComplexOperator(n, String.fromCharCode(s), 61, "=");
          case 33:
          case 61:
            return this.scanComplexOperator(
              n,
              String.fromCharCode(s),
              61,
              "=",
              61,
              "=",
            );
          case 38:
            return this.scanComplexOperator(n, "&", 38, "&");
          case 124:
            return this.scanComplexOperator(n, "|", 124, "|");
          case 160:
            for (; ue(this.peek); ) this.advance();
            return this.scanToken();
        }
        return (
          this.advance(),
          this.error(`Unexpected character [${String.fromCharCode(s)}]`, 0)
        );
      }
      scanCharacter(t, e) {
        return this.advance(), ge(t, this.index, e);
      }
      scanOperator(t, e) {
        return this.advance(), Gt(t, this.index, e);
      }
      scanComplexOperator(t, e, s, i, n, a) {
        this.advance();
        let o = e;
        return (
          this.peek == s && (this.advance(), (o += i)),
          n != null && this.peek == n && (this.advance(), (o += a)),
          Gt(t, this.index, o)
        );
      }
      scanIdentifier() {
        let t = this.index;
        for (this.advance(); Se(this.peek); ) this.advance();
        let e = this.input.substring(t, this.index);
        return Ps.indexOf(e) > -1 ? Bs(t, this.index, e) : bs(t, this.index, e);
      }
      scanPrivateIdentifier() {
        let t = this.index;
        if ((this.advance(), !me(this.peek)))
          return this.error("Invalid character [#]", -1);
        for (; Se(this.peek); ) this.advance();
        let e = this.input.substring(t, this.index);
        return Ks(t, this.index, e);
      }
      scanNumber(t) {
        let e = this.index === t,
          s = !1;
        for (this.advance(); ; ) {
          if (!B(this.peek))
            if (this.peek === 95) {
              if (
                !B(this.input.charCodeAt(this.index - 1)) ||
                !B(this.input.charCodeAt(this.index + 1))
              )
                return this.error("Invalid numeric separator", 0);
              s = !0;
            } else if (this.peek === 46) e = !1;
            else if (Us(this.peek)) {
              if (
                (this.advance(), Fs(this.peek) && this.advance(), !B(this.peek))
              )
                return this.error("Invalid exponent", -1);
              e = !1;
            } else break;
          this.advance();
        }
        let i = this.input.substring(t, this.index);
        s && (i = i.replace(/_/g, ""));
        let n = e ? Ws(i) : parseFloat(i);
        return Ms(t, this.index, n);
      }
      scanString() {
        let t = this.index,
          e = this.peek;
        this.advance();
        let s = "",
          i = this.index,
          n = this.input;
        for (; this.peek != e; )
          if (this.peek == 92) {
            s += n.substring(i, this.index);
            let o;
            if ((this.advance(), this.peek == 117)) {
              let p = n.substring(this.index + 1, this.index + 5);
              if (/^[0-9a-f]+$/i.test(p)) o = parseInt(p, 16);
              else return this.error(`Invalid unicode escape [\\u${p}]`, 0);
              for (let u = 0; u < 5; u++) this.advance();
            } else (o = Ds(this.peek)), this.advance();
            (s += String.fromCharCode(o)), (i = this.index);
          } else {
            if (this.peek == 0) return this.error("Unterminated quote", 0);
            this.advance();
          }
        let a = n.substring(i, this.index);
        return this.advance(), Ts(t, this.index, s + a);
      }
      scanQuestion(t) {
        this.advance();
        let e = "?";
        return (
          (this.peek === 63 || this.peek === 46) &&
            ((e += this.peek === 46 ? "." : "?"), this.advance()),
          Gt(t, this.index, e)
        );
      }
      error(t, e) {
        let s = this.index + e;
        return _s(
          s,
          this.index,
          `Lexer Error: ${t} at column ${s} in expression [${this.input}]`,
        );
      }
    };
  function me(r) {
    return (97 <= r && r <= 122) || (65 <= r && r <= 90) || r == 95 || r == 36;
  }
  function Se(r) {
    return le(r) || B(r) || r == 95 || r == 36;
  }
  function Us(r) {
    return r == 101 || r == 69;
  }
  function Fs(r) {
    return r == 45 || r == 43;
  }
  function Ds(r) {
    switch (r) {
      case 110:
        return 10;
      case 102:
        return 12;
      case 114:
        return 13;
      case 116:
        return 9;
      case 118:
        return 11;
      default:
        return r;
    }
  }
  function Ws(r) {
    let t = parseInt(r);
    if (isNaN(t)) throw new Error("Invalid integer literal when parsing " + r);
    return t;
  }
  var Gs = [/@/, /^\s*$/, /[<>]/, /^[{}]$/, /&(#|[a-z])/i, /^\/\//];
  function Ee(r, t) {
    if (t != null && !(Array.isArray(t) && t.length == 2))
      throw new Error(`Expected '${r}' to be an array, [start, end].`);
    if (t != null) {
      let e = t[0],
        s = t[1];
      Gs.forEach((i) => {
        if (i.test(e) || i.test(s))
          throw new Error(
            `['${e}', '${s}'] contains unusable interpolation symbol.`,
          );
      });
    }
  }
  var zt = class r {
      static fromArray(t) {
        return t ? (Ee("interpolation", t), new r(t[0], t[1])) : Q;
      }
      constructor(t, e) {
        (this.start = t), (this.end = e);
      }
    },
    Q = new zt("{{", "}}");
  var qt = class {
      constructor(t, e, s) {
        (this.strings = t), (this.expressions = e), (this.offsets = s);
      }
    },
    Ht = class {
      constructor(t, e, s) {
        (this.templateBindings = t), (this.warnings = e), (this.errors = s);
      }
    },
    mt = class {
      constructor(t) {
        (this._lexer = t), (this.errors = []);
      }
      parseAction(t, e, s, i = Q) {
        this._checkNoInterpolation(t, e, i);
        let n = this._stripComments(t),
          a = this._lexer.tokenize(n),
          o = new z(t, e, s, a, 1, this.errors, 0).parseChain();
        return new R(o, t, e, s, this.errors);
      }
      parseBinding(t, e, s, i = Q) {
        let n = this._parseBindingAst(t, e, s, i);
        return new R(n, t, e, s, this.errors);
      }
      checkSimpleExpression(t) {
        let e = new jt();
        return t.visit(e), e.errors;
      }
      parseSimpleBinding(t, e, s, i = Q) {
        let n = this._parseBindingAst(t, e, s, i),
          a = this.checkSimpleExpression(n);
        return (
          a.length > 0 &&
            this._reportError(
              `Host binding expression cannot contain ${a.join(" ")}`,
              t,
              e,
            ),
          new R(n, t, e, s, this.errors)
        );
      }
      _reportError(t, e, s, i) {
        this.errors.push(new Z(t, e, s, i));
      }
      _parseBindingAst(t, e, s, i) {
        this._checkNoInterpolation(t, e, i);
        let n = this._stripComments(t),
          a = this._lexer.tokenize(n);
        return new z(t, e, s, a, 0, this.errors, 0).parseChain();
      }
      parseTemplateBindings(t, e, s, i, n) {
        let a = this._lexer.tokenize(e);
        return new z(e, s, n, a, 0, this.errors, 0).parseTemplateBindings({
          source: t,
          span: new L(i, i + t.length),
        });
      }
      parseInterpolation(t, e, s, i, n = Q) {
        let {
          strings: a,
          expressions: o,
          offsets: p,
        } = this.splitInterpolation(t, e, i, n);
        if (o.length === 0) return null;
        let u = [];
        for (let f = 0; f < o.length; ++f) {
          let S = o[f].text,
            g = this._stripComments(S),
            y = this._lexer.tokenize(g),
            w = new z(t, e, s, y, 0, this.errors, p[f]).parseChain();
          u.push(w);
        }
        return this.createInterpolationAst(
          a.map((f) => f.text),
          u,
          t,
          e,
          s,
        );
      }
      parseInterpolationExpression(t, e, s) {
        let i = this._stripComments(t),
          n = this._lexer.tokenize(i),
          a = new z(t, e, s, n, 0, this.errors, 0).parseChain(),
          o = ["", ""];
        return this.createInterpolationAst(o, [a], t, e, s);
      }
      createInterpolationAst(t, e, s, i, n) {
        let a = new b(0, s.length),
          o = new ot(a, a.toAbsolute(n), t, e);
        return new R(o, s, i, n, this.errors);
      }
      splitInterpolation(t, e, s, i = Q) {
        let n = [],
          a = [],
          o = [],
          p = s ? Vs(s) : null,
          u = 0,
          f = !1,
          S = !1,
          { start: g, end: y } = i;
        for (; u < t.length; )
          if (f) {
            let w = u,
              H = w + g.length,
              j = this._getInterpolationEndIndex(t, y, H);
            if (j === -1) {
              (f = !1), (S = !0);
              break;
            }
            let T = j + y.length,
              Nt = t.substring(H, j);
            Nt.trim().length === 0 &&
              this._reportError(
                "Blank expressions are not allowed in interpolated strings",
                t,
                `at column ${u} in`,
                e,
              ),
              a.push({ text: Nt, start: w, end: T });
            let Ze = ((p == null ? void 0 : p.get(w)) ?? w) + g.length;
            o.push(Ze), (u = T), (f = !1);
          } else {
            let w = u;
            (u = t.indexOf(g, u)), u === -1 && (u = t.length);
            let H = t.substring(w, u);
            n.push({ text: H, start: w, end: u }), (f = !0);
          }
        if (!f)
          if (S) {
            let w = n[n.length - 1];
            (w.text += t.substring(u)), (w.end = t.length);
          } else n.push({ text: t.substring(u), start: u, end: t.length });
        return new qt(n, a, o);
      }
      wrapLiteralPrimitive(t, e, s) {
        let i = new b(0, t == null ? 0 : t.length);
        return new R(new E(i, i.toAbsolute(s), t), t, e, s, this.errors);
      }
      _stripComments(t) {
        let e = this._commentStart(t);
        return e != null ? t.substring(0, e) : t;
      }
      _commentStart(t) {
        let e = null;
        for (let s = 0; s < t.length - 1; s++) {
          let i = t.charCodeAt(s),
            n = t.charCodeAt(s + 1);
          if (i === 47 && n == 47 && e == null) return s;
          e === i ? (e = null) : e == null && Dt(i) && (e = i);
        }
        return null;
      }
      _checkNoInterpolation(t, e, { start: s, end: i }) {
        let n = -1,
          a = -1;
        for (let o of this._forEachUnquotedChar(t, 0))
          if (n === -1) t.startsWith(s) && (n = o);
          else if (((a = this._getInterpolationEndIndex(t, i, o)), a > -1))
            break;
        n > -1 &&
          a > -1 &&
          this._reportError(
            `Got interpolation (${s}${i}) where expression was expected`,
            t,
            `at column ${n} in`,
            e,
          );
      }
      _getInterpolationEndIndex(t, e, s) {
        for (let i of this._forEachUnquotedChar(t, s)) {
          if (t.startsWith(e, i)) return i;
          if (t.startsWith("//", i)) return t.indexOf(e, i);
        }
        return -1;
      }
      *_forEachUnquotedChar(t, e) {
        let s = null,
          i = 0;
        for (let n = e; n < t.length; n++) {
          let a = t[n];
          Dt(t.charCodeAt(n)) && (s === null || s === a) && i % 2 === 0
            ? (s = s === null ? a : null)
            : s === null && (yield n),
            (i = a === "\\" ? i + 1 : 0);
        }
      }
    },
    gt;
  (function (r) {
    (r[(r.None = 0)] = "None"), (r[(r.Writable = 1)] = "Writable");
  })(gt || (gt = {}));
  var z = class {
      constructor(t, e, s, i, n, a, o) {
        (this.input = t),
          (this.location = e),
          (this.absoluteOffset = s),
          (this.tokens = i),
          (this.parseFlags = n),
          (this.errors = a),
          (this.offset = o),
          (this.rparensExpected = 0),
          (this.rbracketsExpected = 0),
          (this.rbracesExpected = 0),
          (this.context = gt.None),
          (this.sourceSpanCache = new Map()),
          (this.index = 0);
      }
      peek(t) {
        let e = this.index + t;
        return e < this.tokens.length ? this.tokens[e] : Bt;
      }
      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, e) {
        let s = this.currentEndIndex;
        if ((e !== void 0 && e > this.currentEndIndex && (s = e), t > s)) {
          let i = s;
          (s = t), (t = i);
        }
        return new b(t, s);
      }
      sourceSpan(t, e) {
        let s = `${t}@${this.inputIndex}:${e}`;
        return (
          this.sourceSpanCache.has(s) ||
            this.sourceSpanCache.set(
              s,
              this.span(t, e).toAbsolute(this.absoluteOffset),
            ),
          this.sourceSpanCache.get(s)
        );
      }
      advance() {
        this.index++;
      }
      withContext(t, e) {
        this.context |= t;
        let s = e();
        return (this.context ^= t), s;
      }
      consumeOptionalCharacter(t) {
        return this.next.isCharacter(t) ? (this.advance(), !0) : !1;
      }
      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(), !0) : !1;
      }
      expectOperator(t) {
        this.consumeOptionalOperator(t) ||
          this.error(`Missing expected operator ${t}`);
      }
      prettyPrintToken(t) {
        return t === Bt ? "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 = [],
          e = this.inputIndex;
        for (; this.index < this.tokens.length; ) {
          let s = this.parsePipe();
          if ((t.push(s), this.consumeOptionalCharacter(59)))
            for (
              this.parseFlags & 1 ||
              this.error(
                "Binding expression cannot contain chained expression",
              );
              this.consumeOptionalCharacter(59);

            );
          else if (this.index < this.tokens.length) {
            let i = this.index;
            if (
              (this.error(`Unexpected token '${this.next}'`), this.index === i)
            )
              break;
          }
        }
        if (t.length === 0) {
          let s = this.offset,
            i = this.offset + this.input.length;
          return new $(this.span(s, i), this.sourceSpan(s, i));
        }
        return t.length == 1
          ? t[0]
          : new X(this.span(e), this.sourceSpan(e), t);
      }
      parsePipe() {
        let t = this.inputIndex,
          e = this.parseExpression();
        if (this.consumeOptionalOperator("|")) {
          this.parseFlags & 1 &&
            this.error("Cannot have a pipe in an action expression");
          do {
            let s = this.inputIndex,
              i = this.expectIdentifierOrKeyword(),
              n,
              a;
            i !== null
              ? (n = this.sourceSpan(s))
              : ((i = ""),
                (a =
                  this.next.index !== -1
                    ? this.next.index
                    : this.input.length + this.offset),
                (n = new b(a, a).toAbsolute(this.absoluteOffset)));
            let o = [];
            for (; this.consumeOptionalCharacter(58); )
              o.push(this.parseExpression());
            e = new it(this.span(t), this.sourceSpan(t, a), e, i, o, n);
          } while (this.consumeOptionalOperator("|"));
        }
        return e;
      }
      parseExpression() {
        return this.parseConditional();
      }
      parseConditional() {
        let t = this.inputIndex,
          e = this.parseLogicalOr();
        if (this.consumeOptionalOperator("?")) {
          let s = this.parsePipe(),
            i;
          if (this.consumeOptionalCharacter(58)) i = this.parsePipe();
          else {
            let n = this.inputIndex,
              a = this.input.substring(t, n);
            this.error(
              `Conditional expression ${a} requires all 3 expressions`,
            ),
              (i = new $(this.span(t), this.sourceSpan(t)));
          }
          return new tt(this.span(t), this.sourceSpan(t), e, s, i);
        } else return e;
      }
      parseLogicalOr() {
        let t = this.inputIndex,
          e = this.parseLogicalAnd();
        for (; this.consumeOptionalOperator("||"); ) {
          let s = this.parseLogicalAnd();
          e = new A(this.span(t), this.sourceSpan(t), "||", e, s);
        }
        return e;
      }
      parseLogicalAnd() {
        let t = this.inputIndex,
          e = this.parseNullishCoalescing();
        for (; this.consumeOptionalOperator("&&"); ) {
          let s = this.parseNullishCoalescing();
          e = new A(this.span(t), this.sourceSpan(t), "&&", e, s);
        }
        return e;
      }
      parseNullishCoalescing() {
        let t = this.inputIndex,
          e = this.parseEquality();
        for (; this.consumeOptionalOperator("??"); ) {
          let s = this.parseEquality();
          e = new A(this.span(t), this.sourceSpan(t), "??", e, s);
        }
        return e;
      }
      parseEquality() {
        let t = this.inputIndex,
          e = this.parseRelational();
        for (; this.next.type == l.Operator; ) {
          let s = this.next.strValue;
          switch (s) {
            case "==":
            case "===":
            case "!=":
            case "!==":
              this.advance();
              let i = this.parseRelational();
              e = new A(this.span(t), this.sourceSpan(t), s, e, i);
              continue;
          }
          break;
        }
        return e;
      }
      parseRelational() {
        let t = this.inputIndex,
          e = this.parseAdditive();
        for (; this.next.type == l.Operator; ) {
          let s = this.next.strValue;
          switch (s) {
            case "<":
            case ">":
            case "<=":
            case ">=":
              this.advance();
              let i = this.parseAdditive();
              e = new A(this.span(t), this.sourceSpan(t), s, e, i);
              continue;
          }
          break;
        }
        return e;
      }
      parseAdditive() {
        let t = this.inputIndex,
          e = this.parseMultiplicative();
        for (; this.next.type == l.Operator; ) {
          let s = this.next.strValue;
          switch (s) {
            case "+":
            case "-":
              this.advance();
              let i = this.parseMultiplicative();
              e = new A(this.span(t), this.sourceSpan(t), s, e, i);
              continue;
          }
          break;
        }
        return e;
      }
      parseMultiplicative() {
        let t = this.inputIndex,
          e = this.parsePrefix();
        for (; this.next.type == l.Operator; ) {
          let s = this.next.strValue;
          switch (s) {
            case "*":
            case "%":
            case "/":
              this.advance();
              let i = this.parsePrefix();
              e = new A(this.span(t), this.sourceSpan(t), s, e, i);
              continue;
          }
          break;
        }
        return e;
      }
      parsePrefix() {
        if (this.next.type == l.Operator) {
          let t = this.inputIndex,
            e = this.next.strValue,
            s;
          switch (e) {
            case "+":
              return (
                this.advance(),
                (s = this.parsePrefix()),
                F.createPlus(this.span(t), this.sourceSpan(t), s)
              );
            case "-":
              return (
                this.advance(),
                (s = this.parsePrefix()),
                F.createMinus(this.span(t), this.sourceSpan(t), s)
              );
            case "!":
              return (
                this.advance(),
                (s = this.parsePrefix()),
                new ct(this.span(t), this.sourceSpan(t), s)
              );
          }
        }
        return this.parseCallChain();
      }
      parseCallChain() {
        let t = this.inputIndex,
          e = this.parsePrimary();
        for (;;)
          if (this.consumeOptionalCharacter(46))
            e = this.parseAccessMember(e, t, !1);
          else if (this.consumeOptionalOperator("?."))
            this.consumeOptionalCharacter(40)
              ? (e = this.parseCall(e, t, !0))
              : (e = this.consumeOptionalCharacter(91)
                  ? this.parseKeyedReadOrWrite(e, t, !0)
                  : this.parseAccessMember(e, t, !0));
          else if (this.consumeOptionalCharacter(91))
            e = this.parseKeyedReadOrWrite(e, t, !1);
          else if (this.consumeOptionalCharacter(40))
            e = this.parseCall(e, t, !1);
          else if (this.consumeOptionalOperator("!"))
            e = new ht(this.span(t), this.sourceSpan(t), e);
          else return e;
      }
      parsePrimary() {
        let t = this.inputIndex;
        if (this.consumeOptionalCharacter(40)) {
          this.rparensExpected++;
          let e = this.parsePipe();
          return this.rparensExpected--, this.expectCharacter(41), e;
        } else {
          if (this.next.isKeywordNull())
            return (
              this.advance(), new E(this.span(t), this.sourceSpan(t), null)
            );
          if (this.next.isKeywordUndefined())
            return (
              this.advance(), new E(this.span(t), this.sourceSpan(t), void 0)
            );
          if (this.next.isKeywordTrue())
            return this.advance(), new E(this.span(t), this.sourceSpan(t), !0);
          if (this.next.isKeywordFalse())
            return this.advance(), new E(this.span(t), this.sourceSpan(t), !1);
          if (this.next.isKeywordThis())
            return this.advance(), new Lt(this.span(t), this.sourceSpan(t));
          if (this.consumeOptionalCharacter(91)) {
            this.rbracketsExpected++;
            let e = this.parseExpressionList(93);
            return (
              this.rbracketsExpected--,
              this.expectCharacter(93),
              new nt(this.span(t), this.sourceSpan(t), e)
            );
          } else {
            if (this.next.isCharacter(123)) return this.parseLiteralMap();
            if (this.next.isIdentifier())
              return this.parseAccessMember(
                new K(this.span(t), this.sourceSpan(t)),
                t,
                !1,
              );
            if (this.next.isNumber()) {
              let e = this.next.toNumber();
              return this.advance(), new E(this.span(t), this.sourceSpan(t), e);
            } else if (this.next.isString()) {
              let e = this.next.toString();
              return this.advance(), new E(this.span(t), this.sourceSpan(t), e);
            } else
              return this.next.isPrivateIdentifier()
                ? (this._reportErrorForPrivateIdentifier(this.next, null),
                  new $(this.span(t), this.sourceSpan(t)))
                : this.index >= this.tokens.length
                  ? (this.error(`Unexpected end of expression: ${this.input}`),
                    new $(this.span(t), this.sourceSpan(t)))
                  : (this.error(`Unexpected token ${this.next}`),
                    new $(this.span(t), this.sourceSpan(t)));
          }
        }
      }
      parseExpressionList(t) {
        let e = [];
        do
          if (!this.next.isCharacter(t)) e.push(this.parsePipe());
          else break;
        while (this.consumeOptionalCharacter(44));
        return e;
      }
      parseLiteralMap() {
        let t = [],
          e = [],
          s = this.inputIndex;
        if ((this.expectCharacter(123), !this.consumeOptionalCharacter(125))) {
          this.rbracesExpected++;
          do {
            let i = this.inputIndex,
              n = this.next.isString(),
              a = this.expectIdentifierOrKeywordOrString(),
              o = { key: a, quoted: n };
            if ((t.push(o), n))
              this.expectCharacter(58), e.push(this.parsePipe());
            else if (this.consumeOptionalCharacter(58))
              e.push(this.parsePipe());
            else {
              o.isShorthandInitialized = !0;
              let p = this.span(i),
                u = this.sourceSpan(i);
              e.push(new M(p, u, u, new K(p, u), a));
            }
          } while (
            this.consumeOptionalCharacter(44) &&
            !this.next.isCharacter(125)
          );
          this.rbracesExpected--, this.expectCharacter(125);
        }
        return new at(this.span(s), this.sourceSpan(s), t, e);
      }
      parseAccessMember(t, e, s) {
        let i = this.inputIndex,
          n = this.withContext(gt.Writable, () => {
            let p = this.expectIdentifierOrKeyword() ?? "";
            return (
              p.length === 0 &&
                this.error(
                  "Expected identifier for property access",
                  t.span.end,
                ),
              p
            );
          }),
          a = this.sourceSpan(i),
          o;
        if (s)
          this.consumeOptionalOperator("=")
            ? (this.error("The '?.' operator cannot be used in the assignment"),
              (o = new $(this.span(e), this.sourceSpan(e))))
            : (o = new _(this.span(e), this.sourceSpan(e), a, t, n));
        else if (this.consumeOptionalOperator("=")) {
          if (!(this.parseFlags & 1))
            return (
              this.error("Bindings cannot contain assignments"),
              new $(this.span(e), this.sourceSpan(e))
            );
          let p = this.parseConditional();
          o = new et(this.span(e), this.sourceSpan(e), a, t, n, p);
        } else o = new M(this.span(e), this.sourceSpan(e), a, t, n);
        return o;
      }
      parseCall(t, e, s) {
        let i = this.inputIndex;
        this.rparensExpected++;
        let n = this.parseCallArguments(),
          a = this.span(i, this.inputIndex).toAbsolute(this.absoluteOffset);
        this.expectCharacter(41), this.rparensExpected--;
        let o = this.span(e),
          p = this.sourceSpan(e);
        return s ? new D(o, p, t, n, a) : new pt(o, p, t, n, a);
      }
      parseCallArguments() {
        if (this.next.isCharacter(41)) return [];
        let t = [];
        do t.push(this.parsePipe());
        while (this.consumeOptionalCharacter(44));
        return t;
      }
      expectTemplateBindingKey() {
        let t = "",
          e = !1,
          s = this.currentAbsoluteOffset;
        do
          (t += this.expectIdentifierOrKeywordOrString()),
            (e = this.consumeOptionalOperator("-")),
            e && (t += "-");
        while (e);
        return { source: t, span: new L(s, s + t.length) };
      }
      parseTemplateBindings(t) {
        let e = [];
        for (
          e.push(...this.parseDirectiveKeywordBindings(t));
          this.index < this.tokens.length;

        ) {
          let s = this.parseLetBinding();
          if (s) e.push(s);
          else {
            let i = this.expectTemplateBindingKey(),
              n = this.parseAsBinding(i);
            n
              ? e.push(n)
              : ((i.source =
                  t.source +
                  i.source.charAt(0).toUpperCase() +
                  i.source.substring(1)),
                e.push(...this.parseDirectiveKeywordBindings(i)));
          }
          this.consumeStatementTerminator();
        }
        return new Ht(e, [], this.errors);
      }
      parseKeyedReadOrWrite(t, e, s) {
        return this.withContext(gt.Writable, () => {
          this.rbracketsExpected++;
          let i = this.parsePipe();
          if (
            (i instanceof $ && this.error("Key access cannot be empty"),
            this.rbracketsExpected--,
            this.expectCharacter(93),
            this.consumeOptionalOperator("="))
          )
            if (s)
              this.error("The '?.' operator cannot be used in the assignment");
            else {
              let n = this.parseConditional();
              return new rt(this.span(e), this.sourceSpan(e), t, i, n);
            }
          else
            return s
              ? new U(this.span(e), this.sourceSpan(e), t, i)
              : new st(this.span(e), this.sourceSpan(e), t, i);
          return new $(this.span(e), this.sourceSpan(e));
        });
      }
      parseDirectiveKeywordBindings(t) {
        let e = [];
        this.consumeOptionalCharacter(58);
        let s = this.getDirectiveBoundTarget(),
          i = this.currentAbsoluteOffset,
          n = this.parseAsBinding(t);
        n ||
          (this.consumeStatementTerminator(), (i = this.currentAbsoluteOffset));
        let a = new L(t.span.start, i);
        return e.push(new ut(a, t, s)), n && e.push(n), e;
      }
      getDirectiveBoundTarget() {
        if (this.next === Bt || this.peekKeywordAs() || this.peekKeywordLet())
          return null;
        let t = this.parsePipe(),
          { start: e, end: s } = t.span,
          i = this.input.substring(e, s);
        return new R(t, i, this.location, this.absoluteOffset + e, this.errors);
      }
      parseAsBinding(t) {
        if (!this.peekKeywordAs()) return null;
        this.advance();
        let e = this.expectTemplateBindingKey();
        this.consumeStatementTerminator();
        let s = new L(t.span.start, this.currentAbsoluteOffset);
        return new W(s, e, t);
      }
      parseLetBinding() {
        if (!this.peekKeywordLet()) return null;
        let t = this.currentAbsoluteOffset;
        this.advance();
        let e = this.expectTemplateBindingKey(),
          s = null;
        this.consumeOptionalOperator("=") &&
          (s = this.expectTemplateBindingKey()),
          this.consumeStatementTerminator();
        let i = new L(t, this.currentAbsoluteOffset);
        return new W(i, e, s);
      }
      consumeStatementTerminator() {
        this.consumeOptionalCharacter(59) || this.consumeOptionalCharacter(44);
      }
      error(t, e = null) {
        this.errors.push(
          new Z(t, this.input, this.locationText(e), this.location),
        ),
          this.skip();
      }
      locationText(t = null) {
        return (
          t == null && (t = this.index),
          t < this.tokens.length
            ? `at column ${this.tokens[t].index + 1} in`
            : "at the end of the expression"
        );
      }
      _reportErrorForPrivateIdentifier(t, e) {
        let s = `Private identifiers are not supported. Unexpected private identifier: ${t}`;
        e !== null && (s += `, ${e}`), this.error(s);
      }
      skip() {
        let t = this.next;
        for (
          ;
          this.index < this.tokens.length &&
          !t.isCharacter(59) &&
          !t.isOperator("|") &&
          (this.rparensExpected <= 0 || !t.isCharacter(41)) &&
          (this.rbracesExpected <= 0 || !t.isCharacter(125)) &&
          (this.rbracketsExpected <= 0 || !t.isCharacter(93)) &&
          (!(this.context & gt.Writable) || !t.isOperator("="));

        )
          this.next.isError() &&
            this.errors.push(
              new Z(
                this.next.toString(),
                this.input,
                this.locationText(),
                this.location,
              ),
            ),
            this.advance(),
            (t = this.next);
      }
    },
    jt = class extends Rt {
      constructor() {
        super(...arguments), (this.errors = []);
      }
      visitPipe() {
        this.errors.push("pipes");
      }
    };
  function Vs(r) {
    let t = new Map(),
      e = 0,
      s = 0,
      i = 0;
    for (; i < r.length; ) {
      let n = r[i];
      if (n.type === 9) {
        let [a, o] = n.parts;
        (e += o.length), (s += a.length);
      } else {
        let a = n.parts.reduce((o, p) => o + p.length, 0);
        (s += a), (e += a);
      }
      t.set(s, e), i++;
    }
    return t;
  }
  function Ce({ start: r, end: t }, e) {
    let s = r,
      i = t;
    for (; i !== s && /\s/.test(e[i - 1]); ) i--;
    for (; s !== i && /\s/.test(e[s]); ) s++;
    return { start: s, end: i };
  }
  function zs({ start: r, end: t }, e) {
    let s = r,
      i = t;
    for (; i !== e.length && /\s/.test(e[i]); ) i++;
    for (; s !== 0 && /\s/.test(e[s - 1]); ) s--;
    return { start: s, end: i };
  }
  function qs(r, t) {
    return t[r.start - 1] === "(" && t[r.end] === ")"
      ? { start: r.start - 1, end: r.end + 1 }
      : r;
  }
  function Ae(r, t, e) {
    let s = 0,
      i = { start: r.start, end: r.end };
    for (;;) {
      let n = zs(i, t),
        a = qs(n, t);
      if (n.start === a.start && n.end === a.end) break;
      (i.start = a.start), (i.end = a.end), s++;
    }
    return {
      hasParens: (e ? s - 1 : s) !== 0,
      outerSpan: Ce(e ? { start: i.start + 1, end: i.end - 1 } : i, t),
      innerSpan: Ce(r, t),
    };
  }
  function Oe(r) {
    return typeof r == "string" ? (t) => t === r : (t) => r.test(t);
  }
  function Ie(r, t, e) {
    let s = Oe(t);
    for (let i = e; i >= 0; i--) {
      let n = r[i];
      if (s(n)) return i;
    }
    throw new Error(
      `Cannot find front char ${t} from index ${e} in ${JSON.stringify(r)}`,
    );
  }
  function ke(r, t, e) {
    let s = Oe(t);
    for (let i = e; i < r.length; i++) {
      let n = r[i];
      if (s(n)) return i;
    }
    throw new Error(
      `Cannot find character ${t} from index ${e} in ${JSON.stringify(r)}`,
    );
  }
  function Ne(r) {
    return r.slice(0, 1).toLowerCase() + r.slice(1);
  }
  function Ct(r) {
    let { start: t, end: e } = r;
    return { start: t, end: e, range: [t, e] };
  }
  var Hs = (r) => mt.prototype._commentStart(r);
  function js(r, t) {
    let e = t ? Hs(r) : null;
    if (e === null) return { text: r, comments: [] };
    let s = {
      type: "CommentLine",
      value: r.slice(e + 2),
      ...Ct({ start: e, end: r.length }),
    };
    return { text: r.slice(0, e), comments: [s] };
  }
  function At(r, t = !0) {
    return (e) => {
      let s = new yt(),
        i = new mt(s),
        { text: n, comments: a } = js(e, t),
        o = r(n, i);
      if (o.errors.length !== 0) {
        let [{ message: p }] = o.errors;
        throw new SyntaxError(
          p.replace(/^Parser Error: | at column \d+ in [^]*$/g, ""),
        );
      }
      return { result: o, comments: a, text: n };
    };
  }
  var Le = At((r, t) => t.parseBinding(r, "", 0)),
    Ys = At((r, t) => t.parseSimpleBinding(r, "", 0)),
    Re = At((r, t) => t.parseAction(r, "", 0)),
    Pe = At((r, t) => t.parseInterpolationExpression(r, "", 0)),
    be = At((r, t) => t.parseTemplateBindings("", r, "", 0, 0), !1);
  var Js = (r, t, e) => {
      if (!(r && t == null))
        return Array.isArray(t) || typeof t == "string"
          ? t[e < 0 ? t.length + e : e]
          : t.at(e);
    },
    Tt = Js;
  var Yt = class {
      text;
      constructor(t) {
        this.text = t;
      }
      getCharacterIndex(t, e) {
        return ke(this.text, t, e);
      }
      getCharacterLastIndex(t, e) {
        return Ie(this.text, t, e);
      }
      transformSpan(t, { stripSpaces: e = !1, hasParentParens: s = !1 } = {}) {
        if (!e) return Ct(t);
        let { outerSpan: i, innerSpan: n, hasParens: a } = Ae(t, this.text, s),
          o = Ct(n);
        return (
          a &&
            (o.extra = {
              parenthesized: !0,
              parenStart: i.start,
              parenEnd: i.end,
            }),
          o
        );
      }
      createNode(t, { stripSpaces: e = !0, hasParentParens: s = !1 } = {}) {
        let { type: i, start: n, end: a } = t,
          o = {
            ...t,
            ...this.transformSpan(
              { start: n, end: a },
              { stripSpaces: e, hasParentParens: s },
            ),
          };
        switch (i) {
          case "NumericLiteral":
          case "StringLiteral": {
            let p = this.text.slice(o.start, o.end),
              { value: u } = o;
            o.extra = { ...o.extra, raw: p, rawValue: u };
            break;
          }
          case "ObjectProperty": {
            let { shorthand: p } = o;
            p && (o.extra = { ...o.extra, shorthand: p });
            break;
          }
        }
        return o;
      }
    },
    Ke = Yt;
  function Jt(r) {
    var t;
    return !!((t = r.extra) != null && t.parenthesized);
  }
  function k(r) {
    return Jt(r) ? r.extra.parenStart : r.start;
  }
  function N(r) {
    return Jt(r) ? r.extra.parenEnd : r.end;
  }
  function Be(r) {
    return (
      (r.type === "OptionalCallExpression" ||
        r.type === "OptionalMemberExpression") &&
      !Jt(r)
    );
  }
  function Te(r, t) {
    let { start: e, end: s } = r.sourceSpan;
    return e >= s || /^\s+$/.test(t.slice(e, s));
  }
  var kt,
    St,
    h,
    d,
    Ot,
    v,
    Zt,
    It = class extends Ke {
      constructor(e, s) {
        super(s);
        P(this, h);
        P(this, kt);
        P(this, St);
        Y(this, kt, e), Y(this, St, s);
      }
      get node() {
        return c(this, h, v).call(this, O(this, kt));
      }
      transformNode(e) {
        return c(this, h, Zt).call(this, e);
      }
    };
  (kt = new WeakMap()),
    (St = new WeakMap()),
    (h = new WeakSet()),
    (d = function (e, { stripSpaces: s = !0, hasParentParens: i = !1 } = {}) {
      return this.createNode(e, { stripSpaces: s, hasParentParens: i });
    }),
    (Ot = function (
      e,
      s,
      { computed: i, optional: n, end: a = N(s), hasParentParens: o = !1 },
    ) {
      if (Te(e, O(this, St)) || e.sourceSpan.start === s.start) return s;
      let p = c(this, h, v).call(this, e),
        u = Be(p);
      return c(this, h, d).call(
        this,
        {
          type: n || u ? "OptionalMemberExpression" : "MemberExpression",
          object: p,
          property: s,
          computed: i,
          ...(n ? { optional: !0 } : u ? { optional: !1 } : void 0),
          start: k(p),
          end: a,
        },
        { hasParentParens: o },
      );
    }),
    (v = function (e, s = !1) {
      return c(this, h, Zt).call(this, e, s);
    }),
    (Zt = function (e, s = !1) {
      if (e instanceof ot) {
        let { expressions: i } = e;
        if (i.length !== 1) throw new Error("Unexpected 'Interpolation'");
        return c(this, h, v).call(this, i[0]);
      }
      if (e instanceof F)
        return c(this, h, d).call(
          this,
          {
            type: "UnaryExpression",
            prefix: !0,
            argument: c(this, h, v).call(this, e.expr),
            operator: e.operator,
            ...e.sourceSpan,
          },
          { hasParentParens: s },
        );
      if (e instanceof A) {
        let { left: i, operation: n, right: a } = e,
          o = c(this, h, v).call(this, i),
          p = c(this, h, v).call(this, a),
          u = k(o),
          f = N(p),
          S = { left: o, right: p, start: u, end: f };
        return n === "&&" || n === "||" || n === "??"
          ? c(this, h, d).call(
              this,
              { ...S, type: "LogicalExpression", operator: n },
              { hasParentParens: s },
            )
          : c(this, h, d).call(
              this,
              { ...S, type: "BinaryExpression", operator: n },
              { hasParentParens: s },
            );
      }
      if (e instanceof it) {
        let { exp: i, name: n, args: a } = e,
          o = c(this, h, v).call(this, i),
          p = k(o),
          u = N(o),
          f = this.getCharacterIndex(/\S/, this.getCharacterIndex("|", u) + 1),
          S = c(this, h, d).call(this, {
            type: "Identifier",
            name: n,
            start: f,
            end: f + n.length,
          }),
          g = a.map((y) => c(this, h, v).call(this, y));
        return c(this, h, d).call(
          this,
          {
            type: "NGPipeExpression",
            left: o,
            right: S,
            arguments: g,
            start: p,
            end: N(g.length === 0 ? S : Tt(!1, g, -1)),
          },
          { hasParentParens: s },
        );
      }
      if (e instanceof X)
        return c(this, h, d).call(
          this,
          {
            type: "NGChainedExpression",
            expressions: e.expressions.map((i) => c(this, h, v).call(this, i)),
            ...e.sourceSpan,
          },
          { hasParentParens: s },
        );
      if (e instanceof tt) {
        let { condition: i, trueExp: n, falseExp: a } = e,
          o = c(this, h, v).call(this, i),
          p = c(this, h, v).call(this, n),
          u = c(this, h, v).call(this, a);
        return c(this, h, d).call(
          this,
          {
            type: "ConditionalExpression",
            test: o,
            consequent: p,
            alternate: u,
            start: k(o),
            end: N(u),
          },
          { hasParentParens: s },
        );
      }
      if (e instanceof $)
        return c(this, h, d).call(
          this,
          { type: "NGEmptyExpression", ...e.sourceSpan },
          { hasParentParens: s },
        );
      if (e instanceof K)
        return c(this, h, d).call(
          this,
          { type: "ThisExpression", ...e.sourceSpan },
          { hasParentParens: s },
        );
      if (e instanceof st || e instanceof U)
        return c(this, h, Ot).call(
          this,
          e.receiver,
          c(this, h, v).call(this, e.key),
          {
            computed: !0,
            optional: e instanceof U,
            end: e.sourceSpan.end,
            hasParentParens: s,
          },
        );
      if (e instanceof nt)
        return c(this, h, d).call(
          this,
          {
            type: "ArrayExpression",
            elements: e.expressions.map((i) => c(this, h, v).call(this, i)),
            ...e.sourceSpan,
          },
          { hasParentParens: s },
        );
      if (e instanceof at) {
        let { keys: i, values: n } = e,
          a = n.map((p) => c(this, h, v).call(this, p)),
          o = i.map(({ key: p, quoted: u }, f) => {
            let S = a[f],
              g = k(S),
              y = N(S),
              w = this.getCharacterIndex(
                /\S/,
                f === 0
                  ? e.sourceSpan.start + 1
                  : this.getCharacterIndex(",", N(a[f - 1])) + 1,
              ),
              H =
                g === w
                  ? y
                  : this.getCharacterLastIndex(
                      /\S/,
                      this.getCharacterLastIndex(":", g - 1) - 1,
                    ) + 1,
              j = { start: w, end: H },
              T = u
                ? c(this, h, d).call(this, {
                    type: "StringLiteral",
                    value: p,
                    ...j,
                  })
                : c(this, h, d).call(this, {
                    type: "Identifier",
                    name: p,
                    ...j,
                  }),
              Nt = T.end < T.start || w === g;
            return c(this, h, d).call(this, {
              type: "ObjectProperty",
              key: T,
              value: S,
              shorthand: Nt,
              computed: !1,
              start: k(T),
              end: y,
            });
          });
        return c(this, h, d).call(
          this,
          { type: "ObjectExpression", properties: o, ...e.sourceSpan },
          { hasParentParens: s },
        );
      }
      if (e instanceof E) {
        let { value: i } = e;
        switch (typeof i) {
          case "boolean":
            return c(this, h, d).call(
              this,
              { type: "BooleanLiteral", value: i, ...e.sourceSpan },
              { hasParentParens: s },
            );
          case "number":
            return c(this, h, d).call(
              this,
              { type: "NumericLiteral", value: i, ...e.sourceSpan },
              { hasParentParens: s },
            );
          case "object":
            return c(this, h, d).call(
              this,
              { type: "NullLiteral", ...e.sourceSpan },
              { hasParentParens: s },
            );
          case "string":
            return c(this, h, d).call(
              this,
              { type: "StringLiteral", value: i, ...e.sourceSpan },
              { hasParentParens: s },
            );
          case "undefined":
            return c(this, h, d).call(
              this,
              { type: "Identifier", name: "undefined", ...e.sourceSpan },
              { hasParentParens: s },
            );
          default:
            throw new Error(
              `Unexpected LiteralPrimitive value type ${typeof i}`,
            );
        }
      }
      if (e instanceof pt || e instanceof D) {
        let i = e instanceof D,
          { receiver: n, args: a } = e,
          o =
            a.length === 1
              ? [c(this, h, v).call(this, a[0], !0)]
              : a.map((S) => c(this, h, v).call(this, S)),
          p = c(this, h, v).call(this, n),
          u = Be(p),
          f = i || u ? "OptionalCallExpression" : "CallExpression";
        return c(this, h, d).call(
          this,
          {
            type: f,
            callee: p,
            arguments: o,
            optional: f === "OptionalCallExpression" ? i : void 0,
            start: k(p),
            end: e.sourceSpan.end,
          },
          { hasParentParens: s },
        );
      }
      if (e instanceof ht) {
        let i = c(this, h, v).call(this, e.expression);
        return c(this, h, d).call(
          this,
          {
            type: "TSNonNullExpression",
            expression: i,
            start: k(i),
            end: e.sourceSpan.end,
          },
          { hasParentParens: s },
        );
      }
      if (e instanceof ct) {
        let i = c(this, h, v).call(this, e.expression);
        return c(this, h, d).call(
          this,
          {
            type: "UnaryExpression",
            prefix: !0,
            operator: "!",
            argument: i,
            start: e.sourceSpan.start,
            end: N(i),
          },
          { hasParentParens: s },
        );
      }
      if (e instanceof M || e instanceof _) {
        let { receiver: i, name: n } = e,
          a = this.getCharacterLastIndex(/\S/, e.sourceSpan.end - 1) + 1,
          o = c(this, h, d).call(
            this,
            { type: "Identifier", name: n, start: a - n.length, end: a },
            Te(i, O(this, St)) ? { hasParentParens: s } : {},
          );
        return c(this, h, Ot).call(this, i, o, {
          computed: !1,
          optional: e instanceof _,
          hasParentParens: s,
        });
      }
      if (e instanceof rt) {
        let i = c(this, h, v).call(this, e.key),
          n = c(this, h, v).call(this, e.value),
          a = c(this, h, Ot).call(this, e.receiver, i, {
            computed: !0,
            optional: !1,
            end: this.getCharacterIndex("]", N(i)) + 1,
          });
        return c(this, h, d).call(
          this,
          {
            type: "AssignmentExpression",
            left: a,
            operator: "=",
            right: n,
            start: k(a),
            end: N(n),
          },
          { hasParentParens: s },
        );
      }
      if (e instanceof et) {
        let { receiver: i, name: n, value: a } = e,
          o = c(this, h, v).call(this, a),
          p =
            this.getCharacterLastIndex(
              /\S/,
              this.getCharacterLastIndex("=", k(o) - 1) - 1,
            ) + 1,
          u = c(this, h, d).call(this, {
            type: "Identifier",
            name: n,
            start: p - n.length,
            end: p,
          }),
          f = c(this, h, Ot).call(this, i, u, { computed: !1, optional: !1 });
        return c(this, h, d).call(
          this,
          {
            type: "AssignmentExpression",
            left: f,
            operator: "=",
            right: o,
            start: k(f),
            end: N(o),
          },
          { hasParentParens: s },
        );
      }
      throw Object.assign(new Error("Unexpected node"), { node: e });
    });
  function Me(r, t) {
    return new It(r, t).node;
  }
  function _e(r) {
    return r instanceof ut;
  }
  function Ue(r) {
    return r instanceof W;
  }
  var wt,
    q,
    x,
    Fe,
    C,
    te,
    ee,
    se,
    De,
    We,
    Ge,
    Ve,
    Xt = class extends It {
      constructor(e, s) {
        super(void 0, s);
        P(this, x);
        P(this, wt);
        P(this, q);
        Y(this, wt, e), Y(this, q, s);
        for (let i of e) c(this, x, De).call(this, i);
      }
      get expressions() {
        return c(this, x, Ge).call(this);
      }
    };
  (wt = new WeakMap()),
    (q = new WeakMap()),
    (x = new WeakSet()),
    (Fe = function () {
      return O(this, wt)[0].key;
    }),
    (C = function (e, { stripSpaces: s = !0 } = {}) {
      return this.createNode(e, { stripSpaces: s });
    }),
    (te = function (e) {
      return this.transformNode(e);
    }),
    (ee = function (e) {
      return Ne(e.slice(O(this, x, Fe).source.length));
    }),
    (se = function (e) {
      let s = O(this, q);
      if (s[e.start] !== '"' && s[e.start] !== "'") return;
      let i = s[e.start],
        n = !1;
      for (let a = e.start + 1; a < s.length; a++)
        switch (s[a]) {
          case i:
            if (!n) {
              e.end = a + 1;
              return;
            }
          default:
            n = !1;
            break;
          case "\\":
            n = !n;
            break;
        }
    }),
    (De = function (e) {
      c(this, x, se).call(this, e.key.span),
        Ue(e) && e.value && c(this, x, se).call(this, e.value.span);
    }),
    (We = function (e) {
      if (!e.value || e.value.source) return e.value;
      let s = this.getCharacterIndex(/\S/, e.sourceSpan.start);
      return { source: "$implicit", span: { start: s, end: s } };
    }),
    (Ge = function () {
      let e = O(this, wt),
        [s] = e,
        i =
          O(this, q).slice(s.sourceSpan.start, s.sourceSpan.end).trim()
            .length === 0
            ? e.slice(1)
            : e,
        n = [],
        a = null;
      for (let [o, p] of i.entries()) {
        if (a && _e(a) && Ue(p) && p.value && p.value.source === a.key.source) {
          let u = c(this, x, C).call(this, {
              type: "NGMicrosyntaxKey",
              name: p.key.source,
              ...p.key.span,
            }),
            f = (y, w) => ({
              ...y,
              ...this.transformSpan({ start: y.start, end: w }),
            }),
            S = (y) => ({ ...f(y, u.end), alias: u }),
            g = n.pop();
          if (g.type === "NGMicrosyntaxExpression") n.push(S(g));
          else if (g.type === "NGMicrosyntaxKeyedExpression") {
            let y = S(g.expression);
            n.push(f({ ...g, expression: y }, y.end));
          } else throw new Error(`Unexpected type ${g.type}`);
        } else n.push(c(this, x, Ve).call(this, p, o));
        a = p;
      }
      return c(this, x, C).call(this, {
        type: "NGMicrosyntax",
        body: n,
        ...(n.length === 0
          ? e[0].sourceSpan
          : { start: n[0].start, end: Tt(!1, n, -1).end }),
      });
    }),
    (Ve = function (e, s) {
      if (_e(e)) {
        let { key: i, value: n } = e;
        return n
          ? s === 0
            ? c(this, x, C).call(this, {
                type: "NGMicrosyntaxExpression",
                expression: c(this, x, te).call(this, n.ast),
                alias: null,
                ...n.sourceSpan,
              })
            : c(this, x, C).call(this, {
                type: "NGMicrosyntaxKeyedExpression",
                key: c(this, x, C).call(this, {
                  type: "NGMicrosyntaxKey",
                  name: c(this, x, ee).call(this, i.source),
                  ...i.span,
                }),
                expression: c(this, x, C).call(this, {
                  type: "NGMicrosyntaxExpression",
                  expression: c(this, x, te).call(this, n.ast),
                  alias: null,
                  ...n.sourceSpan,
                }),
                start: i.span.start,
                end: n.sourceSpan.end,
              })
          : c(this, x, C).call(this, {
              type: "NGMicrosyntaxKey",
              name: c(this, x, ee).call(this, i.source),
              ...i.span,
            });
      } else {
        let { key: i, sourceSpan: n } = e;
        if (/^let\s$/.test(O(this, q).slice(n.start, n.start + 4))) {
          let { value: o } = e;
          return c(this, x, C).call(this, {
            type: "NGMicrosyntaxLet",
            key: c(this, x, C).call(this, {
              type: "NGMicrosyntaxKey",
              name: i.source,
              ...i.span,
            }),
            value: o
              ? c(this, x, C).call(this, {
                  type: "NGMicrosyntaxKey",
                  name: o.source,
                  ...o.span,
                })
              : null,
            start: n.start,
            end: o ? o.span.end : i.span.end,
          });
        } else {
          let o = c(this, x, We).call(this, e);
          return c(this, x, C).call(this, {
            type: "NGMicrosyntaxAs",
            key: c(this, x, C).call(this, {
              type: "NGMicrosyntaxKey",
              name: o.source,
              ...o.span,
            }),
            alias: c(this, x, C).call(this, {
              type: "NGMicrosyntaxKey",
              name: i.source,
              ...i.span,
            }),
            start: o.span.start,
            end: i.span.end,
          });
        }
      }
    });
  function Qe(r, t) {
    return new Xt(r, t).expressions;
  }
  function Mt({ result: { ast: r }, text: t, comments: e }) {
    return Object.assign(Me(r, t), { comments: e });
  }
  function ze({ result: { templateBindings: r }, text: t }) {
    return Qe(r, t);
  }
  var qe = (r) => Mt(Le(r));
  var He = (r) => Mt(Pe(r)),
    re = (r) => Mt(Re(r)),
    je = (r) => ze(be(r));
  function ie(r) {
    var s, i, n;
    let t = ((s = r.range) == null ? void 0 : s[0]) ?? r.start,
      e =
        (n =
          ((i = r.declaration) == null ? void 0 : i.decorators) ??
          r.decorators) == null
          ? void 0
          : n[0];
    return e ? Math.min(ie(e), t) : t;
  }
  function Ye(r) {
    var t;
    return ((t = r.range) == null ? void 0 : t[1]) ?? r.end;
  }
  function _t(r) {
    return {
      astFormat: "estree",
      parse(t) {
        let e = r(t);
        return {
          type: "NGRoot",
          node:
            r === re && e.type !== "NGChainedExpression"
              ? { ...e, type: "NGChainedExpression", expressions: [e] }
              : e,
        };
      },
      locStart: ie,
      locEnd: Ye,
    };
  }
  var Xs = _t(re),
    tr = _t(qe),
    er = _t(He),
    sr = _t(je);
  return ss(rr);
});