4613 lines
132 KiB
JavaScript
4613 lines
132 KiB
JavaScript
(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 it = Object.defineProperty;
|
|
var $s = Object.getOwnPropertyDescriptor;
|
|
var Rs = Object.getOwnPropertyNames;
|
|
var Bs = Object.prototype.hasOwnProperty;
|
|
var Xt = (t) => {
|
|
throw TypeError(t);
|
|
};
|
|
var Jt = (t, e) => {
|
|
for (var n in e) it(t, n, { get: e[n], enumerable: !0 });
|
|
},
|
|
Ds = (t, e, n, s) => {
|
|
if ((e && typeof e == 'object') || typeof e == 'function')
|
|
for (let r of Rs(e))
|
|
!Bs.call(t, r) &&
|
|
r !== n &&
|
|
it(t, r, {
|
|
get: () => e[r],
|
|
enumerable: !(s = $s(e, r)) || s.enumerable,
|
|
});
|
|
return t;
|
|
};
|
|
var Os = (t) => Ds(it({}, '__esModule', { value: !0 }), t);
|
|
var ot = (t, e, n) => e.has(t) || Xt('Cannot ' + n);
|
|
var L = (t, e, n) => (
|
|
ot(t, e, 'read from private field'), n ? n.call(t) : e.get(t)
|
|
),
|
|
V = (t, e, n) =>
|
|
e.has(t) ? Xt('Cannot add the same private member more than once')
|
|
: e instanceof WeakSet ? e.add(t)
|
|
: e.set(t, n),
|
|
K = (t, e, n, s) => (
|
|
ot(t, e, 'write to private field'), s ? s.call(t, n) : e.set(t, n), n
|
|
),
|
|
c = (t, e, n) => (ot(t, e, 'access private method'), n);
|
|
var Yr = {};
|
|
Jt(Yr, { parsers: () => zt });
|
|
var zt = {};
|
|
Jt(zt, {
|
|
__ng_action: () => zr,
|
|
__ng_binding: () => Gr,
|
|
__ng_directive: () => Jr,
|
|
__ng_interpolation: () => Xr,
|
|
});
|
|
var Kr = new RegExp(
|
|
`(\\:not\\()|(([\\.\\#]?)[-\\w]+)|(?:\\[([-.\\w*\\\\$]+)(?:=(["']?)([^\\]"']*)\\5)?\\])|(\\))|(\\s*,\\s*)`,
|
|
'g'
|
|
);
|
|
var Yt;
|
|
(function (t) {
|
|
(t[(t.Emulated = 0)] = 'Emulated'),
|
|
(t[(t.None = 2)] = 'None'),
|
|
(t[(t.ShadowDom = 3)] = 'ShadowDom');
|
|
})(Yt || (Yt = {}));
|
|
var Qt;
|
|
(function (t) {
|
|
(t[(t.OnPush = 0)] = 'OnPush'), (t[(t.Default = 1)] = 'Default');
|
|
})(Qt || (Qt = {}));
|
|
var Kt;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'),
|
|
(t[(t.SignalBased = 1)] = 'SignalBased'),
|
|
(t[(t.HasDecoratorInputTransform = 2)] = 'HasDecoratorInputTransform');
|
|
})(Kt || (Kt = {}));
|
|
var B;
|
|
(function (t) {
|
|
(t[(t.NONE = 0)] = 'NONE'),
|
|
(t[(t.HTML = 1)] = 'HTML'),
|
|
(t[(t.STYLE = 2)] = 'STYLE'),
|
|
(t[(t.SCRIPT = 3)] = 'SCRIPT'),
|
|
(t[(t.URL = 4)] = 'URL'),
|
|
(t[(t.RESOURCE_URL = 5)] = 'RESOURCE_URL');
|
|
})(B || (B = {}));
|
|
var Zt;
|
|
(function (t) {
|
|
(t[(t.Error = 0)] = 'Error'),
|
|
(t[(t.Warning = 1)] = 'Warning'),
|
|
(t[(t.Ignore = 2)] = 'Ignore');
|
|
})(Zt || (Zt = {}));
|
|
var en;
|
|
(function (t) {
|
|
(t[(t.Little = 0)] = 'Little'), (t[(t.Big = 1)] = 'Big');
|
|
})(en || (en = {}));
|
|
var tn;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'), (t[(t.Const = 1)] = 'Const');
|
|
})(tn || (tn = {}));
|
|
var nn;
|
|
(function (t) {
|
|
(t[(t.Dynamic = 0)] = 'Dynamic'),
|
|
(t[(t.Bool = 1)] = 'Bool'),
|
|
(t[(t.String = 2)] = 'String'),
|
|
(t[(t.Int = 3)] = 'Int'),
|
|
(t[(t.Number = 4)] = 'Number'),
|
|
(t[(t.Function = 5)] = 'Function'),
|
|
(t[(t.Inferred = 6)] = 'Inferred'),
|
|
(t[(t.None = 7)] = 'None');
|
|
})(nn || (nn = {}));
|
|
var Fs = void 0;
|
|
var sn;
|
|
(function (t) {
|
|
(t[(t.Minus = 0)] = 'Minus'), (t[(t.Plus = 1)] = 'Plus');
|
|
})(sn || (sn = {}));
|
|
var _;
|
|
(function (t) {
|
|
(t[(t.Equals = 0)] = 'Equals'),
|
|
(t[(t.NotEquals = 1)] = 'NotEquals'),
|
|
(t[(t.Identical = 2)] = 'Identical'),
|
|
(t[(t.NotIdentical = 3)] = 'NotIdentical'),
|
|
(t[(t.Minus = 4)] = 'Minus'),
|
|
(t[(t.Plus = 5)] = 'Plus'),
|
|
(t[(t.Divide = 6)] = 'Divide'),
|
|
(t[(t.Multiply = 7)] = 'Multiply'),
|
|
(t[(t.Modulo = 8)] = 'Modulo'),
|
|
(t[(t.And = 9)] = 'And'),
|
|
(t[(t.Or = 10)] = 'Or'),
|
|
(t[(t.BitwiseOr = 11)] = 'BitwiseOr'),
|
|
(t[(t.BitwiseAnd = 12)] = 'BitwiseAnd'),
|
|
(t[(t.Lower = 13)] = 'Lower'),
|
|
(t[(t.LowerEquals = 14)] = 'LowerEquals'),
|
|
(t[(t.Bigger = 15)] = 'Bigger'),
|
|
(t[(t.BiggerEquals = 16)] = 'BiggerEquals'),
|
|
(t[(t.NullishCoalesce = 17)] = 'NullishCoalesce');
|
|
})(_ || (_ = {}));
|
|
function Vs(t, e) {
|
|
return t == null || e == null ? t == e : t.isEquivalent(e);
|
|
}
|
|
function Hs(t, e, n) {
|
|
let s = t.length;
|
|
if (s !== e.length) return !1;
|
|
for (let r = 0; r < s; r++) if (!n(t[r], e[r])) return !1;
|
|
return !0;
|
|
}
|
|
function tt(t, e) {
|
|
return Hs(t, e, (n, s) => n.isEquivalent(s));
|
|
}
|
|
var k = class {
|
|
type;
|
|
sourceSpan;
|
|
constructor(e, n) {
|
|
(this.type = e || null), (this.sourceSpan = n || null);
|
|
}
|
|
prop(e, n) {
|
|
return new vt(this, e, null, n);
|
|
}
|
|
key(e, n, s) {
|
|
return new wt(this, e, n, s);
|
|
}
|
|
callFn(e, n, s) {
|
|
return new Xe(this, e, null, n, s);
|
|
}
|
|
instantiate(e, n, s) {
|
|
return new dt(this, e, n, s);
|
|
}
|
|
conditional(e, n = null, s) {
|
|
return new gt(this, e, n, null, s);
|
|
}
|
|
equals(e, n) {
|
|
return new C(_.Equals, this, e, null, n);
|
|
}
|
|
notEquals(e, n) {
|
|
return new C(_.NotEquals, this, e, null, n);
|
|
}
|
|
identical(e, n) {
|
|
return new C(_.Identical, this, e, null, n);
|
|
}
|
|
notIdentical(e, n) {
|
|
return new C(_.NotIdentical, this, e, null, n);
|
|
}
|
|
minus(e, n) {
|
|
return new C(_.Minus, this, e, null, n);
|
|
}
|
|
plus(e, n) {
|
|
return new C(_.Plus, this, e, null, n);
|
|
}
|
|
divide(e, n) {
|
|
return new C(_.Divide, this, e, null, n);
|
|
}
|
|
multiply(e, n) {
|
|
return new C(_.Multiply, this, e, null, n);
|
|
}
|
|
modulo(e, n) {
|
|
return new C(_.Modulo, this, e, null, n);
|
|
}
|
|
and(e, n) {
|
|
return new C(_.And, this, e, null, n);
|
|
}
|
|
bitwiseOr(e, n, s = !0) {
|
|
return new C(_.BitwiseOr, this, e, null, n, s);
|
|
}
|
|
bitwiseAnd(e, n, s = !0) {
|
|
return new C(_.BitwiseAnd, this, e, null, n, s);
|
|
}
|
|
or(e, n) {
|
|
return new C(_.Or, this, e, null, n);
|
|
}
|
|
lower(e, n) {
|
|
return new C(_.Lower, this, e, null, n);
|
|
}
|
|
lowerEquals(e, n) {
|
|
return new C(_.LowerEquals, this, e, null, n);
|
|
}
|
|
bigger(e, n) {
|
|
return new C(_.Bigger, this, e, null, n);
|
|
}
|
|
biggerEquals(e, n) {
|
|
return new C(_.BiggerEquals, this, e, null, n);
|
|
}
|
|
isBlank(e) {
|
|
return this.equals(TYPED_NULL_EXPR, e);
|
|
}
|
|
nullishCoalesce(e, n) {
|
|
return new C(_.NullishCoalesce, this, e, null, n);
|
|
}
|
|
toStmt() {
|
|
return new St(this, null);
|
|
}
|
|
},
|
|
Ge = class t extends k {
|
|
name;
|
|
constructor(e, n, s) {
|
|
super(n, s), (this.name = e);
|
|
}
|
|
isEquivalent(e) {
|
|
return e instanceof t && this.name === e.name;
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitReadVarExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(this.name, this.type, this.sourceSpan);
|
|
}
|
|
set(e) {
|
|
return new pt(this.name, e, null, this.sourceSpan);
|
|
}
|
|
},
|
|
ut = class t extends k {
|
|
expr;
|
|
constructor(e, n, s) {
|
|
super(n, s), (this.expr = e);
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitTypeofExpr(this, n);
|
|
}
|
|
isEquivalent(e) {
|
|
return e instanceof t && e.expr.isEquivalent(this.expr);
|
|
}
|
|
isConstant() {
|
|
return this.expr.isConstant();
|
|
}
|
|
clone() {
|
|
return new t(this.expr.clone());
|
|
}
|
|
};
|
|
var pt = class t extends k {
|
|
name;
|
|
value;
|
|
constructor(e, n, s, r) {
|
|
super(s || n.type, r), (this.name = e), (this.value = n);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.name === e.name &&
|
|
this.value.isEquivalent(e.value)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitWriteVarExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(this.name, this.value.clone(), this.type, this.sourceSpan);
|
|
}
|
|
toDeclStmt(e, n) {
|
|
return new xt(this.name, this.value, e, n, this.sourceSpan);
|
|
}
|
|
toConstDecl() {
|
|
return this.toDeclStmt(Fs, Ee.Final);
|
|
}
|
|
},
|
|
ht = class t extends k {
|
|
receiver;
|
|
index;
|
|
value;
|
|
constructor(e, n, s, r, o) {
|
|
super(r || s.type, o),
|
|
(this.receiver = e),
|
|
(this.index = n),
|
|
(this.value = s);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.receiver.isEquivalent(e.receiver) &&
|
|
this.index.isEquivalent(e.index) &&
|
|
this.value.isEquivalent(e.value)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitWriteKeyExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.receiver.clone(),
|
|
this.index.clone(),
|
|
this.value.clone(),
|
|
this.type,
|
|
this.sourceSpan
|
|
);
|
|
}
|
|
},
|
|
ft = class t extends k {
|
|
receiver;
|
|
name;
|
|
value;
|
|
constructor(e, n, s, r, o) {
|
|
super(r || s.type, o),
|
|
(this.receiver = e),
|
|
(this.name = n),
|
|
(this.value = s);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.receiver.isEquivalent(e.receiver) &&
|
|
this.name === e.name &&
|
|
this.value.isEquivalent(e.value)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitWritePropExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.receiver.clone(),
|
|
this.name,
|
|
this.value.clone(),
|
|
this.type,
|
|
this.sourceSpan
|
|
);
|
|
}
|
|
},
|
|
Xe = class t extends k {
|
|
fn;
|
|
args;
|
|
pure;
|
|
constructor(e, n, s, r, o = !1) {
|
|
super(s, r), (this.fn = e), (this.args = n), (this.pure = o);
|
|
}
|
|
get receiver() {
|
|
return this.fn;
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.fn.isEquivalent(e.fn) &&
|
|
tt(this.args, e.args) &&
|
|
this.pure === e.pure
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitInvokeFunctionExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.fn.clone(),
|
|
this.args.map((e) => e.clone()),
|
|
this.type,
|
|
this.sourceSpan,
|
|
this.pure
|
|
);
|
|
}
|
|
};
|
|
var dt = class t extends k {
|
|
classExpr;
|
|
args;
|
|
constructor(e, n, s, r) {
|
|
super(s, r), (this.classExpr = e), (this.args = n);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.classExpr.isEquivalent(e.classExpr) &&
|
|
tt(this.args, e.args)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitInstantiateExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.classExpr.clone(),
|
|
this.args.map((e) => e.clone()),
|
|
this.type,
|
|
this.sourceSpan
|
|
);
|
|
}
|
|
},
|
|
Je = class t extends k {
|
|
value;
|
|
constructor(e, n, s) {
|
|
super(n, s), (this.value = e);
|
|
}
|
|
isEquivalent(e) {
|
|
return e instanceof t && this.value === e.value;
|
|
}
|
|
isConstant() {
|
|
return !0;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitLiteralExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(this.value, this.type, this.sourceSpan);
|
|
}
|
|
};
|
|
var mt = class t extends k {
|
|
value;
|
|
typeParams;
|
|
constructor(e, n, s = null, r) {
|
|
super(n, r), (this.value = e), (this.typeParams = s);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.value.name === e.value.name &&
|
|
this.value.moduleName === e.value.moduleName
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitExternalExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(this.value, this.type, this.typeParams, this.sourceSpan);
|
|
}
|
|
};
|
|
var gt = class t extends k {
|
|
condition;
|
|
falseCase;
|
|
trueCase;
|
|
constructor(e, n, s = null, r, o) {
|
|
super(r || n.type, o),
|
|
(this.condition = e),
|
|
(this.falseCase = s),
|
|
(this.trueCase = n);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.condition.isEquivalent(e.condition) &&
|
|
this.trueCase.isEquivalent(e.trueCase) &&
|
|
Vs(this.falseCase, e.falseCase)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitConditionalExpr(this, n);
|
|
}
|
|
clone() {
|
|
var e;
|
|
return new t(
|
|
this.condition.clone(),
|
|
this.trueCase.clone(),
|
|
(e = this.falseCase) == null ? void 0 : e.clone(),
|
|
this.type,
|
|
this.sourceSpan
|
|
);
|
|
}
|
|
};
|
|
var C = class t extends k {
|
|
operator;
|
|
rhs;
|
|
parens;
|
|
lhs;
|
|
constructor(e, n, s, r, o, a = !0) {
|
|
super(r || n.type, o),
|
|
(this.operator = e),
|
|
(this.rhs = s),
|
|
(this.parens = a),
|
|
(this.lhs = n);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.operator === e.operator &&
|
|
this.lhs.isEquivalent(e.lhs) &&
|
|
this.rhs.isEquivalent(e.rhs)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitBinaryOperatorExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.operator,
|
|
this.lhs.clone(),
|
|
this.rhs.clone(),
|
|
this.type,
|
|
this.sourceSpan,
|
|
this.parens
|
|
);
|
|
}
|
|
},
|
|
vt = class t extends k {
|
|
receiver;
|
|
name;
|
|
constructor(e, n, s, r) {
|
|
super(s, r), (this.receiver = e), (this.name = n);
|
|
}
|
|
get index() {
|
|
return this.name;
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.receiver.isEquivalent(e.receiver) &&
|
|
this.name === e.name
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitReadPropExpr(this, n);
|
|
}
|
|
set(e) {
|
|
return new ft(this.receiver, this.name, e, null, this.sourceSpan);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.receiver.clone(),
|
|
this.name,
|
|
this.type,
|
|
this.sourceSpan
|
|
);
|
|
}
|
|
},
|
|
wt = class t extends k {
|
|
receiver;
|
|
index;
|
|
constructor(e, n, s, r) {
|
|
super(s, r), (this.receiver = e), (this.index = n);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.receiver.isEquivalent(e.receiver) &&
|
|
this.index.isEquivalent(e.index)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitReadKeyExpr(this, n);
|
|
}
|
|
set(e) {
|
|
return new ht(this.receiver, this.index, e, null, this.sourceSpan);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.receiver.clone(),
|
|
this.index.clone(),
|
|
this.type,
|
|
this.sourceSpan
|
|
);
|
|
}
|
|
},
|
|
Ye = class t extends k {
|
|
entries;
|
|
constructor(e, n, s) {
|
|
super(n, s), (this.entries = e);
|
|
}
|
|
isConstant() {
|
|
return this.entries.every((e) => e.isConstant());
|
|
}
|
|
isEquivalent(e) {
|
|
return e instanceof t && tt(this.entries, e.entries);
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitLiteralArrayExpr(this, n);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.entries.map((e) => e.clone()),
|
|
this.type,
|
|
this.sourceSpan
|
|
);
|
|
}
|
|
};
|
|
var Qe = class t extends k {
|
|
entries;
|
|
valueType = null;
|
|
constructor(e, n, s) {
|
|
super(n, s), (this.entries = e), n && (this.valueType = n.valueType);
|
|
}
|
|
isEquivalent(e) {
|
|
return e instanceof t && tt(this.entries, e.entries);
|
|
}
|
|
isConstant() {
|
|
return this.entries.every((e) => e.value.isConstant());
|
|
}
|
|
visitExpression(e, n) {
|
|
return e.visitLiteralMapExpr(this, n);
|
|
}
|
|
clone() {
|
|
let e = this.entries.map((n) => n.clone());
|
|
return new t(e, this.type, this.sourceSpan);
|
|
}
|
|
};
|
|
var Ee;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'),
|
|
(t[(t.Final = 1)] = 'Final'),
|
|
(t[(t.Private = 2)] = 'Private'),
|
|
(t[(t.Exported = 4)] = 'Exported'),
|
|
(t[(t.Static = 8)] = 'Static');
|
|
})(Ee || (Ee = {}));
|
|
var Ke = class {
|
|
modifiers;
|
|
sourceSpan;
|
|
leadingComments;
|
|
constructor(e = Ee.None, n = null, s) {
|
|
(this.modifiers = e), (this.sourceSpan = n), (this.leadingComments = s);
|
|
}
|
|
hasModifier(e) {
|
|
return (this.modifiers & e) !== 0;
|
|
}
|
|
addLeadingComment(e) {
|
|
(this.leadingComments = this.leadingComments ?? []),
|
|
this.leadingComments.push(e);
|
|
}
|
|
},
|
|
xt = class t extends Ke {
|
|
name;
|
|
value;
|
|
type;
|
|
constructor(e, n, s, r, o, a) {
|
|
super(r, o, a),
|
|
(this.name = e),
|
|
(this.value = n),
|
|
(this.type = s || (n && n.type) || null);
|
|
}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
this.name === e.name &&
|
|
(this.value ?
|
|
!!e.value && this.value.isEquivalent(e.value)
|
|
: !e.value)
|
|
);
|
|
}
|
|
visitStatement(e, n) {
|
|
return e.visitDeclareVarStmt(this, n);
|
|
}
|
|
};
|
|
var St = class t extends Ke {
|
|
expr;
|
|
constructor(e, n, s) {
|
|
super(Ee.None, n, s), (this.expr = e);
|
|
}
|
|
isEquivalent(e) {
|
|
return e instanceof t && this.expr.isEquivalent(e.expr);
|
|
}
|
|
visitStatement(e, n) {
|
|
return e.visitExpressionStmt(this, n);
|
|
}
|
|
};
|
|
function Us(t, e, n) {
|
|
return new Ge(t, e, n);
|
|
}
|
|
var Zr = Us('<unknown>');
|
|
var rn = class t {
|
|
static INSTANCE = new t();
|
|
keyOf(e) {
|
|
if (e instanceof Je && typeof e.value == 'string') return `"${e.value}"`;
|
|
if (e instanceof Je) return String(e.value);
|
|
if (e instanceof Ye) {
|
|
let n = [];
|
|
for (let s of e.entries) n.push(this.keyOf(s));
|
|
return `[${n.join(',')}]`;
|
|
} else if (e instanceof Qe) {
|
|
let n = [];
|
|
for (let s of e.entries) {
|
|
let r = s.key;
|
|
s.quoted && (r = `"${r}"`), n.push(r + ':' + this.keyOf(s.value));
|
|
}
|
|
return `{${n.join(',')}}`;
|
|
} else {
|
|
if (e instanceof mt)
|
|
return `import("${e.value.moduleName}", ${e.value.name})`;
|
|
if (e instanceof Ge) return `read(${e.name})`;
|
|
if (e instanceof ut) return `typeof(${this.keyOf(e.expr)})`;
|
|
throw new Error(
|
|
`${this.constructor.name} does not handle expressions of type ${e.constructor.name}`
|
|
);
|
|
}
|
|
}
|
|
};
|
|
var i = '@angular/core',
|
|
P = class {
|
|
static NEW_METHOD = 'factory';
|
|
static TRANSFORM_METHOD = 'transform';
|
|
static PATCH_DEPS = 'patchedDeps';
|
|
static core = { name: null, moduleName: i };
|
|
static namespaceHTML = {
|
|
name: '\u0275\u0275namespaceHTML',
|
|
moduleName: i,
|
|
};
|
|
static namespaceMathML = {
|
|
name: '\u0275\u0275namespaceMathML',
|
|
moduleName: i,
|
|
};
|
|
static namespaceSVG = { name: '\u0275\u0275namespaceSVG', moduleName: i };
|
|
static element = { name: '\u0275\u0275element', moduleName: i };
|
|
static elementStart = { name: '\u0275\u0275elementStart', moduleName: i };
|
|
static elementEnd = { name: '\u0275\u0275elementEnd', moduleName: i };
|
|
static advance = { name: '\u0275\u0275advance', moduleName: i };
|
|
static syntheticHostProperty = {
|
|
name: '\u0275\u0275syntheticHostProperty',
|
|
moduleName: i,
|
|
};
|
|
static syntheticHostListener = {
|
|
name: '\u0275\u0275syntheticHostListener',
|
|
moduleName: i,
|
|
};
|
|
static attribute = { name: '\u0275\u0275attribute', moduleName: i };
|
|
static attributeInterpolate1 = {
|
|
name: '\u0275\u0275attributeInterpolate1',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolate2 = {
|
|
name: '\u0275\u0275attributeInterpolate2',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolate3 = {
|
|
name: '\u0275\u0275attributeInterpolate3',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolate4 = {
|
|
name: '\u0275\u0275attributeInterpolate4',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolate5 = {
|
|
name: '\u0275\u0275attributeInterpolate5',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolate6 = {
|
|
name: '\u0275\u0275attributeInterpolate6',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolate7 = {
|
|
name: '\u0275\u0275attributeInterpolate7',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolate8 = {
|
|
name: '\u0275\u0275attributeInterpolate8',
|
|
moduleName: i,
|
|
};
|
|
static attributeInterpolateV = {
|
|
name: '\u0275\u0275attributeInterpolateV',
|
|
moduleName: i,
|
|
};
|
|
static classProp = { name: '\u0275\u0275classProp', moduleName: i };
|
|
static elementContainerStart = {
|
|
name: '\u0275\u0275elementContainerStart',
|
|
moduleName: i,
|
|
};
|
|
static elementContainerEnd = {
|
|
name: '\u0275\u0275elementContainerEnd',
|
|
moduleName: i,
|
|
};
|
|
static elementContainer = {
|
|
name: '\u0275\u0275elementContainer',
|
|
moduleName: i,
|
|
};
|
|
static styleMap = { name: '\u0275\u0275styleMap', moduleName: i };
|
|
static styleMapInterpolate1 = {
|
|
name: '\u0275\u0275styleMapInterpolate1',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolate2 = {
|
|
name: '\u0275\u0275styleMapInterpolate2',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolate3 = {
|
|
name: '\u0275\u0275styleMapInterpolate3',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolate4 = {
|
|
name: '\u0275\u0275styleMapInterpolate4',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolate5 = {
|
|
name: '\u0275\u0275styleMapInterpolate5',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolate6 = {
|
|
name: '\u0275\u0275styleMapInterpolate6',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolate7 = {
|
|
name: '\u0275\u0275styleMapInterpolate7',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolate8 = {
|
|
name: '\u0275\u0275styleMapInterpolate8',
|
|
moduleName: i,
|
|
};
|
|
static styleMapInterpolateV = {
|
|
name: '\u0275\u0275styleMapInterpolateV',
|
|
moduleName: i,
|
|
};
|
|
static classMap = { name: '\u0275\u0275classMap', moduleName: i };
|
|
static classMapInterpolate1 = {
|
|
name: '\u0275\u0275classMapInterpolate1',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolate2 = {
|
|
name: '\u0275\u0275classMapInterpolate2',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolate3 = {
|
|
name: '\u0275\u0275classMapInterpolate3',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolate4 = {
|
|
name: '\u0275\u0275classMapInterpolate4',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolate5 = {
|
|
name: '\u0275\u0275classMapInterpolate5',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolate6 = {
|
|
name: '\u0275\u0275classMapInterpolate6',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolate7 = {
|
|
name: '\u0275\u0275classMapInterpolate7',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolate8 = {
|
|
name: '\u0275\u0275classMapInterpolate8',
|
|
moduleName: i,
|
|
};
|
|
static classMapInterpolateV = {
|
|
name: '\u0275\u0275classMapInterpolateV',
|
|
moduleName: i,
|
|
};
|
|
static styleProp = { name: '\u0275\u0275styleProp', moduleName: i };
|
|
static stylePropInterpolate1 = {
|
|
name: '\u0275\u0275stylePropInterpolate1',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolate2 = {
|
|
name: '\u0275\u0275stylePropInterpolate2',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolate3 = {
|
|
name: '\u0275\u0275stylePropInterpolate3',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolate4 = {
|
|
name: '\u0275\u0275stylePropInterpolate4',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolate5 = {
|
|
name: '\u0275\u0275stylePropInterpolate5',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolate6 = {
|
|
name: '\u0275\u0275stylePropInterpolate6',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolate7 = {
|
|
name: '\u0275\u0275stylePropInterpolate7',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolate8 = {
|
|
name: '\u0275\u0275stylePropInterpolate8',
|
|
moduleName: i,
|
|
};
|
|
static stylePropInterpolateV = {
|
|
name: '\u0275\u0275stylePropInterpolateV',
|
|
moduleName: i,
|
|
};
|
|
static nextContext = { name: '\u0275\u0275nextContext', moduleName: i };
|
|
static resetView = { name: '\u0275\u0275resetView', moduleName: i };
|
|
static templateCreate = { name: '\u0275\u0275template', moduleName: i };
|
|
static defer = { name: '\u0275\u0275defer', moduleName: i };
|
|
static deferWhen = { name: '\u0275\u0275deferWhen', moduleName: i };
|
|
static deferOnIdle = { name: '\u0275\u0275deferOnIdle', moduleName: i };
|
|
static deferOnImmediate = {
|
|
name: '\u0275\u0275deferOnImmediate',
|
|
moduleName: i,
|
|
};
|
|
static deferOnTimer = { name: '\u0275\u0275deferOnTimer', moduleName: i };
|
|
static deferOnHover = { name: '\u0275\u0275deferOnHover', moduleName: i };
|
|
static deferOnInteraction = {
|
|
name: '\u0275\u0275deferOnInteraction',
|
|
moduleName: i,
|
|
};
|
|
static deferOnViewport = {
|
|
name: '\u0275\u0275deferOnViewport',
|
|
moduleName: i,
|
|
};
|
|
static deferPrefetchWhen = {
|
|
name: '\u0275\u0275deferPrefetchWhen',
|
|
moduleName: i,
|
|
};
|
|
static deferPrefetchOnIdle = {
|
|
name: '\u0275\u0275deferPrefetchOnIdle',
|
|
moduleName: i,
|
|
};
|
|
static deferPrefetchOnImmediate = {
|
|
name: '\u0275\u0275deferPrefetchOnImmediate',
|
|
moduleName: i,
|
|
};
|
|
static deferPrefetchOnTimer = {
|
|
name: '\u0275\u0275deferPrefetchOnTimer',
|
|
moduleName: i,
|
|
};
|
|
static deferPrefetchOnHover = {
|
|
name: '\u0275\u0275deferPrefetchOnHover',
|
|
moduleName: i,
|
|
};
|
|
static deferPrefetchOnInteraction = {
|
|
name: '\u0275\u0275deferPrefetchOnInteraction',
|
|
moduleName: i,
|
|
};
|
|
static deferPrefetchOnViewport = {
|
|
name: '\u0275\u0275deferPrefetchOnViewport',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateWhen = {
|
|
name: '\u0275\u0275deferHydrateWhen',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateNever = {
|
|
name: '\u0275\u0275deferHydrateNever',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateOnIdle = {
|
|
name: '\u0275\u0275deferHydrateOnIdle',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateOnImmediate = {
|
|
name: '\u0275\u0275deferHydrateOnImmediate',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateOnTimer = {
|
|
name: '\u0275\u0275deferHydrateOnTimer',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateOnHover = {
|
|
name: '\u0275\u0275deferHydrateOnHover',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateOnInteraction = {
|
|
name: '\u0275\u0275deferHydrateOnInteraction',
|
|
moduleName: i,
|
|
};
|
|
static deferHydrateOnViewport = {
|
|
name: '\u0275\u0275deferHydrateOnViewport',
|
|
moduleName: i,
|
|
};
|
|
static deferEnableTimerScheduling = {
|
|
name: '\u0275\u0275deferEnableTimerScheduling',
|
|
moduleName: i,
|
|
};
|
|
static conditional = { name: '\u0275\u0275conditional', moduleName: i };
|
|
static repeater = { name: '\u0275\u0275repeater', moduleName: i };
|
|
static repeaterCreate = {
|
|
name: '\u0275\u0275repeaterCreate',
|
|
moduleName: i,
|
|
};
|
|
static repeaterTrackByIndex = {
|
|
name: '\u0275\u0275repeaterTrackByIndex',
|
|
moduleName: i,
|
|
};
|
|
static repeaterTrackByIdentity = {
|
|
name: '\u0275\u0275repeaterTrackByIdentity',
|
|
moduleName: i,
|
|
};
|
|
static componentInstance = {
|
|
name: '\u0275\u0275componentInstance',
|
|
moduleName: i,
|
|
};
|
|
static text = { name: '\u0275\u0275text', moduleName: i };
|
|
static enableBindings = {
|
|
name: '\u0275\u0275enableBindings',
|
|
moduleName: i,
|
|
};
|
|
static disableBindings = {
|
|
name: '\u0275\u0275disableBindings',
|
|
moduleName: i,
|
|
};
|
|
static getCurrentView = {
|
|
name: '\u0275\u0275getCurrentView',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate = {
|
|
name: '\u0275\u0275textInterpolate',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate1 = {
|
|
name: '\u0275\u0275textInterpolate1',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate2 = {
|
|
name: '\u0275\u0275textInterpolate2',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate3 = {
|
|
name: '\u0275\u0275textInterpolate3',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate4 = {
|
|
name: '\u0275\u0275textInterpolate4',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate5 = {
|
|
name: '\u0275\u0275textInterpolate5',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate6 = {
|
|
name: '\u0275\u0275textInterpolate6',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate7 = {
|
|
name: '\u0275\u0275textInterpolate7',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolate8 = {
|
|
name: '\u0275\u0275textInterpolate8',
|
|
moduleName: i,
|
|
};
|
|
static textInterpolateV = {
|
|
name: '\u0275\u0275textInterpolateV',
|
|
moduleName: i,
|
|
};
|
|
static restoreView = { name: '\u0275\u0275restoreView', moduleName: i };
|
|
static pureFunction0 = {
|
|
name: '\u0275\u0275pureFunction0',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction1 = {
|
|
name: '\u0275\u0275pureFunction1',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction2 = {
|
|
name: '\u0275\u0275pureFunction2',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction3 = {
|
|
name: '\u0275\u0275pureFunction3',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction4 = {
|
|
name: '\u0275\u0275pureFunction4',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction5 = {
|
|
name: '\u0275\u0275pureFunction5',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction6 = {
|
|
name: '\u0275\u0275pureFunction6',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction7 = {
|
|
name: '\u0275\u0275pureFunction7',
|
|
moduleName: i,
|
|
};
|
|
static pureFunction8 = {
|
|
name: '\u0275\u0275pureFunction8',
|
|
moduleName: i,
|
|
};
|
|
static pureFunctionV = {
|
|
name: '\u0275\u0275pureFunctionV',
|
|
moduleName: i,
|
|
};
|
|
static pipeBind1 = { name: '\u0275\u0275pipeBind1', moduleName: i };
|
|
static pipeBind2 = { name: '\u0275\u0275pipeBind2', moduleName: i };
|
|
static pipeBind3 = { name: '\u0275\u0275pipeBind3', moduleName: i };
|
|
static pipeBind4 = { name: '\u0275\u0275pipeBind4', moduleName: i };
|
|
static pipeBindV = { name: '\u0275\u0275pipeBindV', moduleName: i };
|
|
static hostProperty = { name: '\u0275\u0275hostProperty', moduleName: i };
|
|
static property = { name: '\u0275\u0275property', moduleName: i };
|
|
static propertyInterpolate = {
|
|
name: '\u0275\u0275propertyInterpolate',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate1 = {
|
|
name: '\u0275\u0275propertyInterpolate1',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate2 = {
|
|
name: '\u0275\u0275propertyInterpolate2',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate3 = {
|
|
name: '\u0275\u0275propertyInterpolate3',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate4 = {
|
|
name: '\u0275\u0275propertyInterpolate4',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate5 = {
|
|
name: '\u0275\u0275propertyInterpolate5',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate6 = {
|
|
name: '\u0275\u0275propertyInterpolate6',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate7 = {
|
|
name: '\u0275\u0275propertyInterpolate7',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolate8 = {
|
|
name: '\u0275\u0275propertyInterpolate8',
|
|
moduleName: i,
|
|
};
|
|
static propertyInterpolateV = {
|
|
name: '\u0275\u0275propertyInterpolateV',
|
|
moduleName: i,
|
|
};
|
|
static i18n = { name: '\u0275\u0275i18n', moduleName: i };
|
|
static i18nAttributes = {
|
|
name: '\u0275\u0275i18nAttributes',
|
|
moduleName: i,
|
|
};
|
|
static i18nExp = { name: '\u0275\u0275i18nExp', moduleName: i };
|
|
static i18nStart = { name: '\u0275\u0275i18nStart', moduleName: i };
|
|
static i18nEnd = { name: '\u0275\u0275i18nEnd', moduleName: i };
|
|
static i18nApply = { name: '\u0275\u0275i18nApply', moduleName: i };
|
|
static i18nPostprocess = {
|
|
name: '\u0275\u0275i18nPostprocess',
|
|
moduleName: i,
|
|
};
|
|
static pipe = { name: '\u0275\u0275pipe', moduleName: i };
|
|
static projection = { name: '\u0275\u0275projection', moduleName: i };
|
|
static projectionDef = {
|
|
name: '\u0275\u0275projectionDef',
|
|
moduleName: i,
|
|
};
|
|
static reference = { name: '\u0275\u0275reference', moduleName: i };
|
|
static inject = { name: '\u0275\u0275inject', moduleName: i };
|
|
static injectAttribute = {
|
|
name: '\u0275\u0275injectAttribute',
|
|
moduleName: i,
|
|
};
|
|
static directiveInject = {
|
|
name: '\u0275\u0275directiveInject',
|
|
moduleName: i,
|
|
};
|
|
static invalidFactory = {
|
|
name: '\u0275\u0275invalidFactory',
|
|
moduleName: i,
|
|
};
|
|
static invalidFactoryDep = {
|
|
name: '\u0275\u0275invalidFactoryDep',
|
|
moduleName: i,
|
|
};
|
|
static templateRefExtractor = {
|
|
name: '\u0275\u0275templateRefExtractor',
|
|
moduleName: i,
|
|
};
|
|
static forwardRef = { name: 'forwardRef', moduleName: i };
|
|
static resolveForwardRef = { name: 'resolveForwardRef', moduleName: i };
|
|
static replaceMetadata = {
|
|
name: '\u0275\u0275replaceMetadata',
|
|
moduleName: i,
|
|
};
|
|
static ɵɵdefineInjectable = {
|
|
name: '\u0275\u0275defineInjectable',
|
|
moduleName: i,
|
|
};
|
|
static declareInjectable = {
|
|
name: '\u0275\u0275ngDeclareInjectable',
|
|
moduleName: i,
|
|
};
|
|
static InjectableDeclaration = {
|
|
name: '\u0275\u0275InjectableDeclaration',
|
|
moduleName: i,
|
|
};
|
|
static resolveWindow = {
|
|
name: '\u0275\u0275resolveWindow',
|
|
moduleName: i,
|
|
};
|
|
static resolveDocument = {
|
|
name: '\u0275\u0275resolveDocument',
|
|
moduleName: i,
|
|
};
|
|
static resolveBody = { name: '\u0275\u0275resolveBody', moduleName: i };
|
|
static getComponentDepsFactory = {
|
|
name: '\u0275\u0275getComponentDepsFactory',
|
|
moduleName: i,
|
|
};
|
|
static defineComponent = {
|
|
name: '\u0275\u0275defineComponent',
|
|
moduleName: i,
|
|
};
|
|
static declareComponent = {
|
|
name: '\u0275\u0275ngDeclareComponent',
|
|
moduleName: i,
|
|
};
|
|
static setComponentScope = {
|
|
name: '\u0275\u0275setComponentScope',
|
|
moduleName: i,
|
|
};
|
|
static ChangeDetectionStrategy = {
|
|
name: 'ChangeDetectionStrategy',
|
|
moduleName: i,
|
|
};
|
|
static ViewEncapsulation = { name: 'ViewEncapsulation', moduleName: i };
|
|
static ComponentDeclaration = {
|
|
name: '\u0275\u0275ComponentDeclaration',
|
|
moduleName: i,
|
|
};
|
|
static FactoryDeclaration = {
|
|
name: '\u0275\u0275FactoryDeclaration',
|
|
moduleName: i,
|
|
};
|
|
static declareFactory = {
|
|
name: '\u0275\u0275ngDeclareFactory',
|
|
moduleName: i,
|
|
};
|
|
static FactoryTarget = {
|
|
name: '\u0275\u0275FactoryTarget',
|
|
moduleName: i,
|
|
};
|
|
static defineDirective = {
|
|
name: '\u0275\u0275defineDirective',
|
|
moduleName: i,
|
|
};
|
|
static declareDirective = {
|
|
name: '\u0275\u0275ngDeclareDirective',
|
|
moduleName: i,
|
|
};
|
|
static DirectiveDeclaration = {
|
|
name: '\u0275\u0275DirectiveDeclaration',
|
|
moduleName: i,
|
|
};
|
|
static InjectorDef = { name: '\u0275\u0275InjectorDef', moduleName: i };
|
|
static InjectorDeclaration = {
|
|
name: '\u0275\u0275InjectorDeclaration',
|
|
moduleName: i,
|
|
};
|
|
static defineInjector = {
|
|
name: '\u0275\u0275defineInjector',
|
|
moduleName: i,
|
|
};
|
|
static declareInjector = {
|
|
name: '\u0275\u0275ngDeclareInjector',
|
|
moduleName: i,
|
|
};
|
|
static NgModuleDeclaration = {
|
|
name: '\u0275\u0275NgModuleDeclaration',
|
|
moduleName: i,
|
|
};
|
|
static ModuleWithProviders = {
|
|
name: 'ModuleWithProviders',
|
|
moduleName: i,
|
|
};
|
|
static defineNgModule = {
|
|
name: '\u0275\u0275defineNgModule',
|
|
moduleName: i,
|
|
};
|
|
static declareNgModule = {
|
|
name: '\u0275\u0275ngDeclareNgModule',
|
|
moduleName: i,
|
|
};
|
|
static setNgModuleScope = {
|
|
name: '\u0275\u0275setNgModuleScope',
|
|
moduleName: i,
|
|
};
|
|
static registerNgModuleType = {
|
|
name: '\u0275\u0275registerNgModuleType',
|
|
moduleName: i,
|
|
};
|
|
static PipeDeclaration = {
|
|
name: '\u0275\u0275PipeDeclaration',
|
|
moduleName: i,
|
|
};
|
|
static definePipe = { name: '\u0275\u0275definePipe', moduleName: i };
|
|
static declarePipe = { name: '\u0275\u0275ngDeclarePipe', moduleName: i };
|
|
static declareClassMetadata = {
|
|
name: '\u0275\u0275ngDeclareClassMetadata',
|
|
moduleName: i,
|
|
};
|
|
static declareClassMetadataAsync = {
|
|
name: '\u0275\u0275ngDeclareClassMetadataAsync',
|
|
moduleName: i,
|
|
};
|
|
static setClassMetadata = {
|
|
name: '\u0275setClassMetadata',
|
|
moduleName: i,
|
|
};
|
|
static setClassMetadataAsync = {
|
|
name: '\u0275setClassMetadataAsync',
|
|
moduleName: i,
|
|
};
|
|
static setClassDebugInfo = {
|
|
name: '\u0275setClassDebugInfo',
|
|
moduleName: i,
|
|
};
|
|
static queryRefresh = { name: '\u0275\u0275queryRefresh', moduleName: i };
|
|
static viewQuery = { name: '\u0275\u0275viewQuery', moduleName: i };
|
|
static loadQuery = { name: '\u0275\u0275loadQuery', moduleName: i };
|
|
static contentQuery = { name: '\u0275\u0275contentQuery', moduleName: i };
|
|
static viewQuerySignal = {
|
|
name: '\u0275\u0275viewQuerySignal',
|
|
moduleName: i,
|
|
};
|
|
static contentQuerySignal = {
|
|
name: '\u0275\u0275contentQuerySignal',
|
|
moduleName: i,
|
|
};
|
|
static queryAdvance = { name: '\u0275\u0275queryAdvance', moduleName: i };
|
|
static twoWayProperty = {
|
|
name: '\u0275\u0275twoWayProperty',
|
|
moduleName: i,
|
|
};
|
|
static twoWayBindingSet = {
|
|
name: '\u0275\u0275twoWayBindingSet',
|
|
moduleName: i,
|
|
};
|
|
static twoWayListener = {
|
|
name: '\u0275\u0275twoWayListener',
|
|
moduleName: i,
|
|
};
|
|
static declareLet = { name: '\u0275\u0275declareLet', moduleName: i };
|
|
static storeLet = { name: '\u0275\u0275storeLet', moduleName: i };
|
|
static readContextLet = {
|
|
name: '\u0275\u0275readContextLet',
|
|
moduleName: i,
|
|
};
|
|
static attachSourceLocations = {
|
|
name: '\u0275\u0275attachSourceLocations',
|
|
moduleName: i,
|
|
};
|
|
static NgOnChangesFeature = {
|
|
name: '\u0275\u0275NgOnChangesFeature',
|
|
moduleName: i,
|
|
};
|
|
static InheritDefinitionFeature = {
|
|
name: '\u0275\u0275InheritDefinitionFeature',
|
|
moduleName: i,
|
|
};
|
|
static CopyDefinitionFeature = {
|
|
name: '\u0275\u0275CopyDefinitionFeature',
|
|
moduleName: i,
|
|
};
|
|
static ProvidersFeature = {
|
|
name: '\u0275\u0275ProvidersFeature',
|
|
moduleName: i,
|
|
};
|
|
static HostDirectivesFeature = {
|
|
name: '\u0275\u0275HostDirectivesFeature',
|
|
moduleName: i,
|
|
};
|
|
static InputTransformsFeatureFeature = {
|
|
name: '\u0275\u0275InputTransformsFeature',
|
|
moduleName: i,
|
|
};
|
|
static ExternalStylesFeature = {
|
|
name: '\u0275\u0275ExternalStylesFeature',
|
|
moduleName: i,
|
|
};
|
|
static listener = { name: '\u0275\u0275listener', moduleName: i };
|
|
static getInheritedFactory = {
|
|
name: '\u0275\u0275getInheritedFactory',
|
|
moduleName: i,
|
|
};
|
|
static sanitizeHtml = { name: '\u0275\u0275sanitizeHtml', moduleName: i };
|
|
static sanitizeStyle = {
|
|
name: '\u0275\u0275sanitizeStyle',
|
|
moduleName: i,
|
|
};
|
|
static sanitizeResourceUrl = {
|
|
name: '\u0275\u0275sanitizeResourceUrl',
|
|
moduleName: i,
|
|
};
|
|
static sanitizeScript = {
|
|
name: '\u0275\u0275sanitizeScript',
|
|
moduleName: i,
|
|
};
|
|
static sanitizeUrl = { name: '\u0275\u0275sanitizeUrl', moduleName: i };
|
|
static sanitizeUrlOrResourceUrl = {
|
|
name: '\u0275\u0275sanitizeUrlOrResourceUrl',
|
|
moduleName: i,
|
|
};
|
|
static trustConstantHtml = {
|
|
name: '\u0275\u0275trustConstantHtml',
|
|
moduleName: i,
|
|
};
|
|
static trustConstantResourceUrl = {
|
|
name: '\u0275\u0275trustConstantResourceUrl',
|
|
moduleName: i,
|
|
};
|
|
static validateIframeAttribute = {
|
|
name: '\u0275\u0275validateIframeAttribute',
|
|
moduleName: i,
|
|
};
|
|
static InputSignalBrandWriteType = {
|
|
name: '\u0275INPUT_SIGNAL_BRAND_WRITE_TYPE',
|
|
moduleName: i,
|
|
};
|
|
static UnwrapDirectiveSignalInputs = {
|
|
name: '\u0275UnwrapDirectiveSignalInputs',
|
|
moduleName: i,
|
|
};
|
|
static unwrapWritableSignal = {
|
|
name: '\u0275unwrapWritableSignal',
|
|
moduleName: i,
|
|
};
|
|
};
|
|
var Et = class {
|
|
full;
|
|
major;
|
|
minor;
|
|
patch;
|
|
constructor(e) {
|
|
this.full = e;
|
|
let n = e.split('.');
|
|
(this.major = n[0]),
|
|
(this.minor = n[1]),
|
|
(this.patch = n.slice(2).join('.'));
|
|
}
|
|
};
|
|
var on;
|
|
(function (t) {
|
|
(t[(t.Class = 0)] = 'Class'), (t[(t.Function = 1)] = 'Function');
|
|
})(on || (on = {}));
|
|
var an;
|
|
(function (t) {
|
|
(t[(t.Directive = 0)] = 'Directive'),
|
|
(t[(t.Component = 1)] = 'Component'),
|
|
(t[(t.Injectable = 2)] = 'Injectable'),
|
|
(t[(t.Pipe = 3)] = 'Pipe'),
|
|
(t[(t.NgModule = 4)] = 'NgModule');
|
|
})(an || (an = {}));
|
|
var ye = class {
|
|
input;
|
|
errLocation;
|
|
ctxLocation;
|
|
message;
|
|
constructor(e, n, s, r) {
|
|
(this.input = n),
|
|
(this.errLocation = s),
|
|
(this.ctxLocation = r),
|
|
(this.message = `Parser Error: ${e} ${s} [${n}] in ${r}`);
|
|
}
|
|
},
|
|
G = class {
|
|
start;
|
|
end;
|
|
constructor(e, n) {
|
|
(this.start = e), (this.end = n);
|
|
}
|
|
toAbsolute(e) {
|
|
return new O(e + this.start, e + this.end);
|
|
}
|
|
},
|
|
E = class {
|
|
span;
|
|
sourceSpan;
|
|
constructor(e, n) {
|
|
(this.span = e), (this.sourceSpan = n);
|
|
}
|
|
toString() {
|
|
return 'AST';
|
|
}
|
|
},
|
|
se = class extends E {
|
|
nameSpan;
|
|
constructor(e, n, s) {
|
|
super(e, n), (this.nameSpan = s);
|
|
}
|
|
},
|
|
b = class extends E {
|
|
visit(e, n = null) {}
|
|
},
|
|
X = class extends E {
|
|
visit(e, n = null) {
|
|
return e.visitImplicitReceiver(this, n);
|
|
}
|
|
},
|
|
yt = class extends X {
|
|
visit(e, n = null) {
|
|
var s;
|
|
return (s = e.visitThisReceiver) == null ? void 0 : s.call(e, this, n);
|
|
}
|
|
},
|
|
_e = class extends E {
|
|
expressions;
|
|
constructor(e, n, s) {
|
|
super(e, n), (this.expressions = s);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitChain(this, n);
|
|
}
|
|
},
|
|
Ce = class extends E {
|
|
condition;
|
|
trueExp;
|
|
falseExp;
|
|
constructor(e, n, s, r, o) {
|
|
super(e, n),
|
|
(this.condition = s),
|
|
(this.trueExp = r),
|
|
(this.falseExp = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitConditional(this, n);
|
|
}
|
|
},
|
|
re = class extends se {
|
|
receiver;
|
|
name;
|
|
constructor(e, n, s, r, o) {
|
|
super(e, n, s), (this.receiver = r), (this.name = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitPropertyRead(this, n);
|
|
}
|
|
},
|
|
Te = class extends se {
|
|
receiver;
|
|
name;
|
|
value;
|
|
constructor(e, n, s, r, o, a) {
|
|
super(e, n, s), (this.receiver = r), (this.name = o), (this.value = a);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitPropertyWrite(this, n);
|
|
}
|
|
},
|
|
ie = class extends se {
|
|
receiver;
|
|
name;
|
|
constructor(e, n, s, r, o) {
|
|
super(e, n, s), (this.receiver = r), (this.name = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitSafePropertyRead(this, n);
|
|
}
|
|
},
|
|
ke = class extends E {
|
|
receiver;
|
|
key;
|
|
constructor(e, n, s, r) {
|
|
super(e, n), (this.receiver = s), (this.key = r);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitKeyedRead(this, n);
|
|
}
|
|
},
|
|
oe = class extends E {
|
|
receiver;
|
|
key;
|
|
constructor(e, n, s, r) {
|
|
super(e, n), (this.receiver = s), (this.key = r);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitSafeKeyedRead(this, n);
|
|
}
|
|
},
|
|
Ie = class extends E {
|
|
receiver;
|
|
key;
|
|
value;
|
|
constructor(e, n, s, r, o) {
|
|
super(e, n), (this.receiver = s), (this.key = r), (this.value = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitKeyedWrite(this, n);
|
|
}
|
|
},
|
|
be = class extends se {
|
|
exp;
|
|
name;
|
|
args;
|
|
constructor(e, n, s, r, o, a) {
|
|
super(e, n, a), (this.exp = s), (this.name = r), (this.args = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitPipe(this, n);
|
|
}
|
|
},
|
|
N = class extends E {
|
|
value;
|
|
constructor(e, n, s) {
|
|
super(e, n), (this.value = s);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitLiteralPrimitive(this, n);
|
|
}
|
|
},
|
|
Ne = class extends E {
|
|
expressions;
|
|
constructor(e, n, s) {
|
|
super(e, n), (this.expressions = s);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitLiteralArray(this, n);
|
|
}
|
|
},
|
|
Ae = class extends E {
|
|
keys;
|
|
values;
|
|
constructor(e, n, s, r) {
|
|
super(e, n), (this.keys = s), (this.values = r);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitLiteralMap(this, n);
|
|
}
|
|
},
|
|
Pe = class extends E {
|
|
strings;
|
|
expressions;
|
|
constructor(e, n, s, r) {
|
|
super(e, n), (this.strings = s), (this.expressions = r);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitInterpolation(this, n);
|
|
}
|
|
},
|
|
A = class extends E {
|
|
operation;
|
|
left;
|
|
right;
|
|
constructor(e, n, s, r, o) {
|
|
super(e, n), (this.operation = s), (this.left = r), (this.right = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitBinary(this, n);
|
|
}
|
|
},
|
|
ae = class t extends A {
|
|
operator;
|
|
expr;
|
|
left = null;
|
|
right = null;
|
|
operation = null;
|
|
static createMinus(e, n, s) {
|
|
return new t(e, n, '-', s, '-', new N(e, n, 0), s);
|
|
}
|
|
static createPlus(e, n, s) {
|
|
return new t(e, n, '+', s, '-', s, new N(e, n, 0));
|
|
}
|
|
constructor(e, n, s, r, o, a, l) {
|
|
super(e, n, o, a, l), (this.operator = s), (this.expr = r);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitUnary !== void 0 ?
|
|
e.visitUnary(this, n)
|
|
: e.visitBinary(this, n);
|
|
}
|
|
},
|
|
Le = class extends E {
|
|
expression;
|
|
constructor(e, n, s) {
|
|
super(e, n), (this.expression = s);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitPrefixNot(this, n);
|
|
}
|
|
},
|
|
Me = class extends E {
|
|
expression;
|
|
constructor(e, n, s) {
|
|
super(e, n), (this.expression = s);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitTypeofExpression(this, n);
|
|
}
|
|
},
|
|
$e = class extends E {
|
|
expression;
|
|
constructor(e, n, s) {
|
|
super(e, n), (this.expression = s);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitNonNullAssert(this, n);
|
|
}
|
|
},
|
|
Re = class extends E {
|
|
receiver;
|
|
args;
|
|
argumentSpan;
|
|
constructor(e, n, s, r, o) {
|
|
super(e, n),
|
|
(this.receiver = s),
|
|
(this.args = r),
|
|
(this.argumentSpan = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitCall(this, n);
|
|
}
|
|
},
|
|
le = class extends E {
|
|
receiver;
|
|
args;
|
|
argumentSpan;
|
|
constructor(e, n, s, r, o) {
|
|
super(e, n),
|
|
(this.receiver = s),
|
|
(this.args = r),
|
|
(this.argumentSpan = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitSafeCall(this, n);
|
|
}
|
|
},
|
|
O = class {
|
|
start;
|
|
end;
|
|
constructor(e, n) {
|
|
(this.start = e), (this.end = n);
|
|
}
|
|
},
|
|
W = class extends E {
|
|
ast;
|
|
source;
|
|
location;
|
|
errors;
|
|
constructor(e, n, s, r, o) {
|
|
super(
|
|
new G(0, n === null ? 0 : n.length),
|
|
new O(r, n === null ? r : r + n.length)
|
|
),
|
|
(this.ast = e),
|
|
(this.source = n),
|
|
(this.location = s),
|
|
(this.errors = o);
|
|
}
|
|
visit(e, n = null) {
|
|
return e.visitASTWithSource ?
|
|
e.visitASTWithSource(this, n)
|
|
: this.ast.visit(e, n);
|
|
}
|
|
toString() {
|
|
return `${this.source} in ${this.location}`;
|
|
}
|
|
},
|
|
ce = class {
|
|
sourceSpan;
|
|
key;
|
|
value;
|
|
constructor(e, n, s) {
|
|
(this.sourceSpan = e), (this.key = n), (this.value = s);
|
|
}
|
|
},
|
|
Be = class {
|
|
sourceSpan;
|
|
key;
|
|
value;
|
|
constructor(e, n, s) {
|
|
(this.sourceSpan = e), (this.key = n), (this.value = s);
|
|
}
|
|
},
|
|
_t = class {
|
|
visit(e, n) {
|
|
e.visit(this, n);
|
|
}
|
|
visitUnary(e, n) {
|
|
this.visit(e.expr, n);
|
|
}
|
|
visitBinary(e, n) {
|
|
this.visit(e.left, n), this.visit(e.right, n);
|
|
}
|
|
visitChain(e, n) {
|
|
this.visitAll(e.expressions, n);
|
|
}
|
|
visitConditional(e, n) {
|
|
this.visit(e.condition, n),
|
|
this.visit(e.trueExp, n),
|
|
this.visit(e.falseExp, n);
|
|
}
|
|
visitPipe(e, n) {
|
|
this.visit(e.exp, n), this.visitAll(e.args, n);
|
|
}
|
|
visitImplicitReceiver(e, n) {}
|
|
visitThisReceiver(e, n) {}
|
|
visitInterpolation(e, n) {
|
|
this.visitAll(e.expressions, n);
|
|
}
|
|
visitKeyedRead(e, n) {
|
|
this.visit(e.receiver, n), this.visit(e.key, n);
|
|
}
|
|
visitKeyedWrite(e, n) {
|
|
this.visit(e.receiver, n), this.visit(e.key, n), this.visit(e.value, n);
|
|
}
|
|
visitLiteralArray(e, n) {
|
|
this.visitAll(e.expressions, n);
|
|
}
|
|
visitLiteralMap(e, n) {
|
|
this.visitAll(e.values, n);
|
|
}
|
|
visitLiteralPrimitive(e, n) {}
|
|
visitPrefixNot(e, n) {
|
|
this.visit(e.expression, n);
|
|
}
|
|
visitTypeofExpression(e, n) {
|
|
this.visit(e.expression, n);
|
|
}
|
|
visitNonNullAssert(e, n) {
|
|
this.visit(e.expression, n);
|
|
}
|
|
visitPropertyRead(e, n) {
|
|
this.visit(e.receiver, n);
|
|
}
|
|
visitPropertyWrite(e, n) {
|
|
this.visit(e.receiver, n), this.visit(e.value, n);
|
|
}
|
|
visitSafePropertyRead(e, n) {
|
|
this.visit(e.receiver, n);
|
|
}
|
|
visitSafeKeyedRead(e, n) {
|
|
this.visit(e.receiver, n), this.visit(e.key, n);
|
|
}
|
|
visitCall(e, n) {
|
|
this.visit(e.receiver, n), this.visitAll(e.args, n);
|
|
}
|
|
visitSafeCall(e, n) {
|
|
this.visit(e.receiver, n), this.visitAll(e.args, n);
|
|
}
|
|
visitAll(e, n) {
|
|
for (let s of e) this.visit(s, n);
|
|
}
|
|
};
|
|
var ln;
|
|
(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');
|
|
})(ln || (ln = {}));
|
|
var cn;
|
|
(function (t) {
|
|
(t[(t.Regular = 0)] = 'Regular'),
|
|
(t[(t.Animation = 1)] = 'Animation'),
|
|
(t[(t.TwoWay = 2)] = 'TwoWay');
|
|
})(cn || (cn = {}));
|
|
var H;
|
|
(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');
|
|
})(H || (H = {}));
|
|
var un;
|
|
(function (t) {
|
|
(t[(t.RAW_TEXT = 0)] = 'RAW_TEXT'),
|
|
(t[(t.ESCAPABLE_RAW_TEXT = 1)] = 'ESCAPABLE_RAW_TEXT'),
|
|
(t[(t.PARSABLE_DATA = 2)] = 'PARSABLE_DATA');
|
|
})(un || (un = {}));
|
|
var Ws = [/@/, /^\s*$/, /[<>]/, /^[{}]$/, /&(#|[a-z])/i, /^\/\//];
|
|
function qs(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 n = e[0],
|
|
s = e[1];
|
|
Ws.forEach((r) => {
|
|
if (r.test(n) || r.test(s))
|
|
throw new Error(
|
|
`['${n}', '${s}'] contains unusable interpolation symbol.`
|
|
);
|
|
});
|
|
}
|
|
}
|
|
var Ct = class t {
|
|
start;
|
|
end;
|
|
static fromArray(e) {
|
|
return e ? (qs('interpolation', e), new t(e[0], e[1])) : Z;
|
|
}
|
|
constructor(e, n) {
|
|
(this.start = e), (this.end = n);
|
|
}
|
|
},
|
|
Z = new Ct('{{', '}}');
|
|
var at = 0;
|
|
var Un = 9,
|
|
js = 10,
|
|
zs = 11,
|
|
Gs = 12,
|
|
Xs = 13,
|
|
Wn = 32,
|
|
Js = 33,
|
|
qn = 34,
|
|
Ys = 35,
|
|
jn = 36,
|
|
Qs = 37,
|
|
pn = 38,
|
|
zn = 39,
|
|
je = 40,
|
|
me = 41,
|
|
Ks = 42,
|
|
Gn = 43,
|
|
ge = 44,
|
|
Xn = 45,
|
|
ee = 46,
|
|
Tt = 47,
|
|
te = 58,
|
|
ve = 59,
|
|
Zs = 60,
|
|
qe = 61,
|
|
er = 62,
|
|
hn = 63,
|
|
tr = 48;
|
|
var nr = 57,
|
|
Jn = 65,
|
|
sr = 69;
|
|
var Yn = 90,
|
|
ze = 91,
|
|
rr = 92,
|
|
we = 93,
|
|
ir = 94,
|
|
$t = 95,
|
|
Qn = 97;
|
|
var or = 101,
|
|
ar = 102,
|
|
lr = 110,
|
|
cr = 114,
|
|
ur = 116,
|
|
pr = 117,
|
|
hr = 118;
|
|
var Kn = 122,
|
|
kt = 123,
|
|
fn = 124,
|
|
xe = 125,
|
|
Zn = 160;
|
|
var fr = 96;
|
|
function dr(t) {
|
|
return (t >= Un && t <= Wn) || t == Zn;
|
|
}
|
|
function j(t) {
|
|
return tr <= t && t <= nr;
|
|
}
|
|
function mr(t) {
|
|
return (t >= Qn && t <= Kn) || (t >= Jn && t <= Yn);
|
|
}
|
|
function dn(t) {
|
|
return t === zn || t === qn || t === fr;
|
|
}
|
|
var mn;
|
|
(function (t) {
|
|
(t[(t.WARNING = 0)] = 'WARNING'), (t[(t.ERROR = 1)] = 'ERROR');
|
|
})(mn || (mn = {}));
|
|
var gn;
|
|
(function (t) {
|
|
(t[(t.Inline = 0)] = 'Inline'),
|
|
(t[(t.SideEffect = 1)] = 'SideEffect'),
|
|
(t[(t.Omit = 2)] = 'Omit');
|
|
})(gn || (gn = {}));
|
|
var vn;
|
|
(function (t) {
|
|
(t[(t.Global = 0)] = 'Global'), (t[(t.Local = 1)] = 'Local');
|
|
})(vn || (vn = {}));
|
|
var wn;
|
|
(function (t) {
|
|
(t[(t.Directive = 0)] = 'Directive'),
|
|
(t[(t.Pipe = 1)] = 'Pipe'),
|
|
(t[(t.NgModule = 2)] = 'NgModule');
|
|
})(wn || (wn = {}));
|
|
var gr = '(:(where|is)\\()?';
|
|
var es = '-shadowcsshost',
|
|
ts = '-shadowcsscontext',
|
|
Rt = '(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)',
|
|
ei = new RegExp(es + Rt, 'gim'),
|
|
ti = new RegExp(gr + '(' + ts + Rt + ')', 'gim'),
|
|
ni = new RegExp(ts + Rt, 'im'),
|
|
vr = es + '-no-combinator',
|
|
si = new RegExp(`${vr}(?![^(]*\\))`, 'g');
|
|
var ns = '%COMMENT%',
|
|
ri = new RegExp(ns, 'g');
|
|
var ii = new RegExp(
|
|
`(\\s*(?:${ns}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`,
|
|
'g'
|
|
);
|
|
var wr = '%COMMA_IN_PLACEHOLDER%',
|
|
xr = '%SEMI_IN_PLACEHOLDER%',
|
|
Sr = '%COLON_IN_PLACEHOLDER%',
|
|
oi = new RegExp(wr, 'g'),
|
|
ai = new RegExp(xr, 'g'),
|
|
li = new RegExp(Sr, 'g');
|
|
var f;
|
|
(function (t) {
|
|
(t[(t.ListEnd = 0)] = 'ListEnd'),
|
|
(t[(t.Statement = 1)] = 'Statement'),
|
|
(t[(t.Variable = 2)] = 'Variable'),
|
|
(t[(t.ElementStart = 3)] = 'ElementStart'),
|
|
(t[(t.Element = 4)] = 'Element'),
|
|
(t[(t.Template = 5)] = 'Template'),
|
|
(t[(t.ElementEnd = 6)] = 'ElementEnd'),
|
|
(t[(t.ContainerStart = 7)] = 'ContainerStart'),
|
|
(t[(t.Container = 8)] = 'Container'),
|
|
(t[(t.ContainerEnd = 9)] = 'ContainerEnd'),
|
|
(t[(t.DisableBindings = 10)] = 'DisableBindings'),
|
|
(t[(t.Conditional = 11)] = 'Conditional'),
|
|
(t[(t.EnableBindings = 12)] = 'EnableBindings'),
|
|
(t[(t.Text = 13)] = 'Text'),
|
|
(t[(t.Listener = 14)] = 'Listener'),
|
|
(t[(t.InterpolateText = 15)] = 'InterpolateText'),
|
|
(t[(t.Binding = 16)] = 'Binding'),
|
|
(t[(t.Property = 17)] = 'Property'),
|
|
(t[(t.StyleProp = 18)] = 'StyleProp'),
|
|
(t[(t.ClassProp = 19)] = 'ClassProp'),
|
|
(t[(t.StyleMap = 20)] = 'StyleMap'),
|
|
(t[(t.ClassMap = 21)] = 'ClassMap'),
|
|
(t[(t.Advance = 22)] = 'Advance'),
|
|
(t[(t.Pipe = 23)] = 'Pipe'),
|
|
(t[(t.Attribute = 24)] = 'Attribute'),
|
|
(t[(t.ExtractedAttribute = 25)] = 'ExtractedAttribute'),
|
|
(t[(t.Defer = 26)] = 'Defer'),
|
|
(t[(t.DeferOn = 27)] = 'DeferOn'),
|
|
(t[(t.DeferWhen = 28)] = 'DeferWhen'),
|
|
(t[(t.I18nMessage = 29)] = 'I18nMessage'),
|
|
(t[(t.HostProperty = 30)] = 'HostProperty'),
|
|
(t[(t.Namespace = 31)] = 'Namespace'),
|
|
(t[(t.ProjectionDef = 32)] = 'ProjectionDef'),
|
|
(t[(t.Projection = 33)] = 'Projection'),
|
|
(t[(t.RepeaterCreate = 34)] = 'RepeaterCreate'),
|
|
(t[(t.Repeater = 35)] = 'Repeater'),
|
|
(t[(t.TwoWayProperty = 36)] = 'TwoWayProperty'),
|
|
(t[(t.TwoWayListener = 37)] = 'TwoWayListener'),
|
|
(t[(t.DeclareLet = 38)] = 'DeclareLet'),
|
|
(t[(t.StoreLet = 39)] = 'StoreLet'),
|
|
(t[(t.I18nStart = 40)] = 'I18nStart'),
|
|
(t[(t.I18n = 41)] = 'I18n'),
|
|
(t[(t.I18nEnd = 42)] = 'I18nEnd'),
|
|
(t[(t.I18nExpression = 43)] = 'I18nExpression'),
|
|
(t[(t.I18nApply = 44)] = 'I18nApply'),
|
|
(t[(t.IcuStart = 45)] = 'IcuStart'),
|
|
(t[(t.IcuEnd = 46)] = 'IcuEnd'),
|
|
(t[(t.IcuPlaceholder = 47)] = 'IcuPlaceholder'),
|
|
(t[(t.I18nContext = 48)] = 'I18nContext'),
|
|
(t[(t.I18nAttributes = 49)] = 'I18nAttributes'),
|
|
(t[(t.SourceLocation = 50)] = 'SourceLocation');
|
|
})(f || (f = {}));
|
|
var J;
|
|
(function (t) {
|
|
(t[(t.LexicalRead = 0)] = 'LexicalRead'),
|
|
(t[(t.Context = 1)] = 'Context'),
|
|
(t[(t.TrackContext = 2)] = 'TrackContext'),
|
|
(t[(t.ReadVariable = 3)] = 'ReadVariable'),
|
|
(t[(t.NextContext = 4)] = 'NextContext'),
|
|
(t[(t.Reference = 5)] = 'Reference'),
|
|
(t[(t.StoreLet = 6)] = 'StoreLet'),
|
|
(t[(t.ContextLetReference = 7)] = 'ContextLetReference'),
|
|
(t[(t.GetCurrentView = 8)] = 'GetCurrentView'),
|
|
(t[(t.RestoreView = 9)] = 'RestoreView'),
|
|
(t[(t.ResetView = 10)] = 'ResetView'),
|
|
(t[(t.PureFunctionExpr = 11)] = 'PureFunctionExpr'),
|
|
(t[(t.PureFunctionParameterExpr = 12)] = 'PureFunctionParameterExpr'),
|
|
(t[(t.PipeBinding = 13)] = 'PipeBinding'),
|
|
(t[(t.PipeBindingVariadic = 14)] = 'PipeBindingVariadic'),
|
|
(t[(t.SafePropertyRead = 15)] = 'SafePropertyRead'),
|
|
(t[(t.SafeKeyedRead = 16)] = 'SafeKeyedRead'),
|
|
(t[(t.SafeInvokeFunction = 17)] = 'SafeInvokeFunction'),
|
|
(t[(t.SafeTernaryExpr = 18)] = 'SafeTernaryExpr'),
|
|
(t[(t.EmptyExpr = 19)] = 'EmptyExpr'),
|
|
(t[(t.AssignTemporaryExpr = 20)] = 'AssignTemporaryExpr'),
|
|
(t[(t.ReadTemporaryExpr = 21)] = 'ReadTemporaryExpr'),
|
|
(t[(t.SlotLiteralExpr = 22)] = 'SlotLiteralExpr'),
|
|
(t[(t.ConditionalCase = 23)] = 'ConditionalCase'),
|
|
(t[(t.ConstCollected = 24)] = 'ConstCollected'),
|
|
(t[(t.TwoWayBindingSet = 25)] = 'TwoWayBindingSet');
|
|
})(J || (J = {}));
|
|
var xn;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'), (t[(t.AlwaysInline = 1)] = 'AlwaysInline');
|
|
})(xn || (xn = {}));
|
|
var Sn;
|
|
(function (t) {
|
|
(t[(t.Context = 0)] = 'Context'),
|
|
(t[(t.Identifier = 1)] = 'Identifier'),
|
|
(t[(t.SavedView = 2)] = 'SavedView'),
|
|
(t[(t.Alias = 3)] = 'Alias');
|
|
})(Sn || (Sn = {}));
|
|
var En;
|
|
(function (t) {
|
|
(t[(t.Normal = 0)] = 'Normal'),
|
|
(t[(t.TemplateDefinitionBuilder = 1)] = 'TemplateDefinitionBuilder');
|
|
})(En || (En = {}));
|
|
var U;
|
|
(function (t) {
|
|
(t[(t.Attribute = 0)] = 'Attribute'),
|
|
(t[(t.ClassName = 1)] = 'ClassName'),
|
|
(t[(t.StyleProperty = 2)] = 'StyleProperty'),
|
|
(t[(t.Property = 3)] = 'Property'),
|
|
(t[(t.Template = 4)] = 'Template'),
|
|
(t[(t.I18n = 5)] = 'I18n'),
|
|
(t[(t.Animation = 6)] = 'Animation'),
|
|
(t[(t.TwoWayProperty = 7)] = 'TwoWayProperty');
|
|
})(U || (U = {}));
|
|
var yn;
|
|
(function (t) {
|
|
(t[(t.Creation = 0)] = 'Creation'),
|
|
(t[(t.Postproccessing = 1)] = 'Postproccessing');
|
|
})(yn || (yn = {}));
|
|
var _n;
|
|
(function (t) {
|
|
(t[(t.I18nText = 0)] = 'I18nText'),
|
|
(t[(t.I18nAttribute = 1)] = 'I18nAttribute');
|
|
})(_n || (_n = {}));
|
|
var Cn;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'),
|
|
(t[(t.ElementTag = 1)] = 'ElementTag'),
|
|
(t[(t.TemplateTag = 2)] = 'TemplateTag'),
|
|
(t[(t.OpenTag = 4)] = 'OpenTag'),
|
|
(t[(t.CloseTag = 8)] = 'CloseTag'),
|
|
(t[(t.ExpressionIndex = 16)] = 'ExpressionIndex');
|
|
})(Cn || (Cn = {}));
|
|
var Tn;
|
|
(function (t) {
|
|
(t[(t.HTML = 0)] = 'HTML'),
|
|
(t[(t.SVG = 1)] = 'SVG'),
|
|
(t[(t.Math = 2)] = 'Math');
|
|
})(Tn || (Tn = {}));
|
|
var kn;
|
|
(function (t) {
|
|
(t[(t.Idle = 0)] = 'Idle'),
|
|
(t[(t.Immediate = 1)] = 'Immediate'),
|
|
(t[(t.Timer = 2)] = 'Timer'),
|
|
(t[(t.Hover = 3)] = 'Hover'),
|
|
(t[(t.Interaction = 4)] = 'Interaction'),
|
|
(t[(t.Viewport = 5)] = 'Viewport'),
|
|
(t[(t.Never = 6)] = 'Never');
|
|
})(kn || (kn = {}));
|
|
var In;
|
|
(function (t) {
|
|
(t[(t.RootI18n = 0)] = 'RootI18n'),
|
|
(t[(t.Icu = 1)] = 'Icu'),
|
|
(t[(t.Attr = 2)] = 'Attr');
|
|
})(In || (In = {}));
|
|
var bn;
|
|
(function (t) {
|
|
(t[(t.NgTemplate = 0)] = 'NgTemplate'),
|
|
(t[(t.Structural = 1)] = 'Structural'),
|
|
(t[(t.Block = 2)] = 'Block');
|
|
})(bn || (bn = {}));
|
|
var Er = Symbol('ConsumesSlot'),
|
|
ss = Symbol('DependsOnSlotContext'),
|
|
Oe = Symbol('ConsumesVars'),
|
|
Bt = Symbol('UsesVarOffset'),
|
|
ci = { [Er]: !0, numSlotsUsed: 1 },
|
|
ui = { [ss]: !0 },
|
|
pi = { [Oe]: !0 };
|
|
var Ze = class {
|
|
strings;
|
|
expressions;
|
|
i18nPlaceholders;
|
|
constructor(e, n, s) {
|
|
if (
|
|
((this.strings = e),
|
|
(this.expressions = n),
|
|
(this.i18nPlaceholders = s),
|
|
s.length !== 0 && s.length !== n.length)
|
|
)
|
|
throw new Error(
|
|
`Expected ${n.length} placeholders to match interpolation expression count, but got ${s.length}`
|
|
);
|
|
}
|
|
};
|
|
var Y = class extends k {
|
|
constructor(e = null) {
|
|
super(null, e);
|
|
}
|
|
};
|
|
var Nn = class t extends Y {
|
|
target;
|
|
value;
|
|
sourceSpan;
|
|
kind = J.StoreLet;
|
|
[Oe] = !0;
|
|
[ss] = !0;
|
|
constructor(e, n, s) {
|
|
super(), (this.target = e), (this.value = n), (this.sourceSpan = s);
|
|
}
|
|
visitExpression() {}
|
|
isEquivalent(e) {
|
|
return (
|
|
e instanceof t &&
|
|
e.target === this.target &&
|
|
e.value.isEquivalent(this.value)
|
|
);
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
transformInternalExpressions(e, n) {
|
|
this.value = (this.value, void 0);
|
|
}
|
|
clone() {
|
|
return new t(this.target, this.value, this.sourceSpan);
|
|
}
|
|
};
|
|
var An = class t extends Y {
|
|
kind = J.PureFunctionExpr;
|
|
[Oe] = !0;
|
|
[Bt] = !0;
|
|
varOffset = null;
|
|
body;
|
|
args;
|
|
fn = null;
|
|
constructor(e, n) {
|
|
super(), (this.body = e), (this.args = n);
|
|
}
|
|
visitExpression(e, n) {
|
|
var s;
|
|
(s = this.body) == null || s.visitExpression(e, n);
|
|
for (let r of this.args) r.visitExpression(e, n);
|
|
}
|
|
isEquivalent(e) {
|
|
return !(e instanceof t) || e.args.length !== this.args.length ?
|
|
!1
|
|
: e.body !== null &&
|
|
this.body !== null &&
|
|
e.body.isEquivalent(this.body) &&
|
|
e.args.every((n, s) => n.isEquivalent(this.args[s]));
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
transformInternalExpressions(e, n) {
|
|
this.body !== null ?
|
|
(this.body = (this.body, n | Nt.InChildOperation, void 0))
|
|
: this.fn !== null && (this.fn = (this.fn, void 0));
|
|
for (let s = 0; s < this.args.length; s++)
|
|
this.args[s] = (this.args[s], void 0);
|
|
}
|
|
clone() {
|
|
var n, s;
|
|
let e = new t(
|
|
((n = this.body) == null ? void 0 : n.clone()) ?? null,
|
|
this.args.map((r) => r.clone())
|
|
);
|
|
return (
|
|
(e.fn = ((s = this.fn) == null ? void 0 : s.clone()) ?? null),
|
|
(e.varOffset = this.varOffset),
|
|
e
|
|
);
|
|
}
|
|
};
|
|
var It = class t extends Y {
|
|
target;
|
|
targetSlot;
|
|
name;
|
|
args;
|
|
kind = J.PipeBinding;
|
|
[Oe] = !0;
|
|
[Bt] = !0;
|
|
varOffset = null;
|
|
constructor(e, n, s, r) {
|
|
super(),
|
|
(this.target = e),
|
|
(this.targetSlot = n),
|
|
(this.name = s),
|
|
(this.args = r);
|
|
}
|
|
visitExpression(e, n) {
|
|
for (let s of this.args) s.visitExpression(e, n);
|
|
}
|
|
isEquivalent() {
|
|
return !1;
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
transformInternalExpressions(e, n) {
|
|
for (let s = 0; s < this.args.length; s++)
|
|
this.args[s] = (this.args[s], void 0);
|
|
}
|
|
clone() {
|
|
let e = new t(
|
|
this.target,
|
|
this.targetSlot,
|
|
this.name,
|
|
this.args.map((n) => n.clone())
|
|
);
|
|
return (e.varOffset = this.varOffset), e;
|
|
}
|
|
},
|
|
Pn = class t extends Y {
|
|
target;
|
|
targetSlot;
|
|
name;
|
|
args;
|
|
numArgs;
|
|
kind = J.PipeBindingVariadic;
|
|
[Oe] = !0;
|
|
[Bt] = !0;
|
|
varOffset = null;
|
|
constructor(e, n, s, r, o) {
|
|
super(),
|
|
(this.target = e),
|
|
(this.targetSlot = n),
|
|
(this.name = s),
|
|
(this.args = r),
|
|
(this.numArgs = o);
|
|
}
|
|
visitExpression(e, n) {
|
|
this.args.visitExpression(e, n);
|
|
}
|
|
isEquivalent() {
|
|
return !1;
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
transformInternalExpressions(e, n) {
|
|
this.args = (this.args, void 0);
|
|
}
|
|
clone() {
|
|
let e = new t(
|
|
this.target,
|
|
this.targetSlot,
|
|
this.name,
|
|
this.args.clone(),
|
|
this.numArgs
|
|
);
|
|
return (e.varOffset = this.varOffset), e;
|
|
}
|
|
};
|
|
var bt = class t extends Y {
|
|
receiver;
|
|
args;
|
|
kind = J.SafeInvokeFunction;
|
|
constructor(e, n) {
|
|
super(), (this.receiver = e), (this.args = n);
|
|
}
|
|
visitExpression(e, n) {
|
|
this.receiver.visitExpression(e, n);
|
|
for (let s of this.args) s.visitExpression(e, n);
|
|
}
|
|
isEquivalent() {
|
|
return !1;
|
|
}
|
|
isConstant() {
|
|
return !1;
|
|
}
|
|
transformInternalExpressions(e, n) {
|
|
this.receiver = (this.receiver, void 0);
|
|
for (let s = 0; s < this.args.length; s++)
|
|
this.args[s] = (this.args[s], void 0);
|
|
}
|
|
clone() {
|
|
return new t(
|
|
this.receiver.clone(),
|
|
this.args.map((e) => e.clone())
|
|
);
|
|
}
|
|
};
|
|
var Nt;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'),
|
|
(t[(t.InChildOperation = 1)] = 'InChildOperation');
|
|
})(Nt || (Nt = {}));
|
|
var hi = new Set([
|
|
f.Element,
|
|
f.ElementStart,
|
|
f.Container,
|
|
f.ContainerStart,
|
|
f.Template,
|
|
f.RepeaterCreate,
|
|
]);
|
|
var Ln;
|
|
(function (t) {
|
|
(t[(t.Tmpl = 0)] = 'Tmpl'),
|
|
(t[(t.Host = 1)] = 'Host'),
|
|
(t[(t.Both = 2)] = 'Both');
|
|
})(Ln || (Ln = {}));
|
|
var fi = Object.freeze([]);
|
|
var di = new Map([
|
|
[f.ElementEnd, [f.ElementStart, f.Element]],
|
|
[f.ContainerEnd, [f.ContainerStart, f.Container]],
|
|
[f.I18nEnd, [f.I18nStart, f.I18n]],
|
|
]),
|
|
mi = new Set([f.Pipe]);
|
|
var gi = [Xe, Ye, Qe, bt, It].map((t) => t.constructor.name);
|
|
var yr = {},
|
|
_r = '\uE500';
|
|
yr.ngsp = _r;
|
|
var Mn;
|
|
(function (t) {
|
|
(t.HEX = 'hexadecimal'), (t.DEC = 'decimal');
|
|
})(Mn || (Mn = {}));
|
|
var rs = ` \f
|
|
\r \v\u1680\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF`,
|
|
vi = new RegExp(`[^${rs}]`),
|
|
wi = new RegExp(`[${rs}]{2,}`, 'g');
|
|
var d;
|
|
(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');
|
|
})(d || (d = {}));
|
|
var Cr = [
|
|
'var',
|
|
'let',
|
|
'as',
|
|
'null',
|
|
'undefined',
|
|
'true',
|
|
'false',
|
|
'if',
|
|
'else',
|
|
'this',
|
|
'typeof',
|
|
],
|
|
De = class {
|
|
tokenize(e) {
|
|
let n = new At(e),
|
|
s = [],
|
|
r = n.scanToken();
|
|
for (; r != null; ) s.push(r), (r = n.scanToken());
|
|
return s;
|
|
}
|
|
},
|
|
M = class {
|
|
index;
|
|
end;
|
|
type;
|
|
numValue;
|
|
strValue;
|
|
constructor(e, n, s, r, o) {
|
|
(this.index = e),
|
|
(this.end = n),
|
|
(this.type = s),
|
|
(this.numValue = r),
|
|
(this.strValue = o);
|
|
}
|
|
isCharacter(e) {
|
|
return this.type == d.Character && this.numValue == e;
|
|
}
|
|
isNumber() {
|
|
return this.type == d.Number;
|
|
}
|
|
isString() {
|
|
return this.type == d.String;
|
|
}
|
|
isOperator(e) {
|
|
return this.type == d.Operator && this.strValue == e;
|
|
}
|
|
isIdentifier() {
|
|
return this.type == d.Identifier;
|
|
}
|
|
isPrivateIdentifier() {
|
|
return this.type == d.PrivateIdentifier;
|
|
}
|
|
isKeyword() {
|
|
return this.type == d.Keyword;
|
|
}
|
|
isKeywordLet() {
|
|
return this.type == d.Keyword && this.strValue == 'let';
|
|
}
|
|
isKeywordAs() {
|
|
return this.type == d.Keyword && this.strValue == 'as';
|
|
}
|
|
isKeywordNull() {
|
|
return this.type == d.Keyword && this.strValue == 'null';
|
|
}
|
|
isKeywordUndefined() {
|
|
return this.type == d.Keyword && this.strValue == 'undefined';
|
|
}
|
|
isKeywordTrue() {
|
|
return this.type == d.Keyword && this.strValue == 'true';
|
|
}
|
|
isKeywordFalse() {
|
|
return this.type == d.Keyword && this.strValue == 'false';
|
|
}
|
|
isKeywordThis() {
|
|
return this.type == d.Keyword && this.strValue == 'this';
|
|
}
|
|
isKeywordTypeof() {
|
|
return this.type === d.Keyword && this.strValue === 'typeof';
|
|
}
|
|
isError() {
|
|
return this.type == d.Error;
|
|
}
|
|
toNumber() {
|
|
return this.type == d.Number ? this.numValue : -1;
|
|
}
|
|
toString() {
|
|
switch (this.type) {
|
|
case d.Character:
|
|
case d.Identifier:
|
|
case d.Keyword:
|
|
case d.Operator:
|
|
case d.PrivateIdentifier:
|
|
case d.String:
|
|
case d.Error:
|
|
return this.strValue;
|
|
case d.Number:
|
|
return this.numValue.toString();
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
function $n(t, e, n) {
|
|
return new M(t, e, d.Character, n, String.fromCharCode(n));
|
|
}
|
|
function Tr(t, e, n) {
|
|
return new M(t, e, d.Identifier, 0, n);
|
|
}
|
|
function kr(t, e, n) {
|
|
return new M(t, e, d.PrivateIdentifier, 0, n);
|
|
}
|
|
function Ir(t, e, n) {
|
|
return new M(t, e, d.Keyword, 0, n);
|
|
}
|
|
function lt(t, e, n) {
|
|
return new M(t, e, d.Operator, 0, n);
|
|
}
|
|
function br(t, e, n) {
|
|
return new M(t, e, d.String, 0, n);
|
|
}
|
|
function Nr(t, e, n) {
|
|
return new M(t, e, d.Number, n, '');
|
|
}
|
|
function Ar(t, e, n) {
|
|
return new M(t, e, d.Error, 0, n);
|
|
}
|
|
var ct = new M(-1, -1, d.Character, 0, ''),
|
|
At = class {
|
|
input;
|
|
length;
|
|
peek = 0;
|
|
index = -1;
|
|
constructor(e) {
|
|
(this.input = e), (this.length = e.length), this.advance();
|
|
}
|
|
advance() {
|
|
this.peek =
|
|
++this.index >= this.length ? at : this.input.charCodeAt(this.index);
|
|
}
|
|
scanToken() {
|
|
let e = this.input,
|
|
n = this.length,
|
|
s = this.peek,
|
|
r = this.index;
|
|
for (; s <= Wn; )
|
|
if (++r >= n) {
|
|
s = at;
|
|
break;
|
|
} else s = e.charCodeAt(r);
|
|
if (((this.peek = s), (this.index = r), r >= n)) return null;
|
|
if (Rn(s)) return this.scanIdentifier();
|
|
if (j(s)) return this.scanNumber(r);
|
|
let o = r;
|
|
switch (s) {
|
|
case ee:
|
|
return (
|
|
this.advance(),
|
|
j(this.peek) ? this.scanNumber(o) : $n(o, this.index, ee)
|
|
);
|
|
case je:
|
|
case me:
|
|
case kt:
|
|
case xe:
|
|
case ze:
|
|
case we:
|
|
case ge:
|
|
case te:
|
|
case ve:
|
|
return this.scanCharacter(o, s);
|
|
case zn:
|
|
case qn:
|
|
return this.scanString();
|
|
case Ys:
|
|
return this.scanPrivateIdentifier();
|
|
case Gn:
|
|
case Xn:
|
|
case Ks:
|
|
case Tt:
|
|
case Qs:
|
|
case ir:
|
|
return this.scanOperator(o, String.fromCharCode(s));
|
|
case hn:
|
|
return this.scanQuestion(o);
|
|
case Zs:
|
|
case er:
|
|
return this.scanComplexOperator(o, String.fromCharCode(s), qe, '=');
|
|
case Js:
|
|
case qe:
|
|
return this.scanComplexOperator(
|
|
o,
|
|
String.fromCharCode(s),
|
|
qe,
|
|
'=',
|
|
qe,
|
|
'='
|
|
);
|
|
case pn:
|
|
return this.scanComplexOperator(o, '&', pn, '&');
|
|
case fn:
|
|
return this.scanComplexOperator(o, '|', fn, '|');
|
|
case Zn:
|
|
for (; dr(this.peek); ) this.advance();
|
|
return this.scanToken();
|
|
}
|
|
return (
|
|
this.advance(),
|
|
this.error(`Unexpected character [${String.fromCharCode(s)}]`, 0)
|
|
);
|
|
}
|
|
scanCharacter(e, n) {
|
|
return this.advance(), $n(e, this.index, n);
|
|
}
|
|
scanOperator(e, n) {
|
|
return this.advance(), lt(e, this.index, n);
|
|
}
|
|
scanComplexOperator(e, n, s, r, o, a) {
|
|
this.advance();
|
|
let l = n;
|
|
return (
|
|
this.peek == s && (this.advance(), (l += r)),
|
|
o != null && this.peek == o && (this.advance(), (l += a)),
|
|
lt(e, this.index, l)
|
|
);
|
|
}
|
|
scanIdentifier() {
|
|
let e = this.index;
|
|
for (this.advance(); Bn(this.peek); ) this.advance();
|
|
let n = this.input.substring(e, this.index);
|
|
return Cr.indexOf(n) > -1 ? Ir(e, this.index, n) : Tr(e, this.index, n);
|
|
}
|
|
scanPrivateIdentifier() {
|
|
let e = this.index;
|
|
if ((this.advance(), !Rn(this.peek)))
|
|
return this.error('Invalid character [#]', -1);
|
|
for (; Bn(this.peek); ) this.advance();
|
|
let n = this.input.substring(e, this.index);
|
|
return kr(e, this.index, n);
|
|
}
|
|
scanNumber(e) {
|
|
let n = this.index === e,
|
|
s = !1;
|
|
for (this.advance(); ; ) {
|
|
if (!j(this.peek))
|
|
if (this.peek === $t) {
|
|
if (
|
|
!j(this.input.charCodeAt(this.index - 1)) ||
|
|
!j(this.input.charCodeAt(this.index + 1))
|
|
)
|
|
return this.error('Invalid numeric separator', 0);
|
|
s = !0;
|
|
} else if (this.peek === ee) n = !1;
|
|
else if (Pr(this.peek)) {
|
|
if (
|
|
(this.advance(), Lr(this.peek) && this.advance(), !j(this.peek))
|
|
)
|
|
return this.error('Invalid exponent', -1);
|
|
n = !1;
|
|
} else break;
|
|
this.advance();
|
|
}
|
|
let r = this.input.substring(e, this.index);
|
|
s && (r = r.replace(/_/g, ''));
|
|
let o = n ? $r(r) : parseFloat(r);
|
|
return Nr(e, this.index, o);
|
|
}
|
|
scanString() {
|
|
let e = this.index,
|
|
n = this.peek;
|
|
this.advance();
|
|
let s = '',
|
|
r = this.index,
|
|
o = this.input;
|
|
for (; this.peek != n; )
|
|
if (this.peek == rr) {
|
|
s += o.substring(r, this.index);
|
|
let l;
|
|
if ((this.advance(), this.peek == pr)) {
|
|
let u = o.substring(this.index + 1, this.index + 5);
|
|
if (/^[0-9a-f]+$/i.test(u)) l = parseInt(u, 16);
|
|
else return this.error(`Invalid unicode escape [\\u${u}]`, 0);
|
|
for (let h = 0; h < 5; h++) this.advance();
|
|
} else (l = Mr(this.peek)), this.advance();
|
|
(s += String.fromCharCode(l)), (r = this.index);
|
|
} else {
|
|
if (this.peek == at) return this.error('Unterminated quote', 0);
|
|
this.advance();
|
|
}
|
|
let a = o.substring(r, this.index);
|
|
return this.advance(), br(e, this.index, s + a);
|
|
}
|
|
scanQuestion(e) {
|
|
this.advance();
|
|
let n = '?';
|
|
return (
|
|
(this.peek === hn || this.peek === ee) &&
|
|
((n += this.peek === ee ? '.' : '?'), this.advance()),
|
|
lt(e, this.index, n)
|
|
);
|
|
}
|
|
error(e, n) {
|
|
let s = this.index + n;
|
|
return Ar(
|
|
s,
|
|
this.index,
|
|
`Lexer Error: ${e} at column ${s} in expression [${this.input}]`
|
|
);
|
|
}
|
|
};
|
|
function Rn(t) {
|
|
return (Qn <= t && t <= Kn) || (Jn <= t && t <= Yn) || t == $t || t == jn;
|
|
}
|
|
function Bn(t) {
|
|
return mr(t) || j(t) || t == $t || t == jn;
|
|
}
|
|
function Pr(t) {
|
|
return t == or || t == sr;
|
|
}
|
|
function Lr(t) {
|
|
return t == Xn || t == Gn;
|
|
}
|
|
function Mr(t) {
|
|
switch (t) {
|
|
case lr:
|
|
return js;
|
|
case ar:
|
|
return Gs;
|
|
case cr:
|
|
return Xs;
|
|
case ur:
|
|
return Un;
|
|
case hr:
|
|
return zs;
|
|
default:
|
|
return t;
|
|
}
|
|
}
|
|
function $r(t) {
|
|
let e = parseInt(t);
|
|
if (isNaN(e)) throw new Error('Invalid integer literal when parsing ' + t);
|
|
return e;
|
|
}
|
|
var Pt = class {
|
|
strings;
|
|
expressions;
|
|
offsets;
|
|
constructor(e, n, s) {
|
|
(this.strings = e), (this.expressions = n), (this.offsets = s);
|
|
}
|
|
},
|
|
Lt = class {
|
|
templateBindings;
|
|
warnings;
|
|
errors;
|
|
constructor(e, n, s) {
|
|
(this.templateBindings = e), (this.warnings = n), (this.errors = s);
|
|
}
|
|
},
|
|
ue = class {
|
|
_lexer;
|
|
errors = [];
|
|
constructor(e) {
|
|
this._lexer = e;
|
|
}
|
|
parseAction(e, n, s, r = Z) {
|
|
this._checkNoInterpolation(e, n, r);
|
|
let o = this._stripComments(e),
|
|
a = this._lexer.tokenize(o),
|
|
l = new z(e, n, s, a, 1, this.errors, 0).parseChain();
|
|
return new W(l, e, n, s, this.errors);
|
|
}
|
|
parseBinding(e, n, s, r = Z) {
|
|
let o = this._parseBindingAst(e, n, s, r);
|
|
return new W(o, e, n, s, this.errors);
|
|
}
|
|
checkSimpleExpression(e) {
|
|
let n = new Mt();
|
|
return e.visit(n), n.errors;
|
|
}
|
|
parseSimpleBinding(e, n, s, r = Z) {
|
|
let o = this._parseBindingAst(e, n, s, r),
|
|
a = this.checkSimpleExpression(o);
|
|
return (
|
|
a.length > 0 &&
|
|
this._reportError(
|
|
`Host binding expression cannot contain ${a.join(' ')}`,
|
|
e,
|
|
n
|
|
),
|
|
new W(o, e, n, s, this.errors)
|
|
);
|
|
}
|
|
_reportError(e, n, s, r) {
|
|
this.errors.push(new ye(e, n, s, r));
|
|
}
|
|
_parseBindingAst(e, n, s, r) {
|
|
this._checkNoInterpolation(e, n, r);
|
|
let o = this._stripComments(e),
|
|
a = this._lexer.tokenize(o);
|
|
return new z(e, n, s, a, 0, this.errors, 0).parseChain();
|
|
}
|
|
parseTemplateBindings(e, n, s, r, o) {
|
|
let a = this._lexer.tokenize(n);
|
|
return new z(n, s, o, a, 0, this.errors, 0).parseTemplateBindings({
|
|
source: e,
|
|
span: new O(r, r + e.length),
|
|
});
|
|
}
|
|
parseInterpolation(e, n, s, r, o = Z) {
|
|
let {
|
|
strings: a,
|
|
expressions: l,
|
|
offsets: u,
|
|
} = this.splitInterpolation(e, n, r, o);
|
|
if (l.length === 0) return null;
|
|
let h = [];
|
|
for (let g = 0; g < l.length; ++g) {
|
|
let S = l[g].text,
|
|
w = this._stripComments(S),
|
|
y = this._lexer.tokenize(w),
|
|
T = new z(e, n, s, y, 0, this.errors, u[g]).parseChain();
|
|
h.push(T);
|
|
}
|
|
return this.createInterpolationAst(
|
|
a.map((g) => g.text),
|
|
h,
|
|
e,
|
|
n,
|
|
s
|
|
);
|
|
}
|
|
parseInterpolationExpression(e, n, s) {
|
|
let r = this._stripComments(e),
|
|
o = this._lexer.tokenize(r),
|
|
a = new z(e, n, s, o, 0, this.errors, 0).parseChain(),
|
|
l = ['', ''];
|
|
return this.createInterpolationAst(l, [a], e, n, s);
|
|
}
|
|
createInterpolationAst(e, n, s, r, o) {
|
|
let a = new G(0, s.length),
|
|
l = new Pe(a, a.toAbsolute(o), e, n);
|
|
return new W(l, s, r, o, this.errors);
|
|
}
|
|
splitInterpolation(e, n, s, r = Z) {
|
|
let o = [],
|
|
a = [],
|
|
l = [],
|
|
u = s ? Rr(s) : null,
|
|
h = 0,
|
|
g = !1,
|
|
S = !1,
|
|
{ start: w, end: y } = r;
|
|
for (; h < e.length; )
|
|
if (g) {
|
|
let T = h,
|
|
F = T + w.length,
|
|
fe = this._getInterpolationEndIndex(e, y, F);
|
|
if (fe === -1) {
|
|
(g = !1), (S = !0);
|
|
break;
|
|
}
|
|
let de = fe + y.length,
|
|
q = e.substring(F, fe);
|
|
q.trim().length === 0 &&
|
|
this._reportError(
|
|
'Blank expressions are not allowed in interpolated strings',
|
|
e,
|
|
`at column ${h} in`,
|
|
n
|
|
),
|
|
a.push({ text: q, start: T, end: de });
|
|
let Ms = ((u == null ? void 0 : u.get(T)) ?? T) + w.length;
|
|
l.push(Ms), (h = de), (g = !1);
|
|
} else {
|
|
let T = h;
|
|
(h = e.indexOf(w, h)), h === -1 && (h = e.length);
|
|
let F = e.substring(T, h);
|
|
o.push({ text: F, start: T, end: h }), (g = !0);
|
|
}
|
|
if (!g)
|
|
if (S) {
|
|
let T = o[o.length - 1];
|
|
(T.text += e.substring(h)), (T.end = e.length);
|
|
} else o.push({ text: e.substring(h), start: h, end: e.length });
|
|
return new Pt(o, a, l);
|
|
}
|
|
wrapLiteralPrimitive(e, n, s) {
|
|
let r = new G(0, e == null ? 0 : e.length);
|
|
return new W(new N(r, r.toAbsolute(s), e), e, n, s, this.errors);
|
|
}
|
|
_stripComments(e) {
|
|
let n = this._commentStart(e);
|
|
return n != null ? e.substring(0, n) : e;
|
|
}
|
|
_commentStart(e) {
|
|
let n = null;
|
|
for (let s = 0; s < e.length - 1; s++) {
|
|
let r = e.charCodeAt(s),
|
|
o = e.charCodeAt(s + 1);
|
|
if (r === Tt && o == Tt && n == null) return s;
|
|
n === r ? (n = null) : n == null && dn(r) && (n = r);
|
|
}
|
|
return null;
|
|
}
|
|
_checkNoInterpolation(e, n, { start: s, end: r }) {
|
|
let o = -1,
|
|
a = -1;
|
|
for (let l of this._forEachUnquotedChar(e, 0))
|
|
if (o === -1) e.startsWith(s) && (o = l);
|
|
else if (((a = this._getInterpolationEndIndex(e, r, l)), a > -1))
|
|
break;
|
|
o > -1 &&
|
|
a > -1 &&
|
|
this._reportError(
|
|
`Got interpolation (${s}${r}) where expression was expected`,
|
|
e,
|
|
`at column ${o} in`,
|
|
n
|
|
);
|
|
}
|
|
_getInterpolationEndIndex(e, n, s) {
|
|
for (let r of this._forEachUnquotedChar(e, s)) {
|
|
if (e.startsWith(n, r)) return r;
|
|
if (e.startsWith('//', r)) return e.indexOf(n, r);
|
|
}
|
|
return -1;
|
|
}
|
|
*_forEachUnquotedChar(e, n) {
|
|
let s = null,
|
|
r = 0;
|
|
for (let o = n; o < e.length; o++) {
|
|
let a = e[o];
|
|
dn(e.charCodeAt(o)) && (s === null || s === a) && r % 2 === 0 ?
|
|
(s = s === null ? a : null)
|
|
: s === null && (yield o),
|
|
(r = a === '\\' ? r + 1 : 0);
|
|
}
|
|
}
|
|
},
|
|
ne;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'), (t[(t.Writable = 1)] = 'Writable');
|
|
})(ne || (ne = {}));
|
|
var z = class {
|
|
input;
|
|
location;
|
|
absoluteOffset;
|
|
tokens;
|
|
parseFlags;
|
|
errors;
|
|
offset;
|
|
rparensExpected = 0;
|
|
rbracketsExpected = 0;
|
|
rbracesExpected = 0;
|
|
context = ne.None;
|
|
sourceSpanCache = new Map();
|
|
index = 0;
|
|
constructor(e, n, s, r, o, a, l) {
|
|
(this.input = e),
|
|
(this.location = n),
|
|
(this.absoluteOffset = s),
|
|
(this.tokens = r),
|
|
(this.parseFlags = o),
|
|
(this.errors = a),
|
|
(this.offset = l);
|
|
}
|
|
peek(e) {
|
|
let n = this.index + e;
|
|
return n < this.tokens.length ? this.tokens[n] : ct;
|
|
}
|
|
get next() {
|
|
return this.peek(0);
|
|
}
|
|
get atEOF() {
|
|
return this.index >= this.tokens.length;
|
|
}
|
|
get inputIndex() {
|
|
return this.atEOF ?
|
|
this.currentEndIndex
|
|
: this.next.index + this.offset;
|
|
}
|
|
get currentEndIndex() {
|
|
return (
|
|
this.index > 0 ? this.peek(-1).end + this.offset
|
|
: this.tokens.length === 0 ? this.input.length + this.offset
|
|
: this.next.index + this.offset
|
|
);
|
|
}
|
|
get currentAbsoluteOffset() {
|
|
return this.absoluteOffset + this.inputIndex;
|
|
}
|
|
span(e, n) {
|
|
let s = this.currentEndIndex;
|
|
if ((n !== void 0 && n > this.currentEndIndex && (s = n), e > s)) {
|
|
let r = s;
|
|
(s = e), (e = r);
|
|
}
|
|
return new G(e, s);
|
|
}
|
|
sourceSpan(e, n) {
|
|
let s = `${e}@${this.inputIndex}:${n}`;
|
|
return (
|
|
this.sourceSpanCache.has(s) ||
|
|
this.sourceSpanCache.set(
|
|
s,
|
|
this.span(e, n).toAbsolute(this.absoluteOffset)
|
|
),
|
|
this.sourceSpanCache.get(s)
|
|
);
|
|
}
|
|
advance() {
|
|
this.index++;
|
|
}
|
|
withContext(e, n) {
|
|
this.context |= e;
|
|
let s = n();
|
|
return (this.context ^= e), s;
|
|
}
|
|
consumeOptionalCharacter(e) {
|
|
return this.next.isCharacter(e) ? (this.advance(), !0) : !1;
|
|
}
|
|
peekKeywordLet() {
|
|
return this.next.isKeywordLet();
|
|
}
|
|
peekKeywordAs() {
|
|
return this.next.isKeywordAs();
|
|
}
|
|
expectCharacter(e) {
|
|
this.consumeOptionalCharacter(e) ||
|
|
this.error(`Missing expected ${String.fromCharCode(e)}`);
|
|
}
|
|
consumeOptionalOperator(e) {
|
|
return this.next.isOperator(e) ? (this.advance(), !0) : !1;
|
|
}
|
|
expectOperator(e) {
|
|
this.consumeOptionalOperator(e) ||
|
|
this.error(`Missing expected operator ${e}`);
|
|
}
|
|
prettyPrintToken(e) {
|
|
return e === ct ? 'end of input' : `token ${e}`;
|
|
}
|
|
expectIdentifierOrKeyword() {
|
|
let e = this.next;
|
|
return !e.isIdentifier() && !e.isKeyword() ?
|
|
(e.isPrivateIdentifier() ?
|
|
this._reportErrorForPrivateIdentifier(
|
|
e,
|
|
'expected identifier or keyword'
|
|
)
|
|
: this.error(
|
|
`Unexpected ${this.prettyPrintToken(e)}, expected identifier or keyword`
|
|
),
|
|
null)
|
|
: (this.advance(), e.toString());
|
|
}
|
|
expectIdentifierOrKeywordOrString() {
|
|
let e = this.next;
|
|
return !e.isIdentifier() && !e.isKeyword() && !e.isString() ?
|
|
(e.isPrivateIdentifier() ?
|
|
this._reportErrorForPrivateIdentifier(
|
|
e,
|
|
'expected identifier, keyword or string'
|
|
)
|
|
: this.error(
|
|
`Unexpected ${this.prettyPrintToken(e)}, expected identifier, keyword, or string`
|
|
),
|
|
'')
|
|
: (this.advance(), e.toString());
|
|
}
|
|
parseChain() {
|
|
let e = [],
|
|
n = this.inputIndex;
|
|
for (; this.index < this.tokens.length; ) {
|
|
let s = this.parsePipe();
|
|
if ((e.push(s), this.consumeOptionalCharacter(ve)))
|
|
for (
|
|
this.parseFlags & 1 ||
|
|
this.error(
|
|
'Binding expression cannot contain chained expression'
|
|
);
|
|
this.consumeOptionalCharacter(ve);
|
|
|
|
);
|
|
else if (this.index < this.tokens.length) {
|
|
let r = this.index;
|
|
if (
|
|
(this.error(`Unexpected token '${this.next}'`), this.index === r)
|
|
)
|
|
break;
|
|
}
|
|
}
|
|
if (e.length === 0) {
|
|
let s = this.offset,
|
|
r = this.offset + this.input.length;
|
|
return new b(this.span(s, r), this.sourceSpan(s, r));
|
|
}
|
|
return e.length == 1 ?
|
|
e[0]
|
|
: new _e(this.span(n), this.sourceSpan(n), e);
|
|
}
|
|
parsePipe() {
|
|
let e = this.inputIndex,
|
|
n = this.parseExpression();
|
|
if (this.consumeOptionalOperator('|')) {
|
|
this.parseFlags & 1 &&
|
|
this.error('Cannot have a pipe in an action expression');
|
|
do {
|
|
let s = this.inputIndex,
|
|
r = this.expectIdentifierOrKeyword(),
|
|
o,
|
|
a;
|
|
r !== null ?
|
|
(o = this.sourceSpan(s))
|
|
: ((r = ''),
|
|
(a =
|
|
this.next.index !== -1 ?
|
|
this.next.index
|
|
: this.input.length + this.offset),
|
|
(o = new G(a, a).toAbsolute(this.absoluteOffset)));
|
|
let l = [];
|
|
for (; this.consumeOptionalCharacter(te); )
|
|
l.push(this.parseExpression());
|
|
n = new be(this.span(e), this.sourceSpan(e, a), n, r, l, o);
|
|
} while (this.consumeOptionalOperator('|'));
|
|
}
|
|
return n;
|
|
}
|
|
parseExpression() {
|
|
return this.parseConditional();
|
|
}
|
|
parseConditional() {
|
|
let e = this.inputIndex,
|
|
n = this.parseLogicalOr();
|
|
if (this.consumeOptionalOperator('?')) {
|
|
let s = this.parsePipe(),
|
|
r;
|
|
if (this.consumeOptionalCharacter(te)) r = this.parsePipe();
|
|
else {
|
|
let o = this.inputIndex,
|
|
a = this.input.substring(e, o);
|
|
this.error(
|
|
`Conditional expression ${a} requires all 3 expressions`
|
|
),
|
|
(r = new b(this.span(e), this.sourceSpan(e)));
|
|
}
|
|
return new Ce(this.span(e), this.sourceSpan(e), n, s, r);
|
|
} else return n;
|
|
}
|
|
parseLogicalOr() {
|
|
let e = this.inputIndex,
|
|
n = this.parseLogicalAnd();
|
|
for (; this.consumeOptionalOperator('||'); ) {
|
|
let s = this.parseLogicalAnd();
|
|
n = new A(this.span(e), this.sourceSpan(e), '||', n, s);
|
|
}
|
|
return n;
|
|
}
|
|
parseLogicalAnd() {
|
|
let e = this.inputIndex,
|
|
n = this.parseNullishCoalescing();
|
|
for (; this.consumeOptionalOperator('&&'); ) {
|
|
let s = this.parseNullishCoalescing();
|
|
n = new A(this.span(e), this.sourceSpan(e), '&&', n, s);
|
|
}
|
|
return n;
|
|
}
|
|
parseNullishCoalescing() {
|
|
let e = this.inputIndex,
|
|
n = this.parseEquality();
|
|
for (; this.consumeOptionalOperator('??'); ) {
|
|
let s = this.parseEquality();
|
|
n = new A(this.span(e), this.sourceSpan(e), '??', n, s);
|
|
}
|
|
return n;
|
|
}
|
|
parseEquality() {
|
|
let e = this.inputIndex,
|
|
n = this.parseRelational();
|
|
for (; this.next.type == d.Operator; ) {
|
|
let s = this.next.strValue;
|
|
switch (s) {
|
|
case '==':
|
|
case '===':
|
|
case '!=':
|
|
case '!==':
|
|
this.advance();
|
|
let r = this.parseRelational();
|
|
n = new A(this.span(e), this.sourceSpan(e), s, n, r);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return n;
|
|
}
|
|
parseRelational() {
|
|
let e = this.inputIndex,
|
|
n = this.parseAdditive();
|
|
for (; this.next.type == d.Operator; ) {
|
|
let s = this.next.strValue;
|
|
switch (s) {
|
|
case '<':
|
|
case '>':
|
|
case '<=':
|
|
case '>=':
|
|
this.advance();
|
|
let r = this.parseAdditive();
|
|
n = new A(this.span(e), this.sourceSpan(e), s, n, r);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return n;
|
|
}
|
|
parseAdditive() {
|
|
let e = this.inputIndex,
|
|
n = this.parseMultiplicative();
|
|
for (; this.next.type == d.Operator; ) {
|
|
let s = this.next.strValue;
|
|
switch (s) {
|
|
case '+':
|
|
case '-':
|
|
this.advance();
|
|
let r = this.parseMultiplicative();
|
|
n = new A(this.span(e), this.sourceSpan(e), s, n, r);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return n;
|
|
}
|
|
parseMultiplicative() {
|
|
let e = this.inputIndex,
|
|
n = this.parsePrefix();
|
|
for (; this.next.type == d.Operator; ) {
|
|
let s = this.next.strValue;
|
|
switch (s) {
|
|
case '*':
|
|
case '%':
|
|
case '/':
|
|
this.advance();
|
|
let r = this.parsePrefix();
|
|
n = new A(this.span(e), this.sourceSpan(e), s, n, r);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return n;
|
|
}
|
|
parsePrefix() {
|
|
if (this.next.type == d.Operator) {
|
|
let e = this.inputIndex,
|
|
n = this.next.strValue,
|
|
s;
|
|
switch (n) {
|
|
case '+':
|
|
return (
|
|
this.advance(),
|
|
(s = this.parsePrefix()),
|
|
ae.createPlus(this.span(e), this.sourceSpan(e), s)
|
|
);
|
|
case '-':
|
|
return (
|
|
this.advance(),
|
|
(s = this.parsePrefix()),
|
|
ae.createMinus(this.span(e), this.sourceSpan(e), s)
|
|
);
|
|
case '!':
|
|
return (
|
|
this.advance(),
|
|
(s = this.parsePrefix()),
|
|
new Le(this.span(e), this.sourceSpan(e), s)
|
|
);
|
|
}
|
|
} else if (this.next.isKeywordTypeof()) {
|
|
this.advance();
|
|
let e = this.inputIndex,
|
|
n = this.parsePrefix();
|
|
return new Me(this.span(e), this.sourceSpan(e), n);
|
|
}
|
|
return this.parseCallChain();
|
|
}
|
|
parseCallChain() {
|
|
let e = this.inputIndex,
|
|
n = this.parsePrimary();
|
|
for (;;)
|
|
if (this.consumeOptionalCharacter(ee))
|
|
n = this.parseAccessMember(n, e, !1);
|
|
else if (this.consumeOptionalOperator('?.'))
|
|
this.consumeOptionalCharacter(je) ?
|
|
(n = this.parseCall(n, e, !0))
|
|
: (n =
|
|
this.consumeOptionalCharacter(ze) ?
|
|
this.parseKeyedReadOrWrite(n, e, !0)
|
|
: this.parseAccessMember(n, e, !0));
|
|
else if (this.consumeOptionalCharacter(ze))
|
|
n = this.parseKeyedReadOrWrite(n, e, !1);
|
|
else if (this.consumeOptionalCharacter(je))
|
|
n = this.parseCall(n, e, !1);
|
|
else if (this.consumeOptionalOperator('!'))
|
|
n = new $e(this.span(e), this.sourceSpan(e), n);
|
|
else return n;
|
|
}
|
|
parsePrimary() {
|
|
let e = this.inputIndex;
|
|
if (this.consumeOptionalCharacter(je)) {
|
|
this.rparensExpected++;
|
|
let n = this.parsePipe();
|
|
return this.rparensExpected--, this.expectCharacter(me), n;
|
|
} else {
|
|
if (this.next.isKeywordNull())
|
|
return (
|
|
this.advance(), new N(this.span(e), this.sourceSpan(e), null)
|
|
);
|
|
if (this.next.isKeywordUndefined())
|
|
return (
|
|
this.advance(), new N(this.span(e), this.sourceSpan(e), void 0)
|
|
);
|
|
if (this.next.isKeywordTrue())
|
|
return this.advance(), new N(this.span(e), this.sourceSpan(e), !0);
|
|
if (this.next.isKeywordFalse())
|
|
return this.advance(), new N(this.span(e), this.sourceSpan(e), !1);
|
|
if (this.next.isKeywordThis())
|
|
return this.advance(), new yt(this.span(e), this.sourceSpan(e));
|
|
if (this.consumeOptionalCharacter(ze)) {
|
|
this.rbracketsExpected++;
|
|
let n = this.parseExpressionList(we);
|
|
return (
|
|
this.rbracketsExpected--,
|
|
this.expectCharacter(we),
|
|
new Ne(this.span(e), this.sourceSpan(e), n)
|
|
);
|
|
} else {
|
|
if (this.next.isCharacter(kt)) return this.parseLiteralMap();
|
|
if (this.next.isIdentifier())
|
|
return this.parseAccessMember(
|
|
new X(this.span(e), this.sourceSpan(e)),
|
|
e,
|
|
!1
|
|
);
|
|
if (this.next.isNumber()) {
|
|
let n = this.next.toNumber();
|
|
return this.advance(), new N(this.span(e), this.sourceSpan(e), n);
|
|
} else if (this.next.isString()) {
|
|
let n = this.next.toString();
|
|
return this.advance(), new N(this.span(e), this.sourceSpan(e), n);
|
|
} else
|
|
return (
|
|
this.next.isPrivateIdentifier() ?
|
|
(this._reportErrorForPrivateIdentifier(this.next, null),
|
|
new b(this.span(e), this.sourceSpan(e)))
|
|
: this.index >= this.tokens.length ?
|
|
(this.error(`Unexpected end of expression: ${this.input}`),
|
|
new b(this.span(e), this.sourceSpan(e)))
|
|
: (this.error(`Unexpected token ${this.next}`),
|
|
new b(this.span(e), this.sourceSpan(e)))
|
|
);
|
|
}
|
|
}
|
|
}
|
|
parseExpressionList(e) {
|
|
let n = [];
|
|
do
|
|
if (!this.next.isCharacter(e)) n.push(this.parsePipe());
|
|
else break;
|
|
while (this.consumeOptionalCharacter(ge));
|
|
return n;
|
|
}
|
|
parseLiteralMap() {
|
|
let e = [],
|
|
n = [],
|
|
s = this.inputIndex;
|
|
if ((this.expectCharacter(kt), !this.consumeOptionalCharacter(xe))) {
|
|
this.rbracesExpected++;
|
|
do {
|
|
let r = this.inputIndex,
|
|
o = this.next.isString(),
|
|
a = this.expectIdentifierOrKeywordOrString(),
|
|
l = { key: a, quoted: o };
|
|
if ((e.push(l), o))
|
|
this.expectCharacter(te), n.push(this.parsePipe());
|
|
else if (this.consumeOptionalCharacter(te))
|
|
n.push(this.parsePipe());
|
|
else {
|
|
l.isShorthandInitialized = !0;
|
|
let u = this.span(r),
|
|
h = this.sourceSpan(r);
|
|
n.push(new re(u, h, h, new X(u, h), a));
|
|
}
|
|
} while (
|
|
this.consumeOptionalCharacter(ge) &&
|
|
!this.next.isCharacter(xe)
|
|
);
|
|
this.rbracesExpected--, this.expectCharacter(xe);
|
|
}
|
|
return new Ae(this.span(s), this.sourceSpan(s), e, n);
|
|
}
|
|
parseAccessMember(e, n, s) {
|
|
let r = this.inputIndex,
|
|
o = this.withContext(ne.Writable, () => {
|
|
let u = this.expectIdentifierOrKeyword() ?? '';
|
|
return (
|
|
u.length === 0 &&
|
|
this.error(
|
|
'Expected identifier for property access',
|
|
e.span.end
|
|
),
|
|
u
|
|
);
|
|
}),
|
|
a = this.sourceSpan(r),
|
|
l;
|
|
if (s)
|
|
this.consumeOptionalOperator('=') ?
|
|
(this.error("The '?.' operator cannot be used in the assignment"),
|
|
(l = new b(this.span(n), this.sourceSpan(n))))
|
|
: (l = new ie(this.span(n), this.sourceSpan(n), a, e, o));
|
|
else if (this.consumeOptionalOperator('=')) {
|
|
if (!(this.parseFlags & 1))
|
|
return (
|
|
this.error('Bindings cannot contain assignments'),
|
|
new b(this.span(n), this.sourceSpan(n))
|
|
);
|
|
let u = this.parseConditional();
|
|
l = new Te(this.span(n), this.sourceSpan(n), a, e, o, u);
|
|
} else l = new re(this.span(n), this.sourceSpan(n), a, e, o);
|
|
return l;
|
|
}
|
|
parseCall(e, n, s) {
|
|
let r = this.inputIndex;
|
|
this.rparensExpected++;
|
|
let o = this.parseCallArguments(),
|
|
a = this.span(r, this.inputIndex).toAbsolute(this.absoluteOffset);
|
|
this.expectCharacter(me), this.rparensExpected--;
|
|
let l = this.span(n),
|
|
u = this.sourceSpan(n);
|
|
return s ? new le(l, u, e, o, a) : new Re(l, u, e, o, a);
|
|
}
|
|
parseCallArguments() {
|
|
if (this.next.isCharacter(me)) return [];
|
|
let e = [];
|
|
do e.push(this.parsePipe());
|
|
while (this.consumeOptionalCharacter(ge));
|
|
return e;
|
|
}
|
|
expectTemplateBindingKey() {
|
|
let e = '',
|
|
n = !1,
|
|
s = this.currentAbsoluteOffset;
|
|
do
|
|
(e += this.expectIdentifierOrKeywordOrString()),
|
|
(n = this.consumeOptionalOperator('-')),
|
|
n && (e += '-');
|
|
while (n);
|
|
return { source: e, span: new O(s, s + e.length) };
|
|
}
|
|
parseTemplateBindings(e) {
|
|
let n = [];
|
|
for (
|
|
n.push(...this.parseDirectiveKeywordBindings(e));
|
|
this.index < this.tokens.length;
|
|
|
|
) {
|
|
let s = this.parseLetBinding();
|
|
if (s) n.push(s);
|
|
else {
|
|
let r = this.expectTemplateBindingKey(),
|
|
o = this.parseAsBinding(r);
|
|
o ?
|
|
n.push(o)
|
|
: ((r.source =
|
|
e.source +
|
|
r.source.charAt(0).toUpperCase() +
|
|
r.source.substring(1)),
|
|
n.push(...this.parseDirectiveKeywordBindings(r)));
|
|
}
|
|
this.consumeStatementTerminator();
|
|
}
|
|
return new Lt(n, [], this.errors);
|
|
}
|
|
parseKeyedReadOrWrite(e, n, s) {
|
|
return this.withContext(ne.Writable, () => {
|
|
this.rbracketsExpected++;
|
|
let r = this.parsePipe();
|
|
if (
|
|
(r instanceof b && this.error('Key access cannot be empty'),
|
|
this.rbracketsExpected--,
|
|
this.expectCharacter(we),
|
|
this.consumeOptionalOperator('='))
|
|
)
|
|
if (s)
|
|
this.error("The '?.' operator cannot be used in the assignment");
|
|
else {
|
|
let o = this.parseConditional();
|
|
return new Ie(this.span(n), this.sourceSpan(n), e, r, o);
|
|
}
|
|
else
|
|
return s ?
|
|
new oe(this.span(n), this.sourceSpan(n), e, r)
|
|
: new ke(this.span(n), this.sourceSpan(n), e, r);
|
|
return new b(this.span(n), this.sourceSpan(n));
|
|
});
|
|
}
|
|
parseDirectiveKeywordBindings(e) {
|
|
let n = [];
|
|
this.consumeOptionalCharacter(te);
|
|
let s = this.getDirectiveBoundTarget(),
|
|
r = this.currentAbsoluteOffset,
|
|
o = this.parseAsBinding(e);
|
|
o ||
|
|
(this.consumeStatementTerminator(), (r = this.currentAbsoluteOffset));
|
|
let a = new O(e.span.start, r);
|
|
return n.push(new Be(a, e, s)), o && n.push(o), n;
|
|
}
|
|
getDirectiveBoundTarget() {
|
|
if (this.next === ct || this.peekKeywordAs() || this.peekKeywordLet())
|
|
return null;
|
|
let e = this.parsePipe(),
|
|
{ start: n, end: s } = e.span,
|
|
r = this.input.substring(n, s);
|
|
return new W(e, r, this.location, this.absoluteOffset + n, this.errors);
|
|
}
|
|
parseAsBinding(e) {
|
|
if (!this.peekKeywordAs()) return null;
|
|
this.advance();
|
|
let n = this.expectTemplateBindingKey();
|
|
this.consumeStatementTerminator();
|
|
let s = new O(e.span.start, this.currentAbsoluteOffset);
|
|
return new ce(s, n, e);
|
|
}
|
|
parseLetBinding() {
|
|
if (!this.peekKeywordLet()) return null;
|
|
let e = this.currentAbsoluteOffset;
|
|
this.advance();
|
|
let n = this.expectTemplateBindingKey(),
|
|
s = null;
|
|
this.consumeOptionalOperator('=') &&
|
|
(s = this.expectTemplateBindingKey()),
|
|
this.consumeStatementTerminator();
|
|
let r = new O(e, this.currentAbsoluteOffset);
|
|
return new ce(r, n, s);
|
|
}
|
|
consumeStatementTerminator() {
|
|
this.consumeOptionalCharacter(ve) || this.consumeOptionalCharacter(ge);
|
|
}
|
|
error(e, n = null) {
|
|
this.errors.push(
|
|
new ye(e, this.input, this.locationText(n), this.location)
|
|
),
|
|
this.skip();
|
|
}
|
|
locationText(e = null) {
|
|
return (
|
|
e == null && (e = this.index),
|
|
e < this.tokens.length ?
|
|
`at column ${this.tokens[e].index + 1} in`
|
|
: 'at the end of the expression'
|
|
);
|
|
}
|
|
_reportErrorForPrivateIdentifier(e, n) {
|
|
let s = `Private identifiers are not supported. Unexpected private identifier: ${e}`;
|
|
n !== null && (s += `, ${n}`), this.error(s);
|
|
}
|
|
skip() {
|
|
let e = this.next;
|
|
for (
|
|
;
|
|
this.index < this.tokens.length &&
|
|
!e.isCharacter(ve) &&
|
|
!e.isOperator('|') &&
|
|
(this.rparensExpected <= 0 || !e.isCharacter(me)) &&
|
|
(this.rbracesExpected <= 0 || !e.isCharacter(xe)) &&
|
|
(this.rbracketsExpected <= 0 || !e.isCharacter(we)) &&
|
|
(!(this.context & ne.Writable) || !e.isOperator('='));
|
|
|
|
)
|
|
this.next.isError() &&
|
|
this.errors.push(
|
|
new ye(
|
|
this.next.toString(),
|
|
this.input,
|
|
this.locationText(),
|
|
this.location
|
|
)
|
|
),
|
|
this.advance(),
|
|
(e = this.next);
|
|
}
|
|
},
|
|
Mt = class extends _t {
|
|
errors = [];
|
|
visitPipe() {
|
|
this.errors.push('pipes');
|
|
}
|
|
};
|
|
function Rr(t) {
|
|
let e = new Map(),
|
|
n = 0,
|
|
s = 0,
|
|
r = 0;
|
|
for (; r < t.length; ) {
|
|
let o = t[r];
|
|
if (o.type === 9) {
|
|
let [a, l] = o.parts;
|
|
(n += l.length), (s += a.length);
|
|
} else {
|
|
let a = o.parts.reduce((l, u) => l + u.length, 0);
|
|
(s += a), (n += a);
|
|
}
|
|
e.set(s, n), r++;
|
|
}
|
|
return e;
|
|
}
|
|
var Br = new Map(
|
|
Object.entries({
|
|
class: 'className',
|
|
for: 'htmlFor',
|
|
formaction: 'formAction',
|
|
innerHtml: 'innerHTML',
|
|
readonly: 'readOnly',
|
|
tabindex: 'tabIndex',
|
|
})
|
|
),
|
|
xi = Array.from(Br).reduce((t, [e, n]) => (t.set(e, n), t), new Map());
|
|
var Si = new ue(new De());
|
|
function D(t) {
|
|
return (e) => e.kind === t;
|
|
}
|
|
function Se(t, e) {
|
|
return (n) => n.kind === t && e === n.expression instanceof Ze;
|
|
}
|
|
function Dr(t) {
|
|
return (
|
|
(t.kind === f.Property || t.kind === f.TwoWayProperty) &&
|
|
!(t.expression instanceof Ze)
|
|
);
|
|
}
|
|
var Ei = [
|
|
{ test: D(f.StyleMap), transform: et },
|
|
{ test: D(f.ClassMap), transform: et },
|
|
{ test: D(f.StyleProp) },
|
|
{ test: D(f.ClassProp) },
|
|
{ test: Se(f.Attribute, !0) },
|
|
{ test: Se(f.Property, !0) },
|
|
{ test: Dr },
|
|
{ test: Se(f.Attribute, !1) },
|
|
],
|
|
yi = [
|
|
{ test: Se(f.HostProperty, !0) },
|
|
{ test: Se(f.HostProperty, !1) },
|
|
{ test: D(f.Attribute) },
|
|
{ test: D(f.StyleMap), transform: et },
|
|
{ test: D(f.ClassMap), transform: et },
|
|
{ test: D(f.StyleProp) },
|
|
{ test: D(f.ClassProp) },
|
|
],
|
|
_i = new Set([
|
|
f.Listener,
|
|
f.TwoWayListener,
|
|
f.StyleMap,
|
|
f.ClassMap,
|
|
f.StyleProp,
|
|
f.ClassProp,
|
|
f.Property,
|
|
f.TwoWayProperty,
|
|
f.HostProperty,
|
|
f.Attribute,
|
|
]);
|
|
function et(t) {
|
|
return t.slice(t.length - 1);
|
|
}
|
|
var Ci = new Map([
|
|
['window', P.resolveWindow],
|
|
['document', P.resolveDocument],
|
|
['body', P.resolveBody],
|
|
]);
|
|
var Ti = new Map([
|
|
[B.HTML, P.sanitizeHtml],
|
|
[B.RESOURCE_URL, P.sanitizeResourceUrl],
|
|
[B.SCRIPT, P.sanitizeScript],
|
|
[B.STYLE, P.sanitizeStyle],
|
|
[B.URL, P.sanitizeUrl],
|
|
]),
|
|
ki = new Map([
|
|
[B.HTML, P.trustConstantHtml],
|
|
[B.RESOURCE_URL, P.trustConstantResourceUrl],
|
|
]);
|
|
var Dn;
|
|
(function (t) {
|
|
(t[(t.None = 0)] = 'None'),
|
|
(t[(t.ViewContextRead = 1)] = 'ViewContextRead'),
|
|
(t[(t.ViewContextWrite = 2)] = 'ViewContextWrite'),
|
|
(t[(t.SideEffectful = 4)] = 'SideEffectful');
|
|
})(Dn || (Dn = {}));
|
|
var Ii = new Map([
|
|
[H.Property, U.Property],
|
|
[H.TwoWay, U.TwoWayProperty],
|
|
[H.Attribute, U.Attribute],
|
|
[H.Class, U.ClassName],
|
|
[H.Style, U.StyleProperty],
|
|
[H.Animation, U.Animation],
|
|
]);
|
|
var bi = Symbol('queryAdvancePlaceholder');
|
|
var On;
|
|
(function (t) {
|
|
(t[(t.NG_CONTENT = 0)] = 'NG_CONTENT'),
|
|
(t[(t.STYLE = 1)] = 'STYLE'),
|
|
(t[(t.STYLESHEET = 2)] = 'STYLESHEET'),
|
|
(t[(t.SCRIPT = 3)] = 'SCRIPT'),
|
|
(t[(t.OTHER = 4)] = 'OTHER');
|
|
})(On || (On = {}));
|
|
var Fn;
|
|
(function (t) {
|
|
(t.IDLE = 'idle'),
|
|
(t.TIMER = 'timer'),
|
|
(t.INTERACTION = 'interaction'),
|
|
(t.IMMEDIATE = 'immediate'),
|
|
(t.HOVER = 'hover'),
|
|
(t.VIEWPORT = 'viewport'),
|
|
(t.NEVER = 'never');
|
|
})(Fn || (Fn = {}));
|
|
var is = '%COMP%',
|
|
Ni = `_nghost-${is}`,
|
|
Ai = `_ngcontent-${is}`;
|
|
var Pi = new Et('19.1.2');
|
|
var Vn;
|
|
(function (t) {
|
|
(t[(t.Extract = 0)] = 'Extract'), (t[(t.Merge = 1)] = 'Merge');
|
|
})(Vn || (Vn = {}));
|
|
var Hn;
|
|
(function (t) {
|
|
(t[(t.Directive = 0)] = 'Directive'),
|
|
(t[(t.Component = 1)] = 'Component'),
|
|
(t[(t.Injectable = 2)] = 'Injectable'),
|
|
(t[(t.Pipe = 3)] = 'Pipe'),
|
|
(t[(t.NgModule = 4)] = 'NgModule');
|
|
})(Hn || (Hn = {}));
|
|
function os({ start: t, end: e }, n) {
|
|
let s = t,
|
|
r = e;
|
|
for (; r !== s && /\s/.test(n[r - 1]); ) r--;
|
|
for (; s !== r && /\s/.test(n[s]); ) s++;
|
|
return { start: s, end: r };
|
|
}
|
|
function Fr({ start: t, end: e }, n) {
|
|
let s = t,
|
|
r = e;
|
|
for (; r !== n.length && /\s/.test(n[r]); ) r++;
|
|
for (; s !== 0 && /\s/.test(n[s - 1]); ) s--;
|
|
return { start: s, end: r };
|
|
}
|
|
function Vr(t, e) {
|
|
return e[t.start - 1] === '(' && e[t.end] === ')' ?
|
|
{ start: t.start - 1, end: t.end + 1 }
|
|
: t;
|
|
}
|
|
function as(t, e, n) {
|
|
let s = 0,
|
|
r = { start: t.start, end: t.end };
|
|
for (;;) {
|
|
let o = Fr(r, e),
|
|
a = Vr(o, e);
|
|
if (o.start === a.start && o.end === a.end) break;
|
|
(r.start = a.start), (r.end = a.end), s++;
|
|
}
|
|
return {
|
|
hasParens: (n ? s - 1 : s) !== 0,
|
|
outerSpan: os(n ? { start: r.start + 1, end: r.end - 1 } : r, e),
|
|
innerSpan: os(t, e),
|
|
};
|
|
}
|
|
function ls(t) {
|
|
return typeof t == 'string' ? (e) => e === t : (e) => t.test(e);
|
|
}
|
|
function cs(t, e, n) {
|
|
let s = ls(e);
|
|
for (let r = n; r >= 0; r--) {
|
|
let o = t[r];
|
|
if (s(o)) return r;
|
|
}
|
|
throw new Error(
|
|
`Cannot find front char ${e} from index ${n} in ${JSON.stringify(t)}`
|
|
);
|
|
}
|
|
function us(t, e, n) {
|
|
let s = ls(e);
|
|
for (let r = n; r < t.length; r++) {
|
|
let o = t[r];
|
|
if (s(o)) return r;
|
|
}
|
|
throw new Error(
|
|
`Cannot find character ${e} from index ${n} in ${JSON.stringify(t)}`
|
|
);
|
|
}
|
|
function ps(t) {
|
|
return t.slice(0, 1).toLowerCase() + t.slice(1);
|
|
}
|
|
function Fe(t) {
|
|
let { start: e, end: n } = t;
|
|
return { start: e, end: n, range: [e, n] };
|
|
}
|
|
var Hr = (t) => ue.prototype._commentStart(t);
|
|
function Ur(t, e) {
|
|
let n = e ? Hr(t) : null;
|
|
if (n === null) return { text: t, comments: [] };
|
|
let s = {
|
|
type: 'CommentLine',
|
|
value: t.slice(n + 2),
|
|
...Fe({ start: n, end: t.length }),
|
|
};
|
|
return { text: t.slice(0, n), comments: [s] };
|
|
}
|
|
function Ve(t, e = !0) {
|
|
return (n) => {
|
|
let s = new De(),
|
|
r = new ue(s),
|
|
{ text: o, comments: a } = Ur(n, e),
|
|
l = t(o, r);
|
|
if (l.errors.length !== 0) {
|
|
let [{ message: u }] = l.errors;
|
|
throw new SyntaxError(
|
|
u.replace(/^Parser Error: | at column \d+ in [^]*$/g, '')
|
|
);
|
|
}
|
|
return { result: l, comments: a, text: o };
|
|
};
|
|
}
|
|
var hs = Ve((t, e) => e.parseBinding(t, '', 0)),
|
|
Wr = Ve((t, e) => e.parseSimpleBinding(t, '', 0)),
|
|
fs = Ve((t, e) => e.parseAction(t, '', 0)),
|
|
ds = Ve((t, e) => e.parseInterpolationExpression(t, '', 0)),
|
|
ms = Ve((t, e) => e.parseTemplateBindings('', t, '', 0, 0), !1);
|
|
var jr = (t, e, n) => {
|
|
if (!(t && e == null))
|
|
return Array.isArray(e) || typeof e == 'string' ?
|
|
e[n < 0 ? e.length + n : n]
|
|
: e.at(n);
|
|
},
|
|
nt = jr;
|
|
var Dt = class {
|
|
text;
|
|
constructor(e) {
|
|
this.text = e;
|
|
}
|
|
getCharacterIndex(e, n) {
|
|
return us(this.text, e, n);
|
|
}
|
|
getCharacterLastIndex(e, n) {
|
|
return cs(this.text, e, n);
|
|
}
|
|
transformSpan(e, { stripSpaces: n = !1, hasParentParens: s = !1 } = {}) {
|
|
if (!n) return Fe(e);
|
|
let { outerSpan: r, innerSpan: o, hasParens: a } = as(e, this.text, s),
|
|
l = Fe(o);
|
|
return (
|
|
a &&
|
|
(l.extra = {
|
|
parenthesized: !0,
|
|
parenStart: r.start,
|
|
parenEnd: r.end,
|
|
}),
|
|
l
|
|
);
|
|
}
|
|
createNode(e, { stripSpaces: n = !0, hasParentParens: s = !1 } = {}) {
|
|
let { type: r, start: o, end: a } = e,
|
|
l = {
|
|
...e,
|
|
...this.transformSpan(
|
|
{ start: o, end: a },
|
|
{ stripSpaces: n, hasParentParens: s }
|
|
),
|
|
};
|
|
switch (r) {
|
|
case 'NumericLiteral':
|
|
case 'StringLiteral': {
|
|
let u = this.text.slice(l.start, l.end),
|
|
{ value: h } = l;
|
|
l.extra = { ...l.extra, raw: u, rawValue: h };
|
|
break;
|
|
}
|
|
case 'ObjectProperty': {
|
|
let { shorthand: u } = l;
|
|
u && (l.extra = { ...l.extra, shorthand: u });
|
|
break;
|
|
}
|
|
}
|
|
return l;
|
|
}
|
|
},
|
|
gs = Dt;
|
|
function Ft(t) {
|
|
var e;
|
|
return !!((e = t.extra) != null && e.parenthesized);
|
|
}
|
|
function $(t) {
|
|
return Ft(t) ? t.extra.parenStart : t.start;
|
|
}
|
|
function R(t) {
|
|
return Ft(t) ? t.extra.parenEnd : t.end;
|
|
}
|
|
function vs(t) {
|
|
return (
|
|
(t.type === 'OptionalCallExpression' ||
|
|
t.type === 'OptionalMemberExpression') &&
|
|
!Ft(t)
|
|
);
|
|
}
|
|
function ws(t, e) {
|
|
let { start: n, end: s } = t.sourceSpan;
|
|
return n >= s || /^\s+$/.test(e.slice(n, s));
|
|
}
|
|
var We,
|
|
pe,
|
|
p,
|
|
v,
|
|
He,
|
|
x,
|
|
Ot,
|
|
Ue = class extends gs {
|
|
constructor(n, s) {
|
|
super(s);
|
|
V(this, p);
|
|
V(this, We);
|
|
V(this, pe);
|
|
K(this, We, n), K(this, pe, s);
|
|
}
|
|
get node() {
|
|
return c(this, p, x).call(this, L(this, We));
|
|
}
|
|
transformNode(n) {
|
|
return c(this, p, Ot).call(this, n);
|
|
}
|
|
};
|
|
(We = new WeakMap()),
|
|
(pe = new WeakMap()),
|
|
(p = new WeakSet()),
|
|
(v = function (n, { stripSpaces: s = !0, hasParentParens: r = !1 } = {}) {
|
|
return this.createNode(n, { stripSpaces: s, hasParentParens: r });
|
|
}),
|
|
(He = function (
|
|
n,
|
|
s,
|
|
{ computed: r, optional: o, end: a = R(s), hasParentParens: l = !1 }
|
|
) {
|
|
if (ws(n, L(this, pe)) || n.sourceSpan.start === s.start) return s;
|
|
let u = c(this, p, x).call(this, n),
|
|
h = vs(u);
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: o || h ? 'OptionalMemberExpression' : 'MemberExpression',
|
|
object: u,
|
|
property: s,
|
|
computed: r,
|
|
...(o ? { optional: !0 }
|
|
: h ? { optional: !1 }
|
|
: void 0),
|
|
start: $(u),
|
|
end: a,
|
|
},
|
|
{ hasParentParens: l }
|
|
);
|
|
}),
|
|
(x = function (n, s = !1) {
|
|
return c(this, p, Ot).call(this, n, s);
|
|
}),
|
|
(Ot = function (n, s = !1) {
|
|
if (n instanceof Pe) {
|
|
let { expressions: o } = n;
|
|
if (o.length !== 1) throw new Error("Unexpected 'Interpolation'");
|
|
return c(this, p, x).call(this, o[0]);
|
|
}
|
|
if (n instanceof ae)
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'UnaryExpression',
|
|
prefix: !0,
|
|
argument: c(this, p, x).call(this, n.expr),
|
|
operator: n.operator,
|
|
...n.sourceSpan,
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
if (n instanceof A) {
|
|
let { left: o, operation: a, right: l } = n,
|
|
u = c(this, p, x).call(this, o),
|
|
h = c(this, p, x).call(this, l),
|
|
g = $(u),
|
|
S = R(h),
|
|
w = { left: u, right: h, start: g, end: S };
|
|
return a === '&&' || a === '||' || a === '??' ?
|
|
c(this, p, v).call(
|
|
this,
|
|
{ ...w, type: 'LogicalExpression', operator: a },
|
|
{ hasParentParens: s }
|
|
)
|
|
: c(this, p, v).call(
|
|
this,
|
|
{ ...w, type: 'BinaryExpression', operator: a },
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
if (n instanceof be) {
|
|
let { exp: o, name: a, args: l } = n,
|
|
u = c(this, p, x).call(this, o),
|
|
h = $(u),
|
|
g = R(u),
|
|
S = this.getCharacterIndex(/\S/, this.getCharacterIndex('|', g) + 1),
|
|
w = c(this, p, v).call(this, {
|
|
type: 'Identifier',
|
|
name: a,
|
|
start: S,
|
|
end: S + a.length,
|
|
}),
|
|
y = l.map((T) => c(this, p, x).call(this, T));
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'NGPipeExpression',
|
|
left: u,
|
|
right: w,
|
|
arguments: y,
|
|
start: h,
|
|
end: R(y.length === 0 ? w : nt(!1, y, -1)),
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
if (n instanceof _e)
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'NGChainedExpression',
|
|
expressions: n.expressions.map((o) => c(this, p, x).call(this, o)),
|
|
...n.sourceSpan,
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
if (n instanceof Ce) {
|
|
let { condition: o, trueExp: a, falseExp: l } = n,
|
|
u = c(this, p, x).call(this, o),
|
|
h = c(this, p, x).call(this, a),
|
|
g = c(this, p, x).call(this, l);
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'ConditionalExpression',
|
|
test: u,
|
|
consequent: h,
|
|
alternate: g,
|
|
start: $(u),
|
|
end: R(g),
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
if (n instanceof b)
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'NGEmptyExpression', ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
if (n instanceof X)
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'ThisExpression', ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
if (n instanceof ke || n instanceof oe)
|
|
return c(this, p, He).call(
|
|
this,
|
|
n.receiver,
|
|
c(this, p, x).call(this, n.key),
|
|
{
|
|
computed: !0,
|
|
optional: n instanceof oe,
|
|
end: n.sourceSpan.end,
|
|
hasParentParens: s,
|
|
}
|
|
);
|
|
if (n instanceof Ne)
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'ArrayExpression',
|
|
elements: n.expressions.map((o) => c(this, p, x).call(this, o)),
|
|
...n.sourceSpan,
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
if (n instanceof Ae) {
|
|
let { keys: o, values: a } = n,
|
|
l = a.map((h) => c(this, p, x).call(this, h)),
|
|
u = o.map(({ key: h, quoted: g }, S) => {
|
|
let w = l[S],
|
|
y = $(w),
|
|
T = R(w),
|
|
F = this.getCharacterIndex(
|
|
/\S/,
|
|
S === 0 ?
|
|
n.sourceSpan.start + 1
|
|
: this.getCharacterIndex(',', R(l[S - 1])) + 1
|
|
),
|
|
fe =
|
|
y === F ? T : (
|
|
this.getCharacterLastIndex(
|
|
/\S/,
|
|
this.getCharacterLastIndex(':', y - 1) - 1
|
|
) + 1
|
|
),
|
|
de = { start: F, end: fe },
|
|
q =
|
|
g ?
|
|
c(this, p, v).call(this, {
|
|
type: 'StringLiteral',
|
|
value: h,
|
|
...de,
|
|
})
|
|
: c(this, p, v).call(this, {
|
|
type: 'Identifier',
|
|
name: h,
|
|
...de,
|
|
}),
|
|
Gt = q.end < q.start || F === y;
|
|
return c(this, p, v).call(this, {
|
|
type: 'ObjectProperty',
|
|
key: q,
|
|
value: w,
|
|
shorthand: Gt,
|
|
computed: !1,
|
|
start: $(q),
|
|
end: T,
|
|
});
|
|
});
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'ObjectExpression', properties: u, ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
if (n instanceof N) {
|
|
let { value: o } = n;
|
|
switch (typeof o) {
|
|
case 'boolean':
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'BooleanLiteral', value: o, ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
case 'number':
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'NumericLiteral', value: o, ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
case 'object':
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'NullLiteral', ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
case 'string':
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'StringLiteral', value: o, ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
case 'undefined':
|
|
return c(this, p, v).call(
|
|
this,
|
|
{ type: 'Identifier', name: 'undefined', ...n.sourceSpan },
|
|
{ hasParentParens: s }
|
|
);
|
|
default:
|
|
throw new Error(
|
|
`Unexpected LiteralPrimitive value type ${typeof o}`
|
|
);
|
|
}
|
|
}
|
|
if (n instanceof Re || n instanceof le) {
|
|
let o = n instanceof le,
|
|
{ receiver: a, args: l } = n,
|
|
u =
|
|
l.length === 1 ?
|
|
[c(this, p, x).call(this, l[0], !0)]
|
|
: l.map((w) => c(this, p, x).call(this, w)),
|
|
h = c(this, p, x).call(this, a),
|
|
g = vs(h),
|
|
S = o || g ? 'OptionalCallExpression' : 'CallExpression';
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: S,
|
|
callee: h,
|
|
arguments: u,
|
|
optional: S === 'OptionalCallExpression' ? o : void 0,
|
|
start: $(h),
|
|
end: n.sourceSpan.end,
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
if (n instanceof $e) {
|
|
let o = c(this, p, x).call(this, n.expression);
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'TSNonNullExpression',
|
|
expression: o,
|
|
start: $(o),
|
|
end: n.sourceSpan.end,
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
let r = n instanceof Le;
|
|
if (r || n instanceof Me) {
|
|
let o = c(this, p, x).call(this, n.expression),
|
|
a = r ? '!' : 'typeof',
|
|
{ start: l } = n.sourceSpan;
|
|
if (!r) {
|
|
let u = this.text.lastIndexOf(a, l);
|
|
if (u === -1)
|
|
throw new Error(
|
|
`Cannot find operator ${a} from index ${l} in ${JSON.stringify(this.text)}`
|
|
);
|
|
l = u;
|
|
}
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'UnaryExpression',
|
|
prefix: !0,
|
|
operator: a,
|
|
argument: o,
|
|
start: l,
|
|
end: R(o),
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
if (n instanceof re || n instanceof ie) {
|
|
let { receiver: o, name: a } = n,
|
|
l = this.getCharacterLastIndex(/\S/, n.sourceSpan.end - 1) + 1,
|
|
u = c(this, p, v).call(
|
|
this,
|
|
{ type: 'Identifier', name: a, start: l - a.length, end: l },
|
|
ws(o, L(this, pe)) ? { hasParentParens: s } : {}
|
|
);
|
|
return c(this, p, He).call(this, o, u, {
|
|
computed: !1,
|
|
optional: n instanceof ie,
|
|
hasParentParens: s,
|
|
});
|
|
}
|
|
if (n instanceof Ie) {
|
|
let o = c(this, p, x).call(this, n.key),
|
|
a = c(this, p, x).call(this, n.value),
|
|
l = c(this, p, He).call(this, n.receiver, o, {
|
|
computed: !0,
|
|
optional: !1,
|
|
end: this.getCharacterIndex(']', R(o)) + 1,
|
|
});
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'AssignmentExpression',
|
|
left: l,
|
|
operator: '=',
|
|
right: a,
|
|
start: $(l),
|
|
end: R(a),
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
if (n instanceof Te) {
|
|
let { receiver: o, name: a, value: l } = n,
|
|
u = c(this, p, x).call(this, l),
|
|
h =
|
|
this.getCharacterLastIndex(
|
|
/\S/,
|
|
this.getCharacterLastIndex('=', $(u) - 1) - 1
|
|
) + 1,
|
|
g = c(this, p, v).call(this, {
|
|
type: 'Identifier',
|
|
name: a,
|
|
start: h - a.length,
|
|
end: h,
|
|
}),
|
|
S = c(this, p, He).call(this, o, g, { computed: !1, optional: !1 });
|
|
return c(this, p, v).call(
|
|
this,
|
|
{
|
|
type: 'AssignmentExpression',
|
|
left: S,
|
|
operator: '=',
|
|
right: u,
|
|
start: $(S),
|
|
end: R(u),
|
|
},
|
|
{ hasParentParens: s }
|
|
);
|
|
}
|
|
throw Object.assign(new Error('Unexpected node'), { node: n });
|
|
});
|
|
function xs(t, e) {
|
|
return new Ue(t, e).node;
|
|
}
|
|
function Ss(t) {
|
|
return t instanceof Be;
|
|
}
|
|
function Es(t) {
|
|
return t instanceof ce;
|
|
}
|
|
var he,
|
|
Q,
|
|
m,
|
|
ys,
|
|
I,
|
|
Ht,
|
|
Ut,
|
|
Wt,
|
|
_s,
|
|
Cs,
|
|
Ts,
|
|
ks,
|
|
Vt = class extends Ue {
|
|
constructor(n, s) {
|
|
super(void 0, s);
|
|
V(this, m);
|
|
V(this, he);
|
|
V(this, Q);
|
|
K(this, he, n), K(this, Q, s);
|
|
for (let r of n) c(this, m, _s).call(this, r);
|
|
}
|
|
get expressions() {
|
|
return c(this, m, Ts).call(this);
|
|
}
|
|
};
|
|
(he = new WeakMap()),
|
|
(Q = new WeakMap()),
|
|
(m = new WeakSet()),
|
|
(ys = function () {
|
|
return L(this, he)[0].key;
|
|
}),
|
|
(I = function (n, { stripSpaces: s = !0 } = {}) {
|
|
return this.createNode(n, { stripSpaces: s });
|
|
}),
|
|
(Ht = function (n) {
|
|
return this.transformNode(n);
|
|
}),
|
|
(Ut = function (n) {
|
|
return ps(n.slice(L(this, m, ys).source.length));
|
|
}),
|
|
(Wt = function (n) {
|
|
let s = L(this, Q);
|
|
if (s[n.start] !== '"' && s[n.start] !== "'") return;
|
|
let r = s[n.start],
|
|
o = !1;
|
|
for (let a = n.start + 1; a < s.length; a++)
|
|
switch (s[a]) {
|
|
case r:
|
|
if (!o) {
|
|
n.end = a + 1;
|
|
return;
|
|
}
|
|
default:
|
|
o = !1;
|
|
break;
|
|
case '\\':
|
|
o = !o;
|
|
break;
|
|
}
|
|
}),
|
|
(_s = function (n) {
|
|
c(this, m, Wt).call(this, n.key.span),
|
|
Es(n) && n.value && c(this, m, Wt).call(this, n.value.span);
|
|
}),
|
|
(Cs = function (n) {
|
|
if (!n.value || n.value.source) return n.value;
|
|
let s = this.getCharacterIndex(/\S/, n.sourceSpan.start);
|
|
return { source: '$implicit', span: { start: s, end: s } };
|
|
}),
|
|
(Ts = function () {
|
|
let n = L(this, he),
|
|
[s] = n,
|
|
r =
|
|
(
|
|
L(this, Q).slice(s.sourceSpan.start, s.sourceSpan.end).trim()
|
|
.length === 0
|
|
) ?
|
|
n.slice(1)
|
|
: n,
|
|
o = [],
|
|
a = null;
|
|
for (let [l, u] of r.entries()) {
|
|
if (a && Ss(a) && Es(u) && u.value && u.value.source === a.key.source) {
|
|
let h = c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKey',
|
|
name: u.key.source,
|
|
...u.key.span,
|
|
}),
|
|
g = (y, T) => ({
|
|
...y,
|
|
...this.transformSpan({ start: y.start, end: T }),
|
|
}),
|
|
S = (y) => ({ ...g(y, h.end), alias: h }),
|
|
w = o.pop();
|
|
if (w.type === 'NGMicrosyntaxExpression') o.push(S(w));
|
|
else if (w.type === 'NGMicrosyntaxKeyedExpression') {
|
|
let y = S(w.expression);
|
|
o.push(g({ ...w, expression: y }, y.end));
|
|
} else throw new Error(`Unexpected type ${w.type}`);
|
|
} else o.push(c(this, m, ks).call(this, u, l));
|
|
a = u;
|
|
}
|
|
return c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntax',
|
|
body: o,
|
|
...(o.length === 0 ?
|
|
n[0].sourceSpan
|
|
: { start: o[0].start, end: nt(!1, o, -1).end }),
|
|
});
|
|
}),
|
|
(ks = function (n, s) {
|
|
if (Ss(n)) {
|
|
let { key: r, value: o } = n;
|
|
return (
|
|
o ?
|
|
s === 0 ?
|
|
c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxExpression',
|
|
expression: c(this, m, Ht).call(this, o.ast),
|
|
alias: null,
|
|
...o.sourceSpan,
|
|
})
|
|
: c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKeyedExpression',
|
|
key: c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKey',
|
|
name: c(this, m, Ut).call(this, r.source),
|
|
...r.span,
|
|
}),
|
|
expression: c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxExpression',
|
|
expression: c(this, m, Ht).call(this, o.ast),
|
|
alias: null,
|
|
...o.sourceSpan,
|
|
}),
|
|
start: r.span.start,
|
|
end: o.sourceSpan.end,
|
|
})
|
|
: c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKey',
|
|
name: c(this, m, Ut).call(this, r.source),
|
|
...r.span,
|
|
})
|
|
);
|
|
} else {
|
|
let { key: r, sourceSpan: o } = n;
|
|
if (/^let\s$/.test(L(this, Q).slice(o.start, o.start + 4))) {
|
|
let { value: l } = n;
|
|
return c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxLet',
|
|
key: c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKey',
|
|
name: r.source,
|
|
...r.span,
|
|
}),
|
|
value:
|
|
l ?
|
|
c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKey',
|
|
name: l.source,
|
|
...l.span,
|
|
})
|
|
: null,
|
|
start: o.start,
|
|
end: l ? l.span.end : r.span.end,
|
|
});
|
|
} else {
|
|
let l = c(this, m, Cs).call(this, n);
|
|
return c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxAs',
|
|
key: c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKey',
|
|
name: l.source,
|
|
...l.span,
|
|
}),
|
|
alias: c(this, m, I).call(this, {
|
|
type: 'NGMicrosyntaxKey',
|
|
name: r.source,
|
|
...r.span,
|
|
}),
|
|
start: l.span.start,
|
|
end: r.span.end,
|
|
});
|
|
}
|
|
}
|
|
});
|
|
function Is(t, e) {
|
|
return new Vt(t, e).expressions;
|
|
}
|
|
function st({ result: { ast: t }, text: e, comments: n }) {
|
|
return Object.assign(xs(t, e), { comments: n });
|
|
}
|
|
function bs({ result: { templateBindings: t }, text: e }) {
|
|
return Is(t, e);
|
|
}
|
|
var Ns = (t) => st(hs(t));
|
|
var As = (t) => st(ds(t)),
|
|
qt = (t) => st(fs(t)),
|
|
Ps = (t) => bs(ms(t));
|
|
function jt(t) {
|
|
var s, r, o;
|
|
let e = ((s = t.range) == null ? void 0 : s[0]) ?? t.start,
|
|
n =
|
|
(
|
|
(o =
|
|
((r = t.declaration) == null ? void 0 : r.decorators) ??
|
|
t.decorators) == null
|
|
) ?
|
|
void 0
|
|
: o[0];
|
|
return n ? Math.min(jt(n), e) : e;
|
|
}
|
|
function Ls(t) {
|
|
var e;
|
|
return ((e = t.range) == null ? void 0 : e[1]) ?? t.end;
|
|
}
|
|
function rt(t) {
|
|
return {
|
|
astFormat: 'estree',
|
|
parse(e) {
|
|
let n = t(e);
|
|
return {
|
|
type: 'NGRoot',
|
|
node:
|
|
t === qt && n.type !== 'NGChainedExpression' ?
|
|
{ ...n, type: 'NGChainedExpression', expressions: [n] }
|
|
: n,
|
|
};
|
|
},
|
|
locStart: jt,
|
|
locEnd: Ls,
|
|
};
|
|
}
|
|
var zr = rt(qt),
|
|
Gr = rt(Ns),
|
|
Xr = rt(As),
|
|
Jr = rt(Ps);
|
|
return Os(Yr);
|
|
});
|