soonjs 0.0.12 → 0.0.13

package/dist/angular-B-EYu3Xp.js

@@ -0,0 +1,1448 @@
+var re = Object.defineProperty;
+var ne = (t, e, s) => e in t ? re(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var xt = (t, e, s) => ne(t, typeof e != "symbol" ? e + "" : e, s);
+var ae = Object.defineProperty, Kt = (t) => {
+  throw TypeError(t);
+}, Tt = (t, e) => {
+  for (var s in e) ae(t, s, { get: e[s], enumerable: !0 });
+}, pt = (t, e, s) => e.has(t) || Kt("Cannot " + s), I = (t, e, s) => (pt(t, e, "read from private field"), s ? s.call(t) : e.get(t)), B = (t, e, s) => e.has(t) ? Kt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, s), q = (t, e, s, i) => (pt(t, e, "write to private field"), e.set(t, s), s), h = (t, e, s) => (pt(t, e, "access private method"), s), Lt = {};
+Tt(Lt, { parsers: () => _t });
+var _t = {};
+Tt(_t, { __ng_action: () => ts, __ng_binding: () => es, __ng_directive: () => is, __ng_interpolation: () => ss });
+var et = class {
+  constructor(t, e, s, i) {
+    this.input = e, this.errLocation = s, this.ctxLocation = i, this.message = `Parser Error: ${t} ${s} [${e}] in ${i}`;
+  }
+}, V = class {
+  constructor(t, e) {
+    this.start = t, this.end = e;
+  }
+  toAbsolute(t) {
+    return new T(t + this.start, t + this.end);
+  }
+}, g = class {
+  constructor(t, e) {
+    this.span = t, this.sourceSpan = e;
+  }
+  toString() {
+    return "AST";
+  }
+}, D = class extends g {
+  constructor(t, e, s) {
+    super(t, e), this.nameSpan = s;
+  }
+}, P = class extends g {
+  visit(t, e = null) {
+  }
+}, z = class extends g {
+  visit(t, e = null) {
+    return t.visitImplicitReceiver(this, e);
+  }
+}, he = class extends z {
+  visit(t, e = null) {
+    var s;
+    return (s = t.visitThisReceiver) == null ? void 0 : s.call(t, this, e);
+  }
+}, $t = class extends g {
+  constructor(t, e, s) {
+    super(t, e), this.expressions = s;
+  }
+  visit(t, e = null) {
+    return t.visitChain(this, e);
+  }
+}, Mt = class extends g {
+  constructor(t, e, s, i, r) {
+    super(t, e), this.condition = s, this.trueExp = i, this.falseExp = r;
+  }
+  visit(t, e = null) {
+    return t.visitConditional(this, e);
+  }
+}, st = class extends D {
+  constructor(t, e, s, i, r) {
+    super(t, e, s), this.receiver = i, this.name = r;
+  }
+  visit(t, e = null) {
+    return t.visitPropertyRead(this, e);
+  }
+}, Bt = class extends D {
+  constructor(t, e, s, i, r, n) {
+    super(t, e, s), this.receiver = i, this.name = r, this.value = n;
+  }
+  visit(t, e = null) {
+    return t.visitPropertyWrite(this, e);
+  }
+}, it = class extends D {
+  constructor(t, e, s, i, r) {
+    super(t, e, s), this.receiver = i, this.name = r;
+  }
+  visit(t, e = null) {
+    return t.visitSafePropertyRead(this, e);
+  }
+}, Wt = class extends g {
+  constructor(t, e, s, i) {
+    super(t, e), this.receiver = s, this.key = i;
+  }
+  visit(t, e = null) {
+    return t.visitKeyedRead(this, e);
+  }
+}, rt = class extends g {
+  constructor(t, e, s, i) {
+    super(t, e), this.receiver = s, this.key = i;
+  }
+  visit(t, e = null) {
+    return t.visitSafeKeyedRead(this, e);
+  }
+}, Ut = class extends g {
+  constructor(t, e, s, i, r) {
+    super(t, e), this.receiver = s, this.key = i, this.value = r;
+  }
+  visit(t, e = null) {
+    return t.visitKeyedWrite(this, e);
+  }
+}, Rt = class extends D {
+  constructor(t, e, s, i, r, n) {
+    super(t, e, n), this.exp = s, this.name = i, this.args = r;
+  }
+  visit(t, e = null) {
+    return t.visitPipe(this, e);
+  }
+}, O = class extends g {
+  constructor(t, e, s) {
+    super(t, e), this.value = s;
+  }
+  visit(t, e = null) {
+    return t.visitLiteralPrimitive(this, e);
+  }
+}, Gt = class extends g {
+  constructor(t, e, s) {
+    super(t, e), this.expressions = s;
+  }
+  visit(t, e = null) {
+    return t.visitLiteralArray(this, e);
+  }
+}, Vt = class extends g {
+  constructor(t, e, s, i) {
+    super(t, e), this.keys = s, this.values = i;
+  }
+  visit(t, e = null) {
+    return t.visitLiteralMap(this, e);
+  }
+}, Ft = class extends g {
+  constructor(t, e, s, i) {
+    super(t, e), this.strings = s, this.expressions = i;
+  }
+  visit(t, e = null) {
+    return t.visitInterpolation(this, e);
+  }
+}, E = class extends g {
+  constructor(t, e, s, i, r) {
+    super(t, e), this.operation = s, this.left = i, this.right = r;
+  }
+  visit(t, e = null) {
+    return t.visitBinary(this, e);
+  }
+}, nt = class at extends E {
+  static createMinus(e, s, i) {
+    return new at(e, s, "-", i, "-", new O(e, s, 0), i);
+  }
+  static createPlus(e, s, i) {
+    return new at(e, s, "+", i, "-", i, new O(e, s, 0));
+  }
+  constructor(e, s, i, r, n, a, l) {
+    super(e, s, n, a, l), this.operator = i, this.expr = r, this.left = null, this.right = null, this.operation = null;
+  }
+  visit(e, s = null) {
+    return e.visitUnary !== void 0 ? e.visitUnary(this, s) : e.visitBinary(this, s);
+  }
+}, jt = class extends g {
+  constructor(t, e, s) {
+    super(t, e), this.expression = s;
+  }
+  visit(t, e = null) {
+    return t.visitPrefixNot(this, e);
+  }
+}, qt = class extends g {
+  constructor(t, e, s) {
+    super(t, e), this.expression = s;
+  }
+  visit(t, e = null) {
+    return t.visitNonNullAssert(this, e);
+  }
+}, zt = class extends g {
+  constructor(t, e, s, i, r) {
+    super(t, e), this.receiver = s, this.args = i, this.argumentSpan = r;
+  }
+  visit(t, e = null) {
+    return t.visitCall(this, e);
+  }
+}, ht = class extends g {
+  constructor(t, e, s, i, r) {
+    super(t, e), this.receiver = s, this.args = i, this.argumentSpan = r;
+  }
+  visit(t, e = null) {
+    return t.visitSafeCall(this, e);
+  }
+}, T = class {
+  constructor(t, e) {
+    this.start = t, this.end = e;
+  }
+}, L = class extends g {
+  constructor(t, e, s, i, r) {
+    super(new V(0, e === null ? 0 : e.length), new T(i, e === null ? i : i + e.length)), this.ast = t, this.source = e, this.location = s, this.errors = r;
+  }
+  visit(t, e = null) {
+    return t.visitASTWithSource ? t.visitASTWithSource(this, e) : this.ast.visit(t, e);
+  }
+  toString() {
+    return `${this.source} in ${this.location}`;
+  }
+}, ot = class {
+  constructor(t, e, s) {
+    this.sourceSpan = t, this.key = e, this.value = s;
+  }
+}, Dt = class {
+  constructor(t, e, s) {
+    this.sourceSpan = t, this.key = e, this.value = s;
+  }
+}, oe = 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);
+  }
+}, vt;
+(function(t) {
+  t[t.DEFAULT = 0] = "DEFAULT", t[t.LITERAL_ATTR = 1] = "LITERAL_ATTR", t[t.ANIMATION = 2] = "ANIMATION", t[t.TWO_WAY = 3] = "TWO_WAY";
+})(vt || (vt = {}));
+var yt;
+(function(t) {
+  t[t.Regular = 0] = "Regular", t[t.Animation = 1] = "Animation", t[t.TwoWay = 2] = "TwoWay";
+})(yt || (yt = {}));
+var gt;
+(function(t) {
+  t[t.Property = 0] = "Property", t[t.Attribute = 1] = "Attribute", t[t.Class = 2] = "Class", t[t.Style = 3] = "Style", t[t.Animation = 4] = "Animation", t[t.TwoWay = 5] = "TwoWay";
+})(gt || (gt = {}));
+function le(t) {
+  return t >= 9 && t <= 32 || t == 160;
+}
+function K(t) {
+  return 48 <= t && t <= 57;
+}
+function ce(t) {
+  return t >= 97 && t <= 122 || t >= 65 && t <= 90;
+}
+function mt(t) {
+  return t === 39 || t === 34 || t === 96;
+}
+var p;
+(function(t) {
+  t[t.Character = 0] = "Character", t[t.Identifier = 1] = "Identifier", t[t.PrivateIdentifier = 2] = "PrivateIdentifier", t[t.Keyword = 3] = "Keyword", t[t.String = 4] = "String", t[t.Operator = 5] = "Operator", t[t.Number = 6] = "Number", t[t.Error = 7] = "Error";
+})(p || (p = {}));
+var pe = ["var", "let", "as", "null", "undefined", "true", "false", "if", "else", "this"], ue = class {
+  tokenize(t) {
+    let e = new me(t), s = [], i = e.scanToken();
+    for (; i != null; ) s.push(i), i = e.scanToken();
+    return s;
+  }
+}, b = class {
+  constructor(t, e, s, i, r) {
+    this.index = t, this.end = e, this.type = s, this.numValue = i, this.strValue = r;
+  }
+  isCharacter(t) {
+    return this.type == p.Character && this.numValue == t;
+  }
+  isNumber() {
+    return this.type == p.Number;
+  }
+  isString() {
+    return this.type == p.String;
+  }
+  isOperator(t) {
+    return this.type == p.Operator && this.strValue == t;
+  }
+  isIdentifier() {
+    return this.type == p.Identifier;
+  }
+  isPrivateIdentifier() {
+    return this.type == p.PrivateIdentifier;
+  }
+  isKeyword() {
+    return this.type == p.Keyword;
+  }
+  isKeywordLet() {
+    return this.type == p.Keyword && this.strValue == "let";
+  }
+  isKeywordAs() {
+    return this.type == p.Keyword && this.strValue == "as";
+  }
+  isKeywordNull() {
+    return this.type == p.Keyword && this.strValue == "null";
+  }
+  isKeywordUndefined() {
+    return this.type == p.Keyword && this.strValue == "undefined";
+  }
+  isKeywordTrue() {
+    return this.type == p.Keyword && this.strValue == "true";
+  }
+  isKeywordFalse() {
+    return this.type == p.Keyword && this.strValue == "false";
+  }
+  isKeywordThis() {
+    return this.type == p.Keyword && this.strValue == "this";
+  }
+  isError() {
+    return this.type == p.Error;
+  }
+  toNumber() {
+    return this.type == p.Number ? this.numValue : -1;
+  }
+  toString() {
+    switch (this.type) {
+      case p.Character:
+      case p.Identifier:
+      case p.Keyword:
+      case p.Operator:
+      case p.PrivateIdentifier:
+      case p.String:
+      case p.Error:
+        return this.strValue;
+      case p.Number:
+        return this.numValue.toString();
+      default:
+        return null;
+    }
+  }
+};
+function wt(t, e, s) {
+  return new b(t, e, p.Character, s, String.fromCharCode(s));
+}
+function de(t, e, s) {
+  return new b(t, e, p.Identifier, 0, s);
+}
+function fe(t, e, s) {
+  return new b(t, e, p.PrivateIdentifier, 0, s);
+}
+function xe(t, e, s) {
+  return new b(t, e, p.Keyword, 0, s);
+}
+function Q(t, e, s) {
+  return new b(t, e, p.Operator, 0, s);
+}
+function ve(t, e, s) {
+  return new b(t, e, p.String, 0, s);
+}
+function ye(t, e, s) {
+  return new b(t, e, p.Number, s, "");
+}
+function ge(t, e, s) {
+  return new b(t, e, p.Error, 0, s);
+}
+var Y = new b(-1, -1, p.Character, 0, ""), me = 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 (St(s)) return this.scanIdentifier();
+    if (K(s)) return this.scanNumber(i);
+    let r = i;
+    switch (s) {
+      case 46:
+        return this.advance(), K(this.peek) ? this.scanNumber(r) : wt(r, this.index, 46);
+      case 40:
+      case 41:
+      case 123:
+      case 125:
+      case 91:
+      case 93:
+      case 44:
+      case 58:
+      case 59:
+        return this.scanCharacter(r, 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(r, String.fromCharCode(s));
+      case 63:
+        return this.scanQuestion(r);
+      case 60:
+      case 62:
+        return this.scanComplexOperator(r, String.fromCharCode(s), 61, "=");
+      case 33:
+      case 61:
+        return this.scanComplexOperator(r, String.fromCharCode(s), 61, "=", 61, "=");
+      case 38:
+        return this.scanComplexOperator(r, "&", 38, "&");
+      case 124:
+        return this.scanComplexOperator(r, "|", 124, "|");
+      case 160:
+        for (; le(this.peek); ) this.advance();
+        return this.scanToken();
+    }
+    return this.advance(), this.error(`Unexpected character [${String.fromCharCode(s)}]`, 0);
+  }
+  scanCharacter(t, e) {
+    return this.advance(), wt(t, this.index, e);
+  }
+  scanOperator(t, e) {
+    return this.advance(), Q(t, this.index, e);
+  }
+  scanComplexOperator(t, e, s, i, r, n) {
+    this.advance();
+    let a = e;
+    return this.peek == s && (this.advance(), a += i), r != null && this.peek == r && (this.advance(), a += n), Q(t, this.index, a);
+  }
+  scanIdentifier() {
+    let t = this.index;
+    for (this.advance(); Ct(this.peek); ) this.advance();
+    let e = this.input.substring(t, this.index);
+    return pe.indexOf(e) > -1 ? xe(t, this.index, e) : de(t, this.index, e);
+  }
+  scanPrivateIdentifier() {
+    let t = this.index;
+    if (this.advance(), !St(this.peek)) return this.error("Invalid character [#]", -1);
+    for (; Ct(this.peek); ) this.advance();
+    let e = this.input.substring(t, this.index);
+    return fe(t, this.index, e);
+  }
+  scanNumber(t) {
+    let e = this.index === t, s = !1;
+    for (this.advance(); ; ) {
+      if (!K(this.peek)) if (this.peek === 95) {
+        if (!K(this.input.charCodeAt(this.index - 1)) || !K(this.input.charCodeAt(this.index + 1))) return this.error("Invalid numeric separator", 0);
+        s = !0;
+      } else if (this.peek === 46) e = !1;
+      else if (we(this.peek)) {
+        if (this.advance(), Se(this.peek) && this.advance(), !K(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 r = e ? ke(i) : parseFloat(i);
+    return ye(t, this.index, r);
+  }
+  scanString() {
+    let t = this.index, e = this.peek;
+    this.advance();
+    let s = "", i = this.index, r = this.input;
+    for (; this.peek != e; ) if (this.peek == 92) {
+      s += r.substring(i, this.index);
+      let a;
+      if (this.advance(), this.peek == 117) {
+        let l = r.substring(this.index + 1, this.index + 5);
+        if (/^[0-9a-f]+$/i.test(l)) a = parseInt(l, 16);
+        else return this.error(`Invalid unicode escape [\\u${l}]`, 0);
+        for (let c = 0; c < 5; c++) this.advance();
+      } else a = Ce(this.peek), this.advance();
+      s += String.fromCharCode(a), i = this.index;
+    } else {
+      if (this.peek == 0) return this.error("Unterminated quote", 0);
+      this.advance();
+    }
+    let n = r.substring(i, this.index);
+    return this.advance(), ve(t, this.index, s + n);
+  }
+  scanQuestion(t) {
+    this.advance();
+    let e = "?";
+    return (this.peek === 63 || this.peek === 46) && (e += this.peek === 46 ? "." : "?", this.advance()), Q(t, this.index, e);
+  }
+  error(t, e) {
+    let s = this.index + e;
+    return ge(s, this.index, `Lexer Error: ${t} at column ${s} in expression [${this.input}]`);
+  }
+};
+function St(t) {
+  return 97 <= t && t <= 122 || 65 <= t && t <= 90 || t == 95 || t == 36;
+}
+function Ct(t) {
+  return ce(t) || K(t) || t == 95 || t == 36;
+}
+function we(t) {
+  return t == 101 || t == 69;
+}
+function Se(t) {
+  return t == 45 || t == 43;
+}
+function Ce(t) {
+  switch (t) {
+    case 110:
+      return 10;
+    case 102:
+      return 12;
+    case 114:
+      return 13;
+    case 116:
+      return 9;
+    case 118:
+      return 11;
+    default:
+      return t;
+  }
+}
+function ke(t) {
+  let e = parseInt(t);
+  if (isNaN(e)) throw new Error("Invalid integer literal when parsing " + t);
+  return e;
+}
+var Pe = [/@/, /^\s*$/, /[<>]/, /^[{}]$/, /&(#|[a-z])/i, /^\/\//];
+function Oe(t, e) {
+  if (e != null && !(Array.isArray(e) && e.length == 2)) throw new Error(`Expected '${t}' to be an array, [start, end].`);
+  if (e != null) {
+    let s = e[0], i = e[1];
+    Pe.forEach((r) => {
+      if (r.test(s) || r.test(i)) throw new Error(`['${s}', '${i}'] contains unusable interpolation symbol.`);
+    });
+  }
+}
+var Ee = class Ht {
+  static fromArray(e) {
+    return e ? (Oe("interpolation", e), new Ht(e[0], e[1])) : _;
+  }
+  constructor(e, s) {
+    this.start = e, this.end = s;
+  }
+}, _ = new Ee("{{", "}}"), Ie = class {
+  constructor(t, e, s) {
+    this.strings = t, this.expressions = e, this.offsets = s;
+  }
+}, be = class {
+  constructor(t, e, s) {
+    this.templateBindings = t, this.warnings = e, this.errors = s;
+  }
+}, Jt = class {
+  constructor(t) {
+    this._lexer = t, this.errors = [];
+  }
+  parseAction(t, e, s, i = _) {
+    this._checkNoInterpolation(t, e, i);
+    let r = this._stripComments(t), n = this._lexer.tokenize(r), a = new W(t, e, s, n, 1, this.errors, 0).parseChain();
+    return new L(a, t, e, s, this.errors);
+  }
+  parseBinding(t, e, s, i = _) {
+    let r = this._parseBindingAst(t, e, s, i);
+    return new L(r, t, e, s, this.errors);
+  }
+  checkSimpleExpression(t) {
+    let e = new Ae();
+    return t.visit(e), e.errors;
+  }
+  parseSimpleBinding(t, e, s, i = _) {
+    let r = this._parseBindingAst(t, e, s, i), n = this.checkSimpleExpression(r);
+    return n.length > 0 && this._reportError(`Host binding expression cannot contain ${n.join(" ")}`, t, e), new L(r, t, e, s, this.errors);
+  }
+  _reportError(t, e, s, i) {
+    this.errors.push(new et(t, e, s, i));
+  }
+  _parseBindingAst(t, e, s, i) {
+    this._checkNoInterpolation(t, e, i);
+    let r = this._stripComments(t), n = this._lexer.tokenize(r);
+    return new W(t, e, s, n, 0, this.errors, 0).parseChain();
+  }
+  parseTemplateBindings(t, e, s, i, r) {
+    let n = this._lexer.tokenize(e);
+    return new W(e, s, r, n, 0, this.errors, 0).parseTemplateBindings({ source: t, span: new T(i, i + t.length) });
+  }
+  parseInterpolation(t, e, s, i, r = _) {
+    let { strings: n, expressions: a, offsets: l } = this.splitInterpolation(t, e, i, r);
+    if (a.length === 0) return null;
+    let c = [];
+    for (let d = 0; d < a.length; ++d) {
+      let v = a[d].text, y = this._stripComments(v), k = this._lexer.tokenize(y), m = new W(t, e, s, k, 0, this.errors, l[d]).parseChain();
+      c.push(m);
+    }
+    return this.createInterpolationAst(n.map((d) => d.text), c, t, e, s);
+  }
+  parseInterpolationExpression(t, e, s) {
+    let i = this._stripComments(t), r = this._lexer.tokenize(i), n = new W(t, e, s, r, 0, this.errors, 0).parseChain(), a = ["", ""];
+    return this.createInterpolationAst(a, [n], t, e, s);
+  }
+  createInterpolationAst(t, e, s, i, r) {
+    let n = new V(0, s.length), a = new Ft(n, n.toAbsolute(r), t, e);
+    return new L(a, s, i, r, this.errors);
+  }
+  splitInterpolation(t, e, s, i = _) {
+    let r = [], n = [], a = [], l = s ? Ne(s) : null, c = 0, d = !1, v = !1, { start: y, end: k } = i;
+    for (; c < t.length; ) if (d) {
+      let m = c, N = m + y.length, A = this._getInterpolationEndIndex(t, k, N);
+      if (A === -1) {
+        d = !1, v = !0;
+        break;
+      }
+      let F = A + k.length, ft = t.substring(N, A);
+      ft.trim().length === 0 && this._reportError("Blank expressions are not allowed in interpolated strings", t, `at column ${c} in`, e), n.push({ text: ft, start: m, end: F });
+      let ie = ((l == null ? void 0 : l.get(m)) ?? m) + y.length;
+      a.push(ie), c = F, d = !1;
+    } else {
+      let m = c;
+      c = t.indexOf(y, c), c === -1 && (c = t.length);
+      let N = t.substring(m, c);
+      r.push({ text: N, start: m, end: c }), d = !0;
+    }
+    if (!d) if (v) {
+      let m = r[r.length - 1];
+      m.text += t.substring(c), m.end = t.length;
+    } else r.push({ text: t.substring(c), start: c, end: t.length });
+    return new Ie(r, n, a);
+  }
+  wrapLiteralPrimitive(t, e, s) {
+    let i = new V(0, t == null ? 0 : t.length);
+    return new L(new O(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), r = t.charCodeAt(s + 1);
+      if (i === 47 && r == 47 && e == null) return s;
+      e === i ? e = null : e == null && mt(i) && (e = i);
+    }
+    return null;
+  }
+  _checkNoInterpolation(t, e, { start: s, end: i }) {
+    let r = -1, n = -1;
+    for (let a of this._forEachUnquotedChar(t, 0)) if (r === -1) t.startsWith(s) && (r = a);
+    else if (n = this._getInterpolationEndIndex(t, i, a), n > -1) break;
+    r > -1 && n > -1 && this._reportError(`Got interpolation (${s}${i}) where expression was expected`, t, `at column ${r} 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 r = e; r < t.length; r++) {
+      let n = t[r];
+      mt(t.charCodeAt(r)) && (s === null || s === n) && i % 2 === 0 ? s = s === null ? n : null : s === null && (yield r), i = n === "\\" ? i + 1 : 0;
+    }
+  }
+}, $;
+(function(t) {
+  t[t.None = 0] = "None", t[t.Writable = 1] = "Writable";
+})($ || ($ = {}));
+var W = class {
+  constructor(t, e, s, i, r, n, a) {
+    this.input = t, this.location = e, this.absoluteOffset = s, this.tokens = i, this.parseFlags = r, this.errors = n, this.offset = a, this.rparensExpected = 0, this.rbracketsExpected = 0, this.rbracesExpected = 0, this.context = $.None, this.sourceSpanCache = /* @__PURE__ */ new Map(), this.index = 0;
+  }
+  peek(t) {
+    let e = this.index + t;
+    return e < this.tokens.length ? this.tokens[e] : Y;
+  }
+  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 V(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 === Y ? "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 P(this.span(s, i), this.sourceSpan(s, i));
+    }
+    return t.length == 1 ? t[0] : new $t(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(), r, n;
+        i !== null ? r = this.sourceSpan(s) : (i = "", n = this.next.index !== -1 ? this.next.index : this.input.length + this.offset, r = new V(n, n).toAbsolute(this.absoluteOffset));
+        let a = [];
+        for (; this.consumeOptionalCharacter(58); ) a.push(this.parseExpression());
+        e = new Rt(this.span(t), this.sourceSpan(t, n), e, i, a, r);
+      } 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 r = this.inputIndex, n = this.input.substring(t, r);
+        this.error(`Conditional expression ${n} requires all 3 expressions`), i = new P(this.span(t), this.sourceSpan(t));
+      }
+      return new Mt(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 E(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 E(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 E(this.span(t), this.sourceSpan(t), "??", e, s);
+    }
+    return e;
+  }
+  parseEquality() {
+    let t = this.inputIndex, e = this.parseRelational();
+    for (; this.next.type == p.Operator; ) {
+      let s = this.next.strValue;
+      switch (s) {
+        case "==":
+        case "===":
+        case "!=":
+        case "!==":
+          this.advance();
+          let i = this.parseRelational();
+          e = new E(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 == p.Operator; ) {
+      let s = this.next.strValue;
+      switch (s) {
+        case "<":
+        case ">":
+        case "<=":
+        case ">=":
+          this.advance();
+          let i = this.parseAdditive();
+          e = new E(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 == p.Operator; ) {
+      let s = this.next.strValue;
+      switch (s) {
+        case "+":
+        case "-":
+          this.advance();
+          let i = this.parseMultiplicative();
+          e = new E(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 == p.Operator; ) {
+      let s = this.next.strValue;
+      switch (s) {
+        case "*":
+        case "%":
+        case "/":
+          this.advance();
+          let i = this.parsePrefix();
+          e = new E(this.span(t), this.sourceSpan(t), s, e, i);
+          continue;
+      }
+      break;
+    }
+    return e;
+  }
+  parsePrefix() {
+    if (this.next.type == p.Operator) {
+      let t = this.inputIndex, e = this.next.strValue, s;
+      switch (e) {
+        case "+":
+          return this.advance(), s = this.parsePrefix(), nt.createPlus(this.span(t), this.sourceSpan(t), s);
+        case "-":
+          return this.advance(), s = this.parsePrefix(), nt.createMinus(this.span(t), this.sourceSpan(t), s);
+        case "!":
+          return this.advance(), s = this.parsePrefix(), new jt(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 qt(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 O(this.span(t), this.sourceSpan(t), null);
+      if (this.next.isKeywordUndefined()) return this.advance(), new O(this.span(t), this.sourceSpan(t), void 0);
+      if (this.next.isKeywordTrue()) return this.advance(), new O(this.span(t), this.sourceSpan(t), !0);
+      if (this.next.isKeywordFalse()) return this.advance(), new O(this.span(t), this.sourceSpan(t), !1);
+      if (this.next.isKeywordThis()) return this.advance(), new he(this.span(t), this.sourceSpan(t));
+      if (this.consumeOptionalCharacter(91)) {
+        this.rbracketsExpected++;
+        let e = this.parseExpressionList(93);
+        return this.rbracketsExpected--, this.expectCharacter(93), new Gt(this.span(t), this.sourceSpan(t), e);
+      } else {
+        if (this.next.isCharacter(123)) return this.parseLiteralMap();
+        if (this.next.isIdentifier()) return this.parseAccessMember(new z(this.span(t), this.sourceSpan(t)), t, !1);
+        if (this.next.isNumber()) {
+          let e = this.next.toNumber();
+          return this.advance(), new O(this.span(t), this.sourceSpan(t), e);
+        } else if (this.next.isString()) {
+          let e = this.next.toString();
+          return this.advance(), new O(this.span(t), this.sourceSpan(t), e);
+        } else return this.next.isPrivateIdentifier() ? (this._reportErrorForPrivateIdentifier(this.next, null), new P(this.span(t), this.sourceSpan(t))) : this.index >= this.tokens.length ? (this.error(`Unexpected end of expression: ${this.input}`), new P(this.span(t), this.sourceSpan(t))) : (this.error(`Unexpected token ${this.next}`), new P(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, r = this.next.isString(), n = this.expectIdentifierOrKeywordOrString(), a = { key: n, quoted: r };
+        if (t.push(a), r) this.expectCharacter(58), e.push(this.parsePipe());
+        else if (this.consumeOptionalCharacter(58)) e.push(this.parsePipe());
+        else {
+          a.isShorthandInitialized = !0;
+          let l = this.span(i), c = this.sourceSpan(i);
+          e.push(new st(l, c, c, new z(l, c), n));
+        }
+      } while (this.consumeOptionalCharacter(44) && !this.next.isCharacter(125));
+      this.rbracesExpected--, this.expectCharacter(125);
+    }
+    return new Vt(this.span(s), this.sourceSpan(s), t, e);
+  }
+  parseAccessMember(t, e, s) {
+    let i = this.inputIndex, r = this.withContext($.Writable, () => {
+      let l = this.expectIdentifierOrKeyword() ?? "";
+      return l.length === 0 && this.error("Expected identifier for property access", t.span.end), l;
+    }), n = this.sourceSpan(i), a;
+    if (s) this.consumeOptionalOperator("=") ? (this.error("The '?.' operator cannot be used in the assignment"), a = new P(this.span(e), this.sourceSpan(e))) : a = new it(this.span(e), this.sourceSpan(e), n, t, r);
+    else if (this.consumeOptionalOperator("=")) {
+      if (!(this.parseFlags & 1)) return this.error("Bindings cannot contain assignments"), new P(this.span(e), this.sourceSpan(e));
+      let l = this.parseConditional();
+      a = new Bt(this.span(e), this.sourceSpan(e), n, t, r, l);
+    } else a = new st(this.span(e), this.sourceSpan(e), n, t, r);
+    return a;
+  }
+  parseCall(t, e, s) {
+    let i = this.inputIndex;
+    this.rparensExpected++;
+    let r = this.parseCallArguments(), n = this.span(i, this.inputIndex).toAbsolute(this.absoluteOffset);
+    this.expectCharacter(41), this.rparensExpected--;
+    let a = this.span(e), l = this.sourceSpan(e);
+    return s ? new ht(a, l, t, r, n) : new zt(a, l, t, r, n);
+  }
+  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 T(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(), r = this.parseAsBinding(i);
+        r ? e.push(r) : (i.source = t.source + i.source.charAt(0).toUpperCase() + i.source.substring(1), e.push(...this.parseDirectiveKeywordBindings(i)));
+      }
+      this.consumeStatementTerminator();
+    }
+    return new be(e, [], this.errors);
+  }
+  parseKeyedReadOrWrite(t, e, s) {
+    return this.withContext($.Writable, () => {
+      this.rbracketsExpected++;
+      let i = this.parsePipe();
+      if (i instanceof P && 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 r = this.parseConditional();
+        return new Ut(this.span(e), this.sourceSpan(e), t, i, r);
+      }
+      else return s ? new rt(this.span(e), this.sourceSpan(e), t, i) : new Wt(this.span(e), this.sourceSpan(e), t, i);
+      return new P(this.span(e), this.sourceSpan(e));
+    });
+  }
+  parseDirectiveKeywordBindings(t) {
+    let e = [];
+    this.consumeOptionalCharacter(58);
+    let s = this.getDirectiveBoundTarget(), i = this.currentAbsoluteOffset, r = this.parseAsBinding(t);
+    r || (this.consumeStatementTerminator(), i = this.currentAbsoluteOffset);
+    let n = new T(t.span.start, i);
+    return e.push(new Dt(n, t, s)), r && e.push(r), e;
+  }
+  getDirectiveBoundTarget() {
+    if (this.next === Y || this.peekKeywordAs() || this.peekKeywordLet()) return null;
+    let t = this.parsePipe(), { start: e, end: s } = t.span, i = this.input.substring(e, s);
+    return new L(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 T(t.span.start, this.currentAbsoluteOffset);
+    return new ot(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 T(t, this.currentAbsoluteOffset);
+    return new ot(i, e, s);
+  }
+  consumeStatementTerminator() {
+    this.consumeOptionalCharacter(59) || this.consumeOptionalCharacter(44);
+  }
+  error(t, e = null) {
+    this.errors.push(new et(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 & $.Writable) || !t.isOperator("=")); ) this.next.isError() && this.errors.push(new et(this.next.toString(), this.input, this.locationText(), this.location)), this.advance(), t = this.next;
+  }
+}, Ae = class extends oe {
+  constructor() {
+    super(...arguments), this.errors = [];
+  }
+  visitPipe() {
+    this.errors.push("pipes");
+  }
+};
+function Ne(t) {
+  let e = /* @__PURE__ */ new Map(), s = 0, i = 0, r = 0;
+  for (; r < t.length; ) {
+    let n = t[r];
+    if (n.type === 9) {
+      let [a, l] = n.parts;
+      s += l.length, i += a.length;
+    } else {
+      let a = n.parts.reduce((l, c) => l + c.length, 0);
+      i += a, s += a;
+    }
+    e.set(i, s), r++;
+  }
+  return e;
+}
+function kt({ start: t, end: e }, s) {
+  let i = t, r = e;
+  for (; r !== i && /\s/.test(s[r - 1]); ) r--;
+  for (; i !== r && /\s/.test(s[i]); ) i++;
+  return { start: i, end: r };
+}
+function Ke({ start: t, end: e }, s) {
+  let i = t, r = e;
+  for (; r !== s.length && /\s/.test(s[r]); ) r++;
+  for (; i !== 0 && /\s/.test(s[i - 1]); ) i--;
+  return { start: i, end: r };
+}
+function Te(t, e) {
+  return e[t.start - 1] === "(" && e[t.end] === ")" ? { start: t.start - 1, end: t.end + 1 } : t;
+}
+function Le(t, e, s) {
+  let i = 0, r = { start: t.start, end: t.end };
+  for (; ; ) {
+    let n = Ke(r, e), a = Te(n, e);
+    if (n.start === a.start && n.end === a.end) break;
+    r.start = a.start, r.end = a.end, i++;
+  }
+  return { hasParens: (s ? i - 1 : i) !== 0, outerSpan: kt(s ? { start: r.start + 1, end: r.end - 1 } : r, e), innerSpan: kt(t, e) };
+}
+function Qt(t) {
+  return typeof t == "string" ? (e) => e === t : (e) => t.test(e);
+}
+function _e(t, e, s) {
+  let i = Qt(e);
+  for (let r = s; r >= 0; r--) {
+    let n = t[r];
+    if (i(n)) return r;
+  }
+  throw new Error(`Cannot find front char ${e} from index ${s} in ${JSON.stringify(t)}`);
+}
+function $e(t, e, s) {
+  let i = Qt(e);
+  for (let r = s; r < t.length; r++) {
+    let n = t[r];
+    if (i(n)) return r;
+  }
+  throw new Error(`Cannot find character ${e} from index ${s} in ${JSON.stringify(t)}`);
+}
+function Me(t) {
+  return t.slice(0, 1).toLowerCase() + t.slice(1);
+}
+function lt(t) {
+  let { start: e, end: s } = t;
+  return { start: e, end: s, range: [e, s] };
+}
+var Be = (t) => Jt.prototype._commentStart(t);
+function We(t, e) {
+  let s = e ? Be(t) : null;
+  if (s === null) return { text: t, comments: [] };
+  let i = { type: "CommentLine", value: t.slice(s + 2), ...lt({ start: s, end: t.length }) };
+  return { text: t.slice(0, s), comments: [i] };
+}
+function H(t, e = !0) {
+  return (s) => {
+    let i = new ue(), r = new Jt(i), { text: n, comments: a } = We(s, e), l = t(n, r);
+    if (l.errors.length !== 0) {
+      let [{ message: c }] = l.errors;
+      throw new SyntaxError(c.replace(/^Parser Error: | at column \d+ in [^]*$/g, ""));
+    }
+    return { result: l, comments: a, text: n };
+  };
+}
+var Ue = H((t, e) => e.parseBinding(t, "", 0)), Re = H((t, e) => e.parseAction(t, "", 0)), Ge = H((t, e) => e.parseInterpolationExpression(t, "", 0)), Ve = H((t, e) => e.parseTemplateBindings("", t, "", 0, 0), !1), Fe = (t, e, s) => {
+  if (!(t && e == null)) return Array.isArray(e) || typeof e == "string" ? e[s < 0 ? e.length + s : s] : e.at(s);
+}, Yt = Fe, je = class {
+  constructor(t) {
+    xt(this, "text");
+    this.text = t;
+  }
+  getCharacterIndex(t, e) {
+    return $e(this.text, t, e);
+  }
+  getCharacterLastIndex(t, e) {
+    return _e(this.text, t, e);
+  }
+  transformSpan(t, { stripSpaces: e = !1, hasParentParens: s = !1 } = {}) {
+    if (!e) return lt(t);
+    let { outerSpan: i, innerSpan: r, hasParens: n } = Le(t, this.text, s), a = lt(r);
+    return n && (a.extra = { parenthesized: !0, parenStart: i.start, parenEnd: i.end }), a;
+  }
+  createNode(t, { stripSpaces: e = !0, hasParentParens: s = !1 } = {}) {
+    let { type: i, start: r, end: n } = t, a = { ...t, ...this.transformSpan({ start: r, end: n }, { stripSpaces: e, hasParentParens: s }) };
+    switch (i) {
+      case "NumericLiteral":
+      case "StringLiteral": {
+        let l = this.text.slice(a.start, a.end), { value: c } = a;
+        a.extra = { ...a.extra, raw: l, rawValue: c };
+        break;
+      }
+      case "ObjectProperty": {
+        let { shorthand: l } = a;
+        l && (a.extra = { ...a.extra, shorthand: l });
+        break;
+      }
+    }
+    return a;
+  }
+}, qe = je;
+function ut(t) {
+  var e;
+  return !!((e = t.extra) != null && e.parenthesized);
+}
+function S(t) {
+  return ut(t) ? t.extra.parenStart : t.start;
+}
+function C(t) {
+  return ut(t) ? t.extra.parenEnd : t.end;
+}
+function Pt(t) {
+  return (t.type === "OptionalCallExpression" || t.type === "OptionalMemberExpression") && !ut(t);
+}
+function Ot(t, e) {
+  let { start: s, end: i } = t.sourceSpan;
+  return s >= i || /^\s+$/.test(e.slice(s, i));
+}
+var j, R, o, u, U, x, ct, Zt = class extends qe {
+  constructor(t, e) {
+    super(e), B(this, o), B(this, j), B(this, R), q(this, j, t), q(this, R, e);
+  }
+  get node() {
+    return h(this, o, x).call(this, I(this, j));
+  }
+  transformNode(t) {
+    return h(this, o, ct).call(this, t);
+  }
+};
+j = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakSet(), u = function(t, { stripSpaces: e = !0, hasParentParens: s = !1 } = {}) {
+  return this.createNode(t, { stripSpaces: e, hasParentParens: s });
+}, U = function(t, e, { computed: s, optional: i, end: r = C(e), hasParentParens: n = !1 }) {
+  if (Ot(t, I(this, R)) || t.sourceSpan.start === e.start) return e;
+  let a = h(this, o, x).call(this, t), l = Pt(a);
+  return h(this, o, u).call(this, { type: i || l ? "OptionalMemberExpression" : "MemberExpression", object: a, property: e, computed: s, ...i ? { optional: !0 } : l ? { optional: !1 } : void 0, start: S(a), end: r }, { hasParentParens: n });
+}, x = function(t, e = !1) {
+  return h(this, o, ct).call(this, t, e);
+}, ct = function(t, e = !1) {
+  if (t instanceof Ft) {
+    let { expressions: s } = t;
+    if (s.length !== 1) throw new Error("Unexpected 'Interpolation'");
+    return h(this, o, x).call(this, s[0]);
+  }
+  if (t instanceof nt) return h(this, o, u).call(this, { type: "UnaryExpression", prefix: !0, argument: h(this, o, x).call(this, t.expr), operator: t.operator, ...t.sourceSpan }, { hasParentParens: e });
+  if (t instanceof E) {
+    let { left: s, operation: i, right: r } = t, n = h(this, o, x).call(this, s), a = h(this, o, x).call(this, r), l = S(n), c = C(a), d = { left: n, right: a, start: l, end: c };
+    return i === "&&" || i === "||" || i === "??" ? h(this, o, u).call(this, { ...d, type: "LogicalExpression", operator: i }, { hasParentParens: e }) : h(this, o, u).call(this, { ...d, type: "BinaryExpression", operator: i }, { hasParentParens: e });
+  }
+  if (t instanceof Rt) {
+    let { exp: s, name: i, args: r } = t, n = h(this, o, x).call(this, s), a = S(n), l = C(n), c = this.getCharacterIndex(/\S/, this.getCharacterIndex("|", l) + 1), d = h(this, o, u).call(this, { type: "Identifier", name: i, start: c, end: c + i.length }), v = r.map((y) => h(this, o, x).call(this, y));
+    return h(this, o, u).call(this, { type: "NGPipeExpression", left: n, right: d, arguments: v, start: a, end: C(v.length === 0 ? d : Yt(!1, v, -1)) }, { hasParentParens: e });
+  }
+  if (t instanceof $t) return h(this, o, u).call(this, { type: "NGChainedExpression", expressions: t.expressions.map((s) => h(this, o, x).call(this, s)), ...t.sourceSpan }, { hasParentParens: e });
+  if (t instanceof Mt) {
+    let { condition: s, trueExp: i, falseExp: r } = t, n = h(this, o, x).call(this, s), a = h(this, o, x).call(this, i), l = h(this, o, x).call(this, r);
+    return h(this, o, u).call(this, { type: "ConditionalExpression", test: n, consequent: a, alternate: l, start: S(n), end: C(l) }, { hasParentParens: e });
+  }
+  if (t instanceof P) return h(this, o, u).call(this, { type: "NGEmptyExpression", ...t.sourceSpan }, { hasParentParens: e });
+  if (t instanceof z) return h(this, o, u).call(this, { type: "ThisExpression", ...t.sourceSpan }, { hasParentParens: e });
+  if (t instanceof Wt || t instanceof rt) return h(this, o, U).call(this, t.receiver, h(this, o, x).call(this, t.key), { computed: !0, optional: t instanceof rt, end: t.sourceSpan.end, hasParentParens: e });
+  if (t instanceof Gt) return h(this, o, u).call(this, { type: "ArrayExpression", elements: t.expressions.map((s) => h(this, o, x).call(this, s)), ...t.sourceSpan }, { hasParentParens: e });
+  if (t instanceof Vt) {
+    let { keys: s, values: i } = t, r = i.map((a) => h(this, o, x).call(this, a)), n = s.map(({ key: a, quoted: l }, c) => {
+      let d = r[c], v = S(d), y = C(d), k = this.getCharacterIndex(/\S/, c === 0 ? t.sourceSpan.start + 1 : this.getCharacterIndex(",", C(r[c - 1])) + 1), m = v === k ? y : this.getCharacterLastIndex(/\S/, this.getCharacterLastIndex(":", v - 1) - 1) + 1, N = { start: k, end: m }, A = l ? h(this, o, u).call(this, { type: "StringLiteral", value: a, ...N }) : h(this, o, u).call(this, { type: "Identifier", name: a, ...N }), F = A.end < A.start || k === v;
+      return h(this, o, u).call(this, { type: "ObjectProperty", key: A, value: d, shorthand: F, computed: !1, start: S(A), end: y });
+    });
+    return h(this, o, u).call(this, { type: "ObjectExpression", properties: n, ...t.sourceSpan }, { hasParentParens: e });
+  }
+  if (t instanceof O) {
+    let { value: s } = t;
+    switch (typeof s) {
+      case "boolean":
+        return h(this, o, u).call(this, { type: "BooleanLiteral", value: s, ...t.sourceSpan }, { hasParentParens: e });
+      case "number":
+        return h(this, o, u).call(this, { type: "NumericLiteral", value: s, ...t.sourceSpan }, { hasParentParens: e });
+      case "object":
+        return h(this, o, u).call(this, { type: "NullLiteral", ...t.sourceSpan }, { hasParentParens: e });
+      case "string":
+        return h(this, o, u).call(this, { type: "StringLiteral", value: s, ...t.sourceSpan }, { hasParentParens: e });
+      case "undefined":
+        return h(this, o, u).call(this, { type: "Identifier", name: "undefined", ...t.sourceSpan }, { hasParentParens: e });
+      default:
+        throw new Error(`Unexpected LiteralPrimitive value type ${typeof s}`);
+    }
+  }
+  if (t instanceof zt || t instanceof ht) {
+    let s = t instanceof ht, { receiver: i, args: r } = t, n = r.length === 1 ? [h(this, o, x).call(this, r[0], !0)] : r.map((d) => h(this, o, x).call(this, d)), a = h(this, o, x).call(this, i), l = Pt(a), c = s || l ? "OptionalCallExpression" : "CallExpression";
+    return h(this, o, u).call(this, { type: c, callee: a, arguments: n, optional: c === "OptionalCallExpression" ? s : void 0, start: S(a), end: t.sourceSpan.end }, { hasParentParens: e });
+  }
+  if (t instanceof qt) {
+    let s = h(this, o, x).call(this, t.expression);
+    return h(this, o, u).call(this, { type: "TSNonNullExpression", expression: s, start: S(s), end: t.sourceSpan.end }, { hasParentParens: e });
+  }
+  if (t instanceof jt) {
+    let s = h(this, o, x).call(this, t.expression);
+    return h(this, o, u).call(this, { type: "UnaryExpression", prefix: !0, operator: "!", argument: s, start: t.sourceSpan.start, end: C(s) }, { hasParentParens: e });
+  }
+  if (t instanceof st || t instanceof it) {
+    let { receiver: s, name: i } = t, r = this.getCharacterLastIndex(/\S/, t.sourceSpan.end - 1) + 1, n = h(this, o, u).call(this, { type: "Identifier", name: i, start: r - i.length, end: r }, Ot(s, I(this, R)) ? { hasParentParens: e } : {});
+    return h(this, o, U).call(this, s, n, { computed: !1, optional: t instanceof it, hasParentParens: e });
+  }
+  if (t instanceof Ut) {
+    let s = h(this, o, x).call(this, t.key), i = h(this, o, x).call(this, t.value), r = h(this, o, U).call(this, t.receiver, s, { computed: !0, optional: !1, end: this.getCharacterIndex("]", C(s)) + 1 });
+    return h(this, o, u).call(this, { type: "AssignmentExpression", left: r, operator: "=", right: i, start: S(r), end: C(i) }, { hasParentParens: e });
+  }
+  if (t instanceof Bt) {
+    let { receiver: s, name: i, value: r } = t, n = h(this, o, x).call(this, r), a = this.getCharacterLastIndex(/\S/, this.getCharacterLastIndex("=", S(n) - 1) - 1) + 1, l = h(this, o, u).call(this, { type: "Identifier", name: i, start: a - i.length, end: a }), c = h(this, o, U).call(this, s, l, { computed: !1, optional: !1 });
+    return h(this, o, u).call(this, { type: "AssignmentExpression", left: c, operator: "=", right: n, start: S(c), end: C(n) }, { hasParentParens: e });
+  }
+  throw Object.assign(new Error("Unexpected node"), { node: t });
+};
+function ze(t, e) {
+  return new Zt(t, e).node;
+}
+function Et(t) {
+  return t instanceof Dt;
+}
+function It(t) {
+  return t instanceof ot;
+}
+var G, M, f, bt, w, Z, X, tt, Xt, At, te, Nt, De = class extends Zt {
+  constructor(t, e) {
+    super(void 0, e), B(this, f), B(this, G), B(this, M), q(this, G, t), q(this, M, e);
+    for (let s of t) h(this, f, Xt).call(this, s);
+  }
+  get expressions() {
+    return h(this, f, te).call(this);
+  }
+};
+G = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap(), f = /* @__PURE__ */ new WeakSet(), bt = function() {
+  return I(this, G)[0].key;
+}, w = function(t, { stripSpaces: e = !0 } = {}) {
+  return this.createNode(t, { stripSpaces: e });
+}, Z = function(t) {
+  return this.transformNode(t);
+}, X = function(t) {
+  return Me(t.slice(I(this, f, bt).source.length));
+}, tt = function(t) {
+  let e = I(this, M);
+  if (e[t.start] !== '"' && e[t.start] !== "'") return;
+  let s = e[t.start], i = !1;
+  for (let r = t.start + 1; r < e.length; r++) switch (e[r]) {
+    case s:
+      if (!i) {
+        t.end = r + 1;
+        return;
+      }
+    default:
+      i = !1;
+      break;
+    case "\\":
+      i = !i;
+      break;
+  }
+}, Xt = function(t) {
+  h(this, f, tt).call(this, t.key.span), It(t) && t.value && h(this, f, tt).call(this, t.value.span);
+}, At = function(t) {
+  if (!t.value || t.value.source) return t.value;
+  let e = this.getCharacterIndex(/\S/, t.sourceSpan.start);
+  return { source: "$implicit", span: { start: e, end: e } };
+}, te = function() {
+  let t = I(this, G), [e] = t, s = I(this, M).slice(e.sourceSpan.start, e.sourceSpan.end).trim().length === 0 ? t.slice(1) : t, i = [], r = null;
+  for (let [n, a] of s.entries()) {
+    if (r && Et(r) && It(a) && a.value && a.value.source === r.key.source) {
+      let l = h(this, f, w).call(this, { type: "NGMicrosyntaxKey", name: a.key.source, ...a.key.span }), c = (y, k) => ({ ...y, ...this.transformSpan({ start: y.start, end: k }) }), d = (y) => ({ ...c(y, l.end), alias: l }), v = i.pop();
+      if (v.type === "NGMicrosyntaxExpression") i.push(d(v));
+      else if (v.type === "NGMicrosyntaxKeyedExpression") {
+        let y = d(v.expression);
+        i.push(c({ ...v, expression: y }, y.end));
+      } else throw new Error(`Unexpected type ${v.type}`);
+    } else i.push(h(this, f, Nt).call(this, a, n));
+    r = a;
+  }
+  return h(this, f, w).call(this, { type: "NGMicrosyntax", body: i, ...i.length === 0 ? t[0].sourceSpan : { start: i[0].start, end: Yt(!1, i, -1).end } });
+}, Nt = function(t, e) {
+  if (Et(t)) {
+    let { key: s, value: i } = t;
+    return i ? e === 0 ? h(this, f, w).call(this, { type: "NGMicrosyntaxExpression", expression: h(this, f, Z).call(this, i.ast), alias: null, ...i.sourceSpan }) : h(this, f, w).call(this, { type: "NGMicrosyntaxKeyedExpression", key: h(this, f, w).call(this, { type: "NGMicrosyntaxKey", name: h(this, f, X).call(this, s.source), ...s.span }), expression: h(this, f, w).call(this, { type: "NGMicrosyntaxExpression", expression: h(this, f, Z).call(this, i.ast), alias: null, ...i.sourceSpan }), start: s.span.start, end: i.sourceSpan.end }) : h(this, f, w).call(this, { type: "NGMicrosyntaxKey", name: h(this, f, X).call(this, s.source), ...s.span });
+  } else {
+    let { key: s, sourceSpan: i } = t;
+    if (/^let\s$/.test(I(this, M).slice(i.start, i.start + 4))) {
+      let { value: r } = t;
+      return h(this, f, w).call(this, { type: "NGMicrosyntaxLet", key: h(this, f, w).call(this, { type: "NGMicrosyntaxKey", name: s.source, ...s.span }), value: r ? h(this, f, w).call(this, { type: "NGMicrosyntaxKey", name: r.source, ...r.span }) : null, start: i.start, end: r ? r.span.end : s.span.end });
+    } else {
+      let r = h(this, f, At).call(this, t);
+      return h(this, f, w).call(this, { type: "NGMicrosyntaxAs", key: h(this, f, w).call(this, { type: "NGMicrosyntaxKey", name: r.source, ...r.span }), alias: h(this, f, w).call(this, { type: "NGMicrosyntaxKey", name: s.source, ...s.span }), start: r.span.start, end: s.span.end });
+    }
+  }
+};
+function He(t, e) {
+  return new De(t, e).expressions;
+}
+function dt({ result: { ast: t }, text: e, comments: s }) {
+  return Object.assign(ze(t, e), { comments: s });
+}
+function Je({ result: { templateBindings: t }, text: e }) {
+  return He(t, e);
+}
+var Qe = (t) => dt(Ue(t)), Ye = (t) => dt(Ge(t)), ee = (t) => dt(Re(t)), Ze = (t) => Je(Ve(t));
+function se(t) {
+  var e, s, i;
+  let r = ((e = t.range) == null ? void 0 : e[0]) ?? t.start, n = (i = ((s = t.declaration) == null ? void 0 : s.decorators) ?? t.decorators) == null ? void 0 : i[0];
+  return n ? Math.min(se(n), r) : r;
+}
+function Xe(t) {
+  var e;
+  return ((e = t.range) == null ? void 0 : e[1]) ?? t.end;
+}
+function J(t) {
+  return { astFormat: "estree", parse(e) {
+    let s = t(e);
+    return { type: "NGRoot", node: t === ee && s.type !== "NGChainedExpression" ? { ...s, type: "NGChainedExpression", expressions: [s] } : s };
+  }, locStart: se, locEnd: Xe };
+}
+var ts = J(ee), es = J(Qe), ss = J(Ye), is = J(Ze), ns = Lt;
+export {
+  ns as default,
+  _t as parsers
+};