var Ws = Object.defineProperty;
var Or = (e) => {
throw TypeError(e);
};
var Fe = (e, t) => {
for (var r in t) Ws(e, r, { get: t[r], enumerable: !0 });
};
var Br = (e, t, r) => t.has(e) || Or('Cannot ' + r);
var I = (e, t, r) => (
Br(e, t, 'read from private field'), r ? r.call(e) : t.get(e)
),
Lt = (e, t, r) =>
t.has(e) ? Or('Cannot add the same private member more than once')
: t instanceof WeakSet ? t.add(e)
: t.set(e, r),
Y = (e, t, r, s) => (
Br(e, t, 'write to private field'), s ? s.call(e, r) : t.set(e, r), r
);
var Pr = {};
Fe(Pr, { languages: () => ps, parsers: () => xr, printers: () => wi });
var js = (e, t, r, s) => {
if (!(e && t == null))
return (
t.replaceAll ? t.replaceAll(r, s)
: r.global ? t.replace(r, s)
: t.split(r).join(s)
);
},
He = js;
var Dt = 'string',
Gt = 'array',
Kt = 'cursor',
_t = 'indent',
Ot = 'align',
Wt = 'trim',
Bt = 'group',
It = 'fill',
bt = 'if-break',
jt = 'indent-if-break',
Qt = 'line-suffix',
Jt = 'line-suffix-boundary',
j = 'line',
$t = 'label',
Rt = 'break-parent',
fe = new Set([Kt, _t, Ot, Wt, Bt, It, bt, jt, Qt, Jt, j, $t, Rt]);
var Qs = (e, t, r) => {
if (!(e && t == null))
return Array.isArray(t) || typeof t == 'string' ?
t[r < 0 ? t.length + r : r]
: t.at(r);
},
G = Qs;
function Js(e) {
if (typeof e == 'string') return Dt;
if (Array.isArray(e)) return Gt;
if (!e) return;
let { type: t } = e;
if (fe.has(t)) return t;
}
var qt = Js;
var $s = (e) => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(e);
function Xs(e) {
let t = e === null ? 'null' : typeof e;
if (t !== 'string' && t !== 'object')
return `Unexpected doc '${t}',
Expected it to be 'string' or 'object'.`;
if (qt(e)) throw new Error('doc is valid.');
let r = Object.prototype.toString.call(e);
if (r !== '[object Object]') return `Unexpected doc '${r}'.`;
let s = $s([...fe].map((n) => `'${n}'`));
return `Unexpected doc.type '${e.type}'.
Expected it to be ${s}.`;
}
var Ue = class extends Error {
name = 'InvalidDocError';
constructor(t) {
super(Xs(t)), (this.doc = t);
}
},
Me = Ue;
function tn(e, t) {
if (typeof e == 'string') return t(e);
let r = new Map();
return s(e);
function s(i) {
if (r.has(i)) return r.get(i);
let a = n(i);
return r.set(i, a), a;
}
function n(i) {
switch (qt(i)) {
case Gt:
return t(i.map(s));
case It:
return t({ ...i, parts: i.parts.map(s) });
case bt:
return t({
...i,
breakContents: s(i.breakContents),
flatContents: s(i.flatContents),
});
case Bt: {
let { expandedStates: a, contents: o } = i;
return (
a ? ((a = a.map(s)), (o = a[0])) : (o = s(o)),
t({ ...i, contents: o, expandedStates: a })
);
}
case Ot:
case _t:
case jt:
case $t:
case Qt:
return t({ ...i, contents: s(i.contents) });
case Dt:
case Kt:
case Wt:
case Jt:
case j:
case Rt:
return t(i);
default:
throw new Me(i);
}
}
}
function Ir(e, t = Rr) {
return tn(e, (r) =>
typeof r == 'string' ?
yt(
t,
r.split(`
`)
)
: r
);
}
var ze = () => {},
kt = ze,
Ye = ze,
qr = ze;
function B(e) {
return kt(e), { type: _t, contents: e };
}
function en(e, t) {
return kt(t), { type: Ot, contents: t, n: e };
}
function R(e, t = {}) {
return (
kt(e),
Ye(t.expandedStates, !0),
{
type: Bt,
id: t.id,
contents: e,
break: !!t.shouldBreak,
expandedStates: t.expandedStates,
}
);
}
function Xt(e) {
return en(-1, e);
}
function Ge(e) {
return qr(e), { type: It, parts: e };
}
function Ke(e, t = '', r = {}) {
return (
kt(e),
t !== '' && kt(t),
{ type: bt, breakContents: e, flatContents: t, groupId: r.groupId }
);
}
var Vr = { type: Rt };
var rn = { type: j, hard: !0 },
sn = { type: j, hard: !0, literal: !0 },
L = { type: j },
H = { type: j, soft: !0 },
tt = [rn, Vr],
Rr = [sn, Vr];
function yt(e, t) {
kt(e), Ye(t);
let r = [];
for (let s = 0; s < t.length; s++) s !== 0 && r.push(e), r.push(t[s]);
return r;
}
var me = "'",
Fr = '"';
function nn(e, t) {
let r = t === !0 || t === me ? me : Fr,
s = r === me ? Fr : me,
n = 0,
i = 0;
for (let a of e) a === r ? n++ : a === s && i++;
return n > i ? s : r;
}
var de = nn;
function We(e) {
if (typeof e != 'string') throw new TypeError('Expected a string');
return e.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
}
var z,
je = class {
constructor(t) {
Lt(this, z);
Y(this, z, new Set(t));
}
getLeadingWhitespaceCount(t) {
let r = I(this, z),
s = 0;
for (let n = 0; n < t.length && r.has(t.charAt(n)); n++) s++;
return s;
}
getTrailingWhitespaceCount(t) {
let r = I(this, z),
s = 0;
for (let n = t.length - 1; n >= 0 && r.has(t.charAt(n)); n--) s++;
return s;
}
getLeadingWhitespace(t) {
let r = this.getLeadingWhitespaceCount(t);
return t.slice(0, r);
}
getTrailingWhitespace(t) {
let r = this.getTrailingWhitespaceCount(t);
return t.slice(t.length - r);
}
hasLeadingWhitespace(t) {
return I(this, z).has(t.charAt(0));
}
hasTrailingWhitespace(t) {
return I(this, z).has(G(!1, t, -1));
}
trimStart(t) {
let r = this.getLeadingWhitespaceCount(t);
return t.slice(r);
}
trimEnd(t) {
let r = this.getTrailingWhitespaceCount(t);
return t.slice(0, t.length - r);
}
trim(t) {
return this.trimEnd(this.trimStart(t));
}
split(t, r = !1) {
let s = `[${We([...I(this, z)].join(''))}]+`,
n = new RegExp(r ? `(${s})` : s, 'u');
return t.split(n);
}
hasWhitespaceCharacter(t) {
let r = I(this, z);
return Array.prototype.some.call(t, (s) => r.has(s));
}
hasNonWhitespaceCharacter(t) {
let r = I(this, z);
return Array.prototype.some.call(t, (s) => !r.has(s));
}
isWhitespaceOnly(t) {
let r = I(this, z);
return Array.prototype.every.call(t, (s) => r.has(s));
}
};
z = new WeakMap();
var Hr = je;
var an = [
' ',
`
`,
'\f',
'\r',
' ',
],
on = new Hr(an),
K = on;
function ln(e) {
return Array.isArray(e) && e.length > 0;
}
var Zt = ln;
var Qe = class extends Error {
name = 'UnexpectedNodeError';
constructor(t, r, s = 'type') {
super(`Unexpected ${r} node ${s}: ${JSON.stringify(t[s])}.`),
(this.node = t);
}
},
Ur = Qe;
function Mr(e, t, r) {
if (e.type === 'TextNode') {
let s = e.chars.trim();
if (!s) return null;
r.tag === 'style' && r.children.length === 1 && r.children[0] === e ?
(t.chars = '')
: (t.chars = K.split(s).join(' '));
}
e.type === 'ElementNode' &&
(delete t.startTag,
delete t.openTag,
delete t.parts,
delete t.endTag,
delete t.closeTag,
delete t.nameNode,
delete t.body,
delete t.blockParamNodes,
delete t.params,
delete t.path),
e.type === 'Block' && (delete t.blockParamNodes, delete t.params),
e.type === 'AttrNode' && e.name.toLowerCase() === 'class' && delete t.value,
e.type === 'PathExpression' && (t.head = e.head.original);
}
Mr.ignoredProperties = new Set(['loc', 'selfClosing']);
var zr = Mr;
function cn(e) {
let { node: t } = e;
if (t.type !== 'TextNode') return;
let { parent: r } = e;
if (
!(
r.type === 'ElementNode' &&
r.tag === 'style' &&
r.children.length === 1 &&
r.children[0] === t
)
)
return;
let s = r.attributes.find((n) => n.type === 'AttrNode' && n.name === 'lang');
if (
!(
s &&
!(
s.value.type === 'TextNode' &&
(s.value.chars === '' || s.value.chars === 'css')
)
)
)
return async (n) => {
let i = await n(t.chars, { parser: 'css' });
return i ? [tt, i, Xt(H)] : [];
};
}
var Yr = cn;
var te = null;
function ee(e) {
if (te !== null && typeof te.property) {
let t = te;
return (te = ee.prototype = null), t;
}
return (te = ee.prototype = e ?? Object.create(null)), new ee();
}
var un = 10;
for (let e = 0; e <= un; e++) ee();
function Je(e) {
return ee(e);
}
function hn(e, t = 'type') {
Je(e);
function r(s) {
let n = s[t],
i = e[n];
if (!Array.isArray(i))
throw Object.assign(new Error(`Missing visitor keys for '${n}'.`), {
node: s,
});
return i;
}
return r;
}
var Gr = hn;
var Kr = {
Template: ['body'],
Block: ['body'],
MustacheStatement: ['path', 'params', 'hash'],
BlockStatement: ['path', 'params', 'hash', 'program', 'inverse'],
ElementModifierStatement: ['path', 'params', 'hash'],
CommentStatement: [],
MustacheCommentStatement: [],
ElementNode: ['attributes', 'modifiers', 'children', 'comments'],
AttrNode: ['value'],
TextNode: [],
ConcatStatement: ['parts'],
SubExpression: ['path', 'params', 'hash'],
PathExpression: [],
StringLiteral: [],
BooleanLiteral: [],
NumberLiteral: [],
NullLiteral: [],
UndefinedLiteral: [],
Hash: ['pairs'],
HashPair: ['value'],
};
var pn = Gr(Kr),
Wr = pn;
function St(e) {
return e.loc.start.offset;
}
function re(e) {
return e.loc.end.offset;
}
var jr = new Set([
'area',
'base',
'br',
'col',
'command',
'embed',
'hr',
'img',
'input',
'keygen',
'link',
'meta',
'param',
'source',
'track',
'wbr',
]);
function Jr(e) {
return e.toUpperCase() === e;
}
function fn(e) {
return (
e.type === 'ElementNode' &&
typeof e.tag == 'string' &&
!e.tag.startsWith(':') &&
(Jr(e.tag[0]) || e.tag.includes('.'))
);
}
function mn(e) {
return jr.has(e.toLowerCase()) && !Jr(e[0]);
}
function $e(e) {
return (
e.selfClosing === !0 ||
mn(e.tag) ||
(fn(e) && e.children.every((t) => ge(t)))
);
}
function ge(e) {
return e.type === 'TextNode' && !/\S/u.test(e.chars);
}
function Qr(e) {
return (
(e == null ? void 0 : e.type) === 'MustacheCommentStatement' &&
typeof e.value == 'string' &&
e.value.trim() === 'prettier-ignore'
);
}
function $r(e) {
return (
Qr(e.node) ||
(e.isInArray &&
(e.key === 'children' || e.key === 'body' || e.key === 'parts') &&
Qr(e.siblings[e.index - 2]))
);
}
var is = 2;
function dn(e, t, r) {
var n, i, a, o, c, h, p, m, S;
let { node: s } = e;
switch (s.type) {
case 'Block':
case 'Program':
case 'Template':
return R(e.map(r, 'body'));
case 'ElementNode': {
let y = R(bn(e, r)),
E =
(
t.htmlWhitespaceSensitivity === 'ignore' &&
((n = e.next) == null ? void 0 : n.type) === 'ElementNode'
) ?
H
: '';
if ($e(s)) return [y, E];
let C = ['</', s.tag, '>'];
return (
s.children.length === 0 ? [y, B(C), E]
: t.htmlWhitespaceSensitivity === 'ignore' ?
[y, B(Xr(e, t, r)), tt, B(C), E]
: [y, B(R(Xr(e, t, r))), B(C), E]
);
}
case 'BlockStatement':
return wn(e) ?
[Tn(e, r), es(e, r, t), rs(e, r, t)]
: [vn(e, r), R([es(e, r, t), rs(e, r, t), Nn(e, r, t)])];
case 'ElementModifierStatement':
return R(['{{', ns(e, r), '}}']);
case 'MustacheStatement':
return R([be(s), ns(e, r), ye(s)]);
case 'SubExpression':
return R(['(', _n(e, r), H, ')']);
case 'AttrNode': {
let { name: y, value: E } = s,
C = E.type === 'TextNode';
if (C && E.chars === '' && St(E) === re(E)) return y;
let w =
C ? de(E.chars, t.singleQuote)
: E.type === 'ConcatStatement' ?
de(
E.parts
.map((q) => (q.type === 'TextNode' ? q.chars : ''))
.join(''),
t.singleQuote
)
: '',
U = r('value');
return [y, '=', w, y === 'class' && w ? R(B(U)) : U, w];
}
case 'ConcatStatement':
return e.map(r, 'parts');
case 'Hash':
return yt(L, e.map(r, 'pairs'));
case 'HashPair':
return [s.key, '=', r('value')];
case 'TextNode': {
if (e.parent.tag === 'pre' || e.parent.tag === 'style') return s.chars;
let y = He(!1, s.chars, '{{', String.raw`\{{`),
E = xn(e);
if (E) {
if (E === 'class') {
let X = y.trim().split(/\s+/u).join(' '),
rt = !1,
V = !1;
return (
e.parent.type === 'ConcatStatement' &&
(((i = e.previous) == null ? void 0 : i.type) ===
'MustacheStatement' &&
/^\s/u.test(y) &&
(rt = !0),
((a = e.next) == null ? void 0 : a.type) ===
'MustacheStatement' &&
/\s$/u.test(y) &&
X !== '' &&
(V = !0)),
[rt ? L : '', X, V ? L : '']
);
}
return Ir(y);
}
let C = K.isWhitespaceOnly(y),
{ isFirst: x, isLast: w } = e;
if (t.htmlWhitespaceSensitivity !== 'ignore') {
let X = w && e.parent.type === 'Template',
rt = x && e.parent.type === 'Template';
if (C) {
if (rt || X) return '';
let A = [L],
nt = Vt(y);
return nt && (A = se(nt)), w && (A = A.map((ue) => Xt(ue))), A;
}
let V = K.getLeadingWhitespace(y),
xt = [];
if (V) {
xt = [L];
let A = Vt(V);
A && (xt = se(A)), (y = y.slice(V.length));
}
let F = K.getTrailingWhitespace(y),
st = [];
if (F) {
if (!X) {
st = [L];
let A = Vt(F);
A && (st = se(A)), w && (st = st.map((nt) => Xt(nt)));
}
y = y.slice(0, -F.length);
}
return [...xt, Ge(ss(y)), ...st];
}
let U = Vt(y),
q = Pn(y),
$ = An(y);
if (
(x || w) &&
C &&
(e.parent.type === 'Block' ||
e.parent.type === 'ElementNode' ||
e.parent.type === 'Template')
)
return '';
C && U ?
((q = Math.min(U, is)), ($ = 0))
: ((((o = e.next) == null ? void 0 : o.type) === 'BlockStatement' ||
((c = e.next) == null ? void 0 : c.type) === 'ElementNode') &&
($ = Math.max($, 1)),
(((h = e.previous) == null ? void 0 : h.type) === 'BlockStatement' ||
((p = e.previous) == null ? void 0 : p.type) === 'ElementNode') &&
(q = Math.max(q, 1)));
let Nt = '',
Ct = '';
return (
$ === 0 &&
((m = e.next) == null ? void 0 : m.type) === 'MustacheStatement' &&
(Ct = ' '),
q === 0 &&
((S = e.previous) == null ? void 0 : S.type) ===
'MustacheStatement' &&
(Nt = ' '),
x && ((q = 0), (Nt = '')),
w && (($ = 0), (Ct = '')),
K.hasLeadingWhitespace(y) && (y = Nt + K.trimStart(y)),
K.hasTrailingWhitespace(y) && (y = K.trimEnd(y) + Ct),
[...se(q), Ge(ss(y)), ...se($)]
);
}
case 'MustacheCommentStatement': {
let y = St(s),
E = re(s),
C = t.originalText.charAt(y + 2) === '~',
x = t.originalText.charAt(E - 3) === '~',
w = s.value.includes('}}') ? '--' : '';
return ['{{', C ? '~' : '', '!', w, s.value, w, x ? '~' : '', '}}'];
}
case 'PathExpression':
return Rn(s);
case 'BooleanLiteral':
return String(s.value);
case 'CommentStatement':
return ['<!--', s.value, '-->'];
case 'StringLiteral':
return Ln(e, t);
case 'NumberLiteral':
return String(s.value);
case 'UndefinedLiteral':
return 'undefined';
case 'NullLiteral':
return 'null';
case 'AtHead':
case 'VarHead':
case 'ThisHead':
default:
throw new Ur(s, 'Handlebars');
}
}
function gn(e, t) {
return St(e) - St(t);
}
function bn(e, t) {
let { node: r } = e,
s = ['attributes', 'modifiers', 'comments'].filter((i) => Zt(r[i])),
n = s.flatMap((i) => r[i]).sort(gn);
for (let i of s)
e.each(({ node: a }) => {
let o = n.indexOf(a);
n.splice(o, 1, [L, t()]);
}, i);
return Zt(r.blockParams) && n.push(L, Ze(r)), ['<', r.tag, B(n), yn(r)];
}
function Xr(e, t, r) {
let { node: s } = e,
n = s.children.every((i) => ge(i));
return t.htmlWhitespaceSensitivity === 'ignore' && n ?
''
: e.map(({ isFirst: i }) => {
let a = r();
return i && t.htmlWhitespaceSensitivity === 'ignore' ? [H, a] : a;
}, 'children');
}
function yn(e) {
return $e(e) ? Ke([H, '/>'], [' />', H]) : Ke([H, '>'], '>');
}
function be(e) {
var s;
let t = e.trusting ? '{{{' : '{{',
r = (s = e.strip) != null && s.open ? '~' : '';
return [t, r];
}
function ye(e) {
var s;
let t = e.trusting ? '}}}' : '}}';
return [(s = e.strip) != null && s.close ? '~' : '', t];
}
function kn(e) {
let t = be(e),
r = e.openStrip.open ? '~' : '';
return [t, r, '#'];
}
function Sn(e) {
let t = ye(e);
return [e.openStrip.close ? '~' : '', t];
}
function Zr(e) {
let t = be(e),
r = e.closeStrip.open ? '~' : '';
return [t, r, '/'];
}
function ts(e) {
let t = ye(e);
return [e.closeStrip.close ? '~' : '', t];
}
function as(e) {
let t = be(e),
r = e.inverseStrip.open ? '~' : '';
return [t, r];
}
function os(e) {
let t = ye(e);
return [e.inverseStrip.close ? '~' : '', t];
}
function vn(e, t) {
let { node: r } = e,
s = [],
n = ke(e, t);
return (
n && s.push(R(n)),
Zt(r.program.blockParams) && s.push(Ze(r.program)),
R([kn(r), Xe(e, t), s.length > 0 ? B([L, yt(L, s)]) : '', H, Sn(r)])
);
}
function En(e, t) {
return [
t.htmlWhitespaceSensitivity === 'ignore' ? tt : '',
as(e),
'else',
os(e),
];
}
var ls = (e, t) =>
e.head.type === 'VarHead' &&
t.head.type === 'VarHead' &&
e.head.name === t.head.name;
function wn(e) {
var s;
let { grandparent: t, node: r } = e;
return (
((s = t == null ? void 0 : t.inverse) == null ? void 0 : s.body.length) ===
1 &&
t.inverse.body[0] === r &&
ls(t.inverse.body[0].path, t.path)
);
}
function Tn(e, t) {
let { node: r, grandparent: s } = e;
return R([
as(s),
['else', ' ', s.inverse.body[0].path.head.name],
B([
L,
R(ke(e, t)),
...(Zt(r.program.blockParams) ? [L, Ze(r.program)] : []),
]),
H,
os(s),
]);
}
function Nn(e, t, r) {
let { node: s } = e;
return r.htmlWhitespaceSensitivity === 'ignore' ?
[cs(s) ? H : tt, Zr(s), t('path'), ts(s)]
: [Zr(s), t('path'), ts(s)];
}
function cs(e) {
return e.type === 'BlockStatement' && e.program.body.every((t) => ge(t));
}
function Cn(e) {
return (
us(e) &&
e.inverse.body.length === 1 &&
e.inverse.body[0].type === 'BlockStatement' &&
ls(e.inverse.body[0].path, e.path)
);
}
function us(e) {
return e.type === 'BlockStatement' && e.inverse;
}
function es(e, t, r) {
let { node: s } = e;
if (cs(s)) return '';
let n = t('program');
return r.htmlWhitespaceSensitivity === 'ignore' ? B([tt, n]) : B(n);
}
function rs(e, t, r) {
let { node: s } = e,
n = t('inverse'),
i = r.htmlWhitespaceSensitivity === 'ignore' ? [tt, n] : n;
return (
Cn(s) ? i
: us(s) ? [En(s, r), B(i)]
: ''
);
}
function ss(e) {
return yt(L, K.split(e));
}
function xn(e) {
for (let t = 0; t < 2; t++) {
let r = e.getParentNode(t);
if ((r == null ? void 0 : r.type) === 'AttrNode')
return r.name.toLowerCase();
}
}
function Vt(e) {
return (
(e = typeof e == 'string' ? e : ''),
e.split(`
`).length - 1
);
}
function Pn(e) {
e = typeof e == 'string' ? e : '';
let t = (e.match(/^([^\S\n\r]*[\n\r])+/gu) || [])[0] || '';
return Vt(t);
}
function An(e) {
e = typeof e == 'string' ? e : '';
let t = (e.match(/([\n\r][^\S\n\r]*)+$/gu) || [])[0] || '';
return Vt(t);
}
function se(e = 0) {
return Array.from({ length: Math.min(e, is) }).fill(tt);
}
function Ln(e, t) {
let {
node: { value: r },
} = e,
s = de(r, Dn(e) ? !t.singleQuote : t.singleQuote);
return [s, He(!1, r, s, `\\${s}`), s];
}
function Dn(e) {
let { ancestors: t } = e,
r = t.findIndex((s) => s.type !== 'SubExpression');
return (
r !== -1 &&
t[r + 1].type === 'ConcatStatement' &&
t[r + 2].type === 'AttrNode'
);
}
function _n(e, t) {
let r = Xe(e, t),
s = ke(e, t);
return s ? B([r, L, R(s)]) : r;
}
function ns(e, t) {
let r = Xe(e, t),
s = ke(e, t);
return s ? [B([r, L, s]), H] : r;
}
function Xe(e, t) {
return t('path');
}
function ke(e, t) {
var n;
let { node: r } = e,
s = [];
return (
r.params.length > 0 && s.push(...e.map(t, 'params')),
((n = r.hash) == null ? void 0 : n.pairs.length) > 0 && s.push(t('hash')),
s.length === 0 ? '' : yt(L, s)
);
}
function Ze(e) {
return ['as |', e.blockParams.join(' '), '|'];
}
var On = new Set('!"#%&\'()*+,./;<=>@[\\]^`{|}~'),
Bn = new Set(['true', 'false', 'null', 'undefined']),
In = (e, t) =>
t === 0 && e.startsWith('@') ?
!1
: (t !== 0 && Bn.has(e)) ||
/\s/u.test(e) ||
/^\d/u.test(e) ||
Array.prototype.some.call(e, (r) => On.has(r));
function Rn(e) {
return e.tail.length === 0 && e.original.includes('/') ?
e.original
: [e.head.original, ...e.tail]
.map((r, s) => (In(r, s) ? `[${r}]` : r))
.join('.');
}
var qn = {
print: dn,
massageAstNode: zr,
hasPrettierIgnore: $r,
getVisitorKeys: Wr,
embed: Yr,
},
hs = qn;
var ps = [
{
linguistLanguageId: 155,
name: 'Handlebars',
type: 'markup',
color: '#f7931e',
aliases: ['hbs', 'htmlbars'],
extensions: ['.handlebars', '.hbs'],
tmScope: 'text.html.handlebars',
aceMode: 'handlebars',
parsers: ['glimmer'],
vscodeLanguageIds: ['handlebars'],
},
];
var xr = {};
Fe(xr, { glimmer: () => Ei });
var Vn = Object.freeze([]);
function ms() {
return Vn;
}
var Ma = ms(),
za = ms();
var tr = Object.assign;
var fs = console;
function ds(e, t = 'unexpected unreachable branch') {
throw (
(fs.log('unreachable', e),
fs.log(`${t} :: ${JSON.stringify(e)} (${e})`),
new Error('code reached unreachable'))
);
}
var Fn = (function () {
var e = function (it, d, k, g) {
for (k = k || {}, g = it.length; g--; k[it[g]] = d);
return k;
},
t = [2, 44],
r = [1, 20],
s = [5, 14, 15, 19, 29, 34, 39, 44, 47, 48, 52, 56, 60],
n = [1, 35],
i = [1, 38],
a = [1, 30],
o = [1, 31],
c = [1, 32],
h = [1, 33],
p = [1, 34],
m = [1, 37],
S = [14, 15, 19, 29, 34, 39, 44, 47, 48, 52, 56, 60],
y = [14, 15, 19, 29, 34, 44, 47, 48, 52, 56, 60],
E = [15, 18],
C = [14, 15, 19, 29, 34, 47, 48, 52, 56, 60],
x = [33, 64, 71, 79, 80, 81, 82, 83, 84],
w = [23, 33, 55, 64, 67, 71, 74, 79, 80, 81, 82, 83, 84],
U = [1, 51],
q = [23, 33, 55, 64, 67, 71, 74, 79, 80, 81, 82, 83, 84, 86],
$ = [2, 43],
Nt = [55, 64, 71, 79, 80, 81, 82, 83, 84],
Ct = [1, 58],
X = [1, 59],
rt = [1, 66],
V = [33, 64, 71, 74, 79, 80, 81, 82, 83, 84],
xt = [23, 64, 71, 79, 80, 81, 82, 83, 84],
F = [1, 76],
st = [64, 67, 71, 79, 80, 81, 82, 83, 84],
A = [33, 74],
nt = [23, 33, 55, 67, 71, 74],
ue = [1, 106],
De = [1, 118],
Ar = [71, 76],
_e = {
trace: function () {},
yy: {},
symbols_: {
error: 2,
root: 3,
program: 4,
EOF: 5,
program_repetition0: 6,
statement: 7,
mustache: 8,
block: 9,
rawBlock: 10,
partial: 11,
partialBlock: 12,
content: 13,
COMMENT: 14,
CONTENT: 15,
openRawBlock: 16,
rawBlock_repetition0: 17,
END_RAW_BLOCK: 18,
OPEN_RAW_BLOCK: 19,
helperName: 20,
openRawBlock_repetition0: 21,
openRawBlock_option0: 22,
CLOSE_RAW_BLOCK: 23,
openBlock: 24,
block_option0: 25,
closeBlock: 26,
openInverse: 27,
block_option1: 28,
OPEN_BLOCK: 29,
openBlock_repetition0: 30,
openBlock_option0: 31,
openBlock_option1: 32,
CLOSE: 33,
OPEN_INVERSE: 34,
openInverse_repetition0: 35,
openInverse_option0: 36,
openInverse_option1: 37,
openInverseChain: 38,
OPEN_INVERSE_CHAIN: 39,
openInverseChain_repetition0: 40,
openInverseChain_option0: 41,
openInverseChain_option1: 42,
inverseAndProgram: 43,
INVERSE: 44,
inverseChain: 45,
inverseChain_option0: 46,
OPEN_ENDBLOCK: 47,
OPEN: 48,
expr: 49,
mustache_repetition0: 50,
mustache_option0: 51,
OPEN_UNESCAPED: 52,
mustache_repetition1: 53,
mustache_option1: 54,
CLOSE_UNESCAPED: 55,
OPEN_PARTIAL: 56,
partial_repetition0: 57,
partial_option0: 58,
openPartialBlock: 59,
OPEN_PARTIAL_BLOCK: 60,
openPartialBlock_repetition0: 61,
openPartialBlock_option0: 62,
sexpr: 63,
OPEN_SEXPR: 64,
sexpr_repetition0: 65,
sexpr_option0: 66,
CLOSE_SEXPR: 67,
hash: 68,
hash_repetition_plus0: 69,
hashSegment: 70,
ID: 71,
EQUALS: 72,
blockParams: 73,
OPEN_BLOCK_PARAMS: 74,
blockParams_repetition_plus0: 75,
CLOSE_BLOCK_PARAMS: 76,
path: 77,
dataName: 78,
STRING: 79,
NUMBER: 80,
BOOLEAN: 81,
UNDEFINED: 82,
NULL: 83,
DATA: 84,
pathSegments: 85,
SEP: 86,
$accept: 0,
$end: 1,
},
terminals_: {
2: 'error',
5: 'EOF',
14: 'COMMENT',
15: 'CONTENT',
18: 'END_RAW_BLOCK',
19: 'OPEN_RAW_BLOCK',
23: 'CLOSE_RAW_BLOCK',
29: 'OPEN_BLOCK',
33: 'CLOSE',
34: 'OPEN_INVERSE',
39: 'OPEN_INVERSE_CHAIN',
44: 'INVERSE',
47: 'OPEN_ENDBLOCK',
48: 'OPEN',
52: 'OPEN_UNESCAPED',
55: 'CLOSE_UNESCAPED',
56: 'OPEN_PARTIAL',
60: 'OPEN_PARTIAL_BLOCK',
64: 'OPEN_SEXPR',
67: 'CLOSE_SEXPR',
71: 'ID',
72: 'EQUALS',
74: 'OPEN_BLOCK_PARAMS',
76: 'CLOSE_BLOCK_PARAMS',
79: 'STRING',
80: 'NUMBER',
81: 'BOOLEAN',
82: 'UNDEFINED',
83: 'NULL',
84: 'DATA',
86: 'SEP',
},
productions_: [
0,
[3, 2],
[4, 1],
[7, 1],
[7, 1],
[7, 1],
[7, 1],
[7, 1],
[7, 1],
[7, 1],
[13, 1],
[10, 3],
[16, 5],
[9, 4],
[9, 4],
[24, 6],
[27, 6],
[38, 6],
[43, 2],
[45, 3],
[45, 1],
[26, 3],
[8, 5],
[8, 5],
[11, 5],
[12, 3],
[59, 5],
[49, 1],
[49, 1],
[63, 5],
[68, 1],
[70, 3],
[73, 3],
[20, 1],
[20, 1],
[20, 1],
[20, 1],
[20, 1],
[20, 1],
[20, 1],
[78, 2],
[77, 1],
[85, 3],
[85, 1],
[6, 0],
[6, 2],
[17, 0],
[17, 2],
[21, 0],
[21, 2],
[22, 0],
[22, 1],
[25, 0],
[25, 1],
[28, 0],
[28, 1],
[30, 0],
[30, 2],
[31, 0],
[31, 1],
[32, 0],
[32, 1],
[35, 0],
[35, 2],
[36, 0],
[36, 1],
[37, 0],
[37, 1],
[40, 0],
[40, 2],
[41, 0],
[41, 1],
[42, 0],
[42, 1],
[46, 0],
[46, 1],
[50, 0],
[50, 2],
[51, 0],
[51, 1],
[53, 0],
[53, 2],
[54, 0],
[54, 1],
[57, 0],
[57, 2],
[58, 0],
[58, 1],
[61, 0],
[61, 2],
[62, 0],
[62, 1],
[65, 0],
[65, 2],
[66, 0],
[66, 1],
[69, 1],
[69, 2],
[75, 1],
[75, 2],
],
performAction: function (d, k, g, b, N, l, Pt) {
var u = l.length - 1;
switch (N) {
case 1:
return l[u - 1];
case 2:
this.$ = b.prepareProgram(l[u]);
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 20:
case 27:
case 28:
case 33:
case 34:
this.$ = l[u];
break;
case 9:
this.$ = {
type: 'CommentStatement',
value: b.stripComment(l[u]),
strip: b.stripFlags(l[u], l[u]),
loc: b.locInfo(this._$),
};
break;
case 10:
this.$ = {
type: 'ContentStatement',
original: l[u],
value: l[u],
loc: b.locInfo(this._$),
};
break;
case 11:
this.$ = b.prepareRawBlock(l[u - 2], l[u - 1], l[u], this._$);
break;
case 12:
this.$ = { path: l[u - 3], params: l[u - 2], hash: l[u - 1] };
break;
case 13:
this.$ = b.prepareBlock(
l[u - 3],
l[u - 2],
l[u - 1],
l[u],
!1,
this._$
);
break;
case 14:
this.$ = b.prepareBlock(
l[u - 3],
l[u - 2],
l[u - 1],
l[u],
!0,
this._$
);
break;
case 15:
this.$ = {
open: l[u - 5],
path: l[u - 4],
params: l[u - 3],
hash: l[u - 2],
blockParams: l[u - 1],
strip: b.stripFlags(l[u - 5], l[u]),
};
break;
case 16:
case 17:
this.$ = {
path: l[u - 4],
params: l[u - 3],
hash: l[u - 2],
blockParams: l[u - 1],
strip: b.stripFlags(l[u - 5], l[u]),
};
break;
case 18:
this.$ = {
strip: b.stripFlags(l[u - 1], l[u - 1]),
program: l[u],
};
break;
case 19:
var at = b.prepareBlock(
l[u - 2],
l[u - 1],
l[u],
l[u],
!1,
this._$
),
Yt = b.prepareProgram([at], l[u - 1].loc);
(Yt.chained = !0),
(this.$ = { strip: l[u - 2].strip, program: Yt, chain: !0 });
break;
case 21:
this.$ = { path: l[u - 1], strip: b.stripFlags(l[u - 2], l[u]) };
break;
case 22:
case 23:
this.$ = b.prepareMustache(
l[u - 3],
l[u - 2],
l[u - 1],
l[u - 4],
b.stripFlags(l[u - 4], l[u]),
this._$
);
break;
case 24:
this.$ = {
type: 'PartialStatement',
name: l[u - 3],
params: l[u - 2],
hash: l[u - 1],
indent: '',
strip: b.stripFlags(l[u - 4], l[u]),
loc: b.locInfo(this._$),
};
break;
case 25:
this.$ = b.preparePartialBlock(l[u - 2], l[u - 1], l[u], this._$);
break;
case 26:
this.$ = {
path: l[u - 3],
params: l[u - 2],
hash: l[u - 1],
strip: b.stripFlags(l[u - 4], l[u]),
};
break;
case 29:
this.$ = {
type: 'SubExpression',
path: l[u - 3],
params: l[u - 2],
hash: l[u - 1],
loc: b.locInfo(this._$),
};
break;
case 30:
this.$ = { type: 'Hash', pairs: l[u], loc: b.locInfo(this._$) };
break;
case 31:
this.$ = {
type: 'HashPair',
key: b.id(l[u - 2]),
value: l[u],
loc: b.locInfo(this._$),
};
break;
case 32:
this.$ = b.id(l[u - 1]);
break;
case 35:
this.$ = {
type: 'StringLiteral',
value: l[u],
original: l[u],
loc: b.locInfo(this._$),
};
break;
case 36:
this.$ = {
type: 'NumberLiteral',
value: Number(l[u]),
original: Number(l[u]),
loc: b.locInfo(this._$),
};
break;
case 37:
this.$ = {
type: 'BooleanLiteral',
value: l[u] === 'true',
original: l[u] === 'true',
loc: b.locInfo(this._$),
};
break;
case 38:
this.$ = {
type: 'UndefinedLiteral',
original: void 0,
value: void 0,
loc: b.locInfo(this._$),
};
break;
case 39:
this.$ = {
type: 'NullLiteral',
original: null,
value: null,
loc: b.locInfo(this._$),
};
break;
case 40:
this.$ = b.preparePath(!0, l[u], this._$);
break;
case 41:
this.$ = b.preparePath(!1, l[u], this._$);
break;
case 42:
l[u - 2].push({
part: b.id(l[u]),
original: l[u],
separator: l[u - 1],
}),
(this.$ = l[u - 2]);
break;
case 43:
this.$ = [{ part: b.id(l[u]), original: l[u] }];
break;
case 44:
case 46:
case 48:
case 56:
case 62:
case 68:
case 76:
case 80:
case 84:
case 88:
case 92:
this.$ = [];
break;
case 45:
case 47:
case 49:
case 57:
case 63:
case 69:
case 77:
case 81:
case 85:
case 89:
case 93:
case 97:
case 99:
l[u - 1].push(l[u]);
break;
case 96:
case 98:
this.$ = [l[u]];
break;
}
},
table: [
e([5, 14, 15, 19, 29, 34, 48, 52, 56, 60], t, { 3: 1, 4: 2, 6: 3 }),
{ 1: [3] },
{ 5: [1, 4] },
e([5, 39, 44, 47], [2, 2], {
7: 5,
8: 6,
9: 7,
10: 8,
11: 9,
12: 10,
13: 11,
24: 15,
27: 16,
16: 17,
59: 19,
14: [1, 12],
15: r,
19: [1, 23],
29: [1, 21],
34: [1, 22],
48: [1, 13],
52: [1, 14],
56: [1, 18],
60: [1, 24],
}),
{ 1: [2, 1] },
e(s, [2, 45]),
e(s, [2, 3]),
e(s, [2, 4]),
e(s, [2, 5]),
e(s, [2, 6]),
e(s, [2, 7]),
e(s, [2, 8]),
e(s, [2, 9]),
{
20: 26,
49: 25,
63: 27,
64: n,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{
20: 26,
49: 39,
63: 27,
64: n,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(S, t, { 6: 3, 4: 40 }),
e(y, t, { 6: 3, 4: 41 }),
e(E, [2, 46], { 17: 42 }),
{
20: 26,
49: 43,
63: 27,
64: n,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(C, t, { 6: 3, 4: 44 }),
e([5, 14, 15, 18, 19, 29, 34, 39, 44, 47, 48, 52, 56, 60], [2, 10]),
{
20: 45,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{
20: 46,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{
20: 47,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{
20: 26,
49: 48,
63: 27,
64: n,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(x, [2, 76], { 50: 49 }),
e(w, [2, 27]),
e(w, [2, 28]),
e(w, [2, 33]),
e(w, [2, 34]),
e(w, [2, 35]),
e(w, [2, 36]),
e(w, [2, 37]),
e(w, [2, 38]),
e(w, [2, 39]),
{
20: 26,
49: 50,
63: 27,
64: n,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(w, [2, 41], { 86: U }),
{ 71: i, 85: 52 },
e(q, $),
e(Nt, [2, 80], { 53: 53 }),
{ 25: 54, 38: 56, 39: Ct, 43: 57, 44: X, 45: 55, 47: [2, 52] },
{ 28: 60, 43: 61, 44: X, 47: [2, 54] },
{ 13: 63, 15: r, 18: [1, 62] },
e(x, [2, 84], { 57: 64 }),
{ 26: 65, 47: rt },
e(V, [2, 56], { 30: 67 }),
e(V, [2, 62], { 35: 68 }),
e(xt, [2, 48], { 21: 69 }),
e(x, [2, 88], { 61: 70 }),
{
20: 26,
33: [2, 78],
49: 72,
51: 71,
63: 27,
64: n,
68: 73,
69: 74,
70: 75,
71: F,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(st, [2, 92], { 65: 77 }),
{ 71: [1, 78] },
e(w, [2, 40], { 86: U }),
{
20: 26,
49: 80,
54: 79,
55: [2, 82],
63: 27,
64: n,
68: 81,
69: 74,
70: 75,
71: F,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{ 26: 82, 47: rt },
{ 47: [2, 53] },
e(S, t, { 6: 3, 4: 83 }),
{ 47: [2, 20] },
{
20: 84,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(C, t, { 6: 3, 4: 85 }),
{ 26: 86, 47: rt },
{ 47: [2, 55] },
e(s, [2, 11]),
e(E, [2, 47]),
{
20: 26,
33: [2, 86],
49: 88,
58: 87,
63: 27,
64: n,
68: 89,
69: 74,
70: 75,
71: F,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(s, [2, 25]),
{
20: 90,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(A, [2, 58], {
20: 26,
63: 27,
77: 28,
78: 29,
85: 36,
69: 74,
70: 75,
31: 91,
49: 92,
68: 93,
64: n,
71: F,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
}),
e(A, [2, 64], {
20: 26,
63: 27,
77: 28,
78: 29,
85: 36,
69: 74,
70: 75,
36: 94,
49: 95,
68: 96,
64: n,
71: F,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
}),
{
20: 26,
22: 97,
23: [2, 50],
49: 98,
63: 27,
64: n,
68: 99,
69: 74,
70: 75,
71: F,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{
20: 26,
33: [2, 90],
49: 101,
62: 100,
63: 27,
64: n,
68: 102,
69: 74,
70: 75,
71: F,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{ 33: [1, 103] },
e(x, [2, 77]),
{ 33: [2, 79] },
e([23, 33, 55, 67, 74], [2, 30], { 70: 104, 71: [1, 105] }),
e(nt, [2, 96]),
e(q, $, { 72: ue }),
{
20: 26,
49: 108,
63: 27,
64: n,
66: 107,
67: [2, 94],
68: 109,
69: 74,
70: 75,
71: F,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
e(q, [2, 42]),
{ 55: [1, 110] },
e(Nt, [2, 81]),
{ 55: [2, 83] },
e(s, [2, 13]),
{ 38: 56, 39: Ct, 43: 57, 44: X, 45: 112, 46: 111, 47: [2, 74] },
e(V, [2, 68], { 40: 113 }),
{ 47: [2, 18] },
e(s, [2, 14]),
{ 33: [1, 114] },
e(x, [2, 85]),
{ 33: [2, 87] },
{ 33: [1, 115] },
{ 32: 116, 33: [2, 60], 73: 117, 74: De },
e(V, [2, 57]),
e(A, [2, 59]),
{ 33: [2, 66], 37: 119, 73: 120, 74: De },
e(V, [2, 63]),
e(A, [2, 65]),
{ 23: [1, 121] },
e(xt, [2, 49]),
{ 23: [2, 51] },
{ 33: [1, 122] },
e(x, [2, 89]),
{ 33: [2, 91] },
e(s, [2, 22]),
e(nt, [2, 97]),
{ 72: ue },
{
20: 26,
49: 123,
63: 27,
64: n,
71: i,
77: 28,
78: 29,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
85: 36,
},
{ 67: [1, 124] },
e(st, [2, 93]),
{ 67: [2, 95] },
e(s, [2, 23]),
{ 47: [2, 19] },
{ 47: [2, 75] },
e(A, [2, 70], {
20: 26,
63: 27,
77: 28,
78: 29,
85: 36,
69: 74,
70: 75,
41: 125,
49: 126,
68: 127,
64: n,
71: F,
79: a,
80: o,
81: c,
82: h,
83: p,
84: m,
}),
e(s, [2, 24]),
e(s, [2, 21]),
{ 33: [1, 128] },
{ 33: [2, 61] },
{ 71: [1, 130], 75: 129 },
{ 33: [1, 131] },
{ 33: [2, 67] },
e(E, [2, 12]),
e(C, [2, 26]),
e(nt, [2, 31]),
e(w, [2, 29]),
{ 33: [2, 72], 42: 132, 73: 133, 74: De },
e(V, [2, 69]),
e(A, [2, 71]),
e(S, [2, 15]),
{ 71: [1, 135], 76: [1, 134] },
e(Ar, [2, 98]),
e(y, [2, 16]),
{ 33: [1, 136] },
{ 33: [2, 73] },
{ 33: [2, 32] },
e(Ar, [2, 99]),
e(S, [2, 17]),
],
defaultActions: {
4: [2, 1],
55: [2, 53],
57: [2, 20],
61: [2, 55],
73: [2, 79],
81: [2, 83],
85: [2, 18],
89: [2, 87],
99: [2, 51],
102: [2, 91],
109: [2, 95],
111: [2, 19],
112: [2, 75],
117: [2, 61],
120: [2, 67],
133: [2, 73],
134: [2, 32],
},
parseError: function (d, k) {
if (k.recoverable) this.trace(d);
else {
var g = new Error(d);
throw ((g.hash = k), g);
}
},
parse: function (d) {
var k = this,
g = [0],
b = [],
N = [null],
l = [],
Pt = this.table,
u = '',
at = 0,
Yt = 0,
Lr = 0,
zs = 2,
Dr = 1,
Ys = l.slice.call(arguments, 1),
P = Object.create(this.lexer),
dt = { yy: {} };
for (var Be in this.yy)
Object.prototype.hasOwnProperty.call(this.yy, Be) &&
(dt.yy[Be] = this.yy[Be]);
P.setInput(d, dt.yy),
(dt.yy.lexer = P),
(dt.yy.parser = this),
typeof P.yylloc > 'u' && (P.yylloc = {});
var Ie = P.yylloc;
l.push(Ie);
var Gs = P.options && P.options.ranges;
typeof dt.yy.parseError == 'function' ?
(this.parseError = dt.yy.parseError)
: (this.parseError = Object.getPrototypeOf(this).parseError);
function Ti(W) {
(g.length = g.length - 2 * W),
(N.length = N.length - W),
(l.length = l.length - W);
}
for (
var Ks = function () {
var W;
return (
(W = P.lex() || Dr),
typeof W != 'number' && (W = k.symbols_[W] || W),
W
);
},
O,
Re,
gt,
M,
Ni,
qe,
At = {},
he,
Z,
_r,
pe;
;
) {
if (
((gt = g[g.length - 1]),
this.defaultActions[gt] ?
(M = this.defaultActions[gt])
: ((O === null || typeof O > 'u') && (O = Ks()),
(M = Pt[gt] && Pt[gt][O])),
typeof M > 'u' || !M.length || !M[0])
) {
var Ve = '';
pe = [];
for (he in Pt[gt])
this.terminals_[he] &&
he > zs &&
pe.push("'" + this.terminals_[he] + "'");
P.showPosition ?
(Ve =
'Parse error on line ' +
(at + 1) +
`:
` +
P.showPosition() +
`
Expecting ` +
pe.join(', ') +
", got '" +
(this.terminals_[O] || O) +
"'")
: (Ve =
'Parse error on line ' +
(at + 1) +
': Unexpected ' +
(O == Dr ? 'end of input' : (
"'" + (this.terminals_[O] || O) + "'"
))),
this.parseError(Ve, {
text: P.match,
token: this.terminals_[O] || O,
line: P.yylineno,
loc: Ie,
expected: pe,
});
}
if (M[0] instanceof Array && M.length > 1)
throw new Error(
'Parse Error: multiple actions possible at state: ' +
gt +
', token: ' +
O
);
switch (M[0]) {
case 1:
g.push(O),
N.push(P.yytext),
l.push(P.yylloc),
g.push(M[1]),
(O = null),
Re ?
((O = Re), (Re = null))
: ((Yt = P.yyleng),
(u = P.yytext),
(at = P.yylineno),
(Ie = P.yylloc),
Lr > 0 && Lr--);
break;
case 2:
if (
((Z = this.productions_[M[1]][1]),
(At.$ = N[N.length - Z]),
(At._$ = {
first_line: l[l.length - (Z || 1)].first_line,
last_line: l[l.length - 1].last_line,
first_column: l[l.length - (Z || 1)].first_column,
last_column: l[l.length - 1].last_column,
}),
Gs &&
(At._$.range = [
l[l.length - (Z || 1)].range[0],
l[l.length - 1].range[1],
]),
(qe = this.performAction.apply(
At,
[u, Yt, at, dt.yy, M[1], N, l].concat(Ys)
)),
typeof qe < 'u')
)
return qe;
Z &&
((g = g.slice(0, -1 * Z * 2)),
(N = N.slice(0, -1 * Z)),
(l = l.slice(0, -1 * Z))),
g.push(this.productions_[M[1]][0]),
N.push(At.$),
l.push(At._$),
(_r = Pt[g[g.length - 2]][g[g.length - 1]]),
g.push(_r);
break;
case 3:
return !0;
}
}
return !0;
},
},
Ms = (function () {
var it = {
EOF: 1,
parseError: function (k, g) {
if (this.yy.parser) this.yy.parser.parseError(k, g);
else throw new Error(k);
},
setInput: function (d, k) {
return (
(this.yy = k || this.yy || {}),
(this._input = d),
(this._more = this._backtrack = this.done = !1),
(this.yylineno = this.yyleng = 0),
(this.yytext = this.matched = this.match = ''),
(this.conditionStack = ['INITIAL']),
(this.yylloc = {
first_line: 1,
first_column: 0,
last_line: 1,
last_column: 0,
}),
this.options.ranges && (this.yylloc.range = [0, 0]),
(this.offset = 0),
this
);
},
input: function () {
var d = this._input[0];
(this.yytext += d),
this.yyleng++,
this.offset++,
(this.match += d),
(this.matched += d);
var k = d.match(/(?:\r\n?|\n).*/g);
return (
k ?
(this.yylineno++, this.yylloc.last_line++)
: this.yylloc.last_column++,
this.options.ranges && this.yylloc.range[1]++,
(this._input = this._input.slice(1)),
d
);
},
unput: function (d) {
var k = d.length,
g = d.split(/(?:\r\n?|\n)/g);
(this._input = d + this._input),
(this.yytext = this.yytext.substr(0, this.yytext.length - k)),
(this.offset -= k);
var b = this.match.split(/(?:\r\n?|\n)/g);
(this.match = this.match.substr(0, this.match.length - 1)),
(this.matched = this.matched.substr(0, this.matched.length - 1)),
g.length - 1 && (this.yylineno -= g.length - 1);
var N = this.yylloc.range;
return (
(this.yylloc = {
first_line: this.yylloc.first_line,
last_line: this.yylineno + 1,
first_column: this.yylloc.first_column,
last_column:
g ?
(g.length === b.length ? this.yylloc.first_column : 0) +
b[b.length - g.length].length -
g[0].length
: this.yylloc.first_column - k,
}),
this.options.ranges &&
(this.yylloc.range = [N[0], N[0] + this.yyleng - k]),
(this.yyleng = this.yytext.length),
this
);
},
more: function () {
return (this._more = !0), this;
},
reject: function () {
if (this.options.backtrack_lexer) this._backtrack = !0;
else
return this.parseError(
'Lexical error on line ' +
(this.yylineno + 1) +
`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
` +
this.showPosition(),
{ text: '', token: null, line: this.yylineno }
);
return this;
},
less: function (d) {
this.unput(this.match.slice(d));
},
pastInput: function () {
var d = this.matched.substr(
0,
this.matched.length - this.match.length
);
return (
(d.length > 20 ? '...' : '') + d.substr(-20).replace(/\n/g, '')
);
},
upcomingInput: function () {
var d = this.match;
return (
d.length < 20 && (d += this._input.substr(0, 20 - d.length)),
(d.substr(0, 20) + (d.length > 20 ? '...' : '')).replace(
/\n/g,
''
)
);
},
showPosition: function () {
var d = this.pastInput(),
k = new Array(d.length + 1).join('-');
return (
d +
this.upcomingInput() +
`
` +
k +
'^'
);
},
test_match: function (d, k) {
var g, b, N;
if (
(this.options.backtrack_lexer &&
((N = {
yylineno: this.yylineno,
yylloc: {
first_line: this.yylloc.first_line,
last_line: this.last_line,
first_column: this.yylloc.first_column,
last_column: this.yylloc.last_column,
},
yytext: this.yytext,
match: this.match,
matches: this.matches,
matched: this.matched,
yyleng: this.yyleng,
offset: this.offset,
_more: this._more,
_input: this._input,
yy: this.yy,
conditionStack: this.conditionStack.slice(0),
done: this.done,
}),
this.options.ranges &&
(N.yylloc.range = this.yylloc.range.slice(0))),
(b = d[0].match(/(?:\r\n?|\n).*/g)),
b && (this.yylineno += b.length),
(this.yylloc = {
first_line: this.yylloc.last_line,
last_line: this.yylineno + 1,
first_column: this.yylloc.last_column,
last_column:
b ?
b[b.length - 1].length -
b[b.length - 1].match(/\r?\n?/)[0].length
: this.yylloc.last_column + d[0].length,
}),
(this.yytext += d[0]),
(this.match += d[0]),
(this.matches = d),
(this.yyleng = this.yytext.length),
this.options.ranges &&
(this.yylloc.range = [
this.offset,
(this.offset += this.yyleng),
]),
(this._more = !1),
(this._backtrack = !1),
(this._input = this._input.slice(d[0].length)),
(this.matched += d[0]),
(g = this.performAction.call(
this,
this.yy,
this,
k,
this.conditionStack[this.conditionStack.length - 1]
)),
this.done && this._input && (this.done = !1),
g)
)
return g;
if (this._backtrack) {
for (var l in N) this[l] = N[l];
return !1;
}
return !1;
},
next: function () {
if (this.done) return this.EOF;
this._input || (this.done = !0);
var d, k, g, b;
this._more || ((this.yytext = ''), (this.match = ''));
for (var N = this._currentRules(), l = 0; l < N.length; l++)
if (
((g = this._input.match(this.rules[N[l]])),
g && (!k || g[0].length > k[0].length))
) {
if (((k = g), (b = l), this.options.backtrack_lexer)) {
if (((d = this.test_match(g, N[l])), d !== !1)) return d;
if (this._backtrack) {
k = !1;
continue;
} else return !1;
} else if (!this.options.flex) break;
}
return (
k ? ((d = this.test_match(k, N[b])), d !== !1 ? d : !1)
: this._input === '' ? this.EOF
: this.parseError(
'Lexical error on line ' +
(this.yylineno + 1) +
`. Unrecognized text.
` +
this.showPosition(),
{ text: '', token: null, line: this.yylineno }
)
);
},
lex: function () {
var k = this.next();
return k || this.lex();
},
begin: function (k) {
this.conditionStack.push(k);
},
popState: function () {
var k = this.conditionStack.length - 1;
return k > 0 ? this.conditionStack.pop() : this.conditionStack[0];
},
_currentRules: function () {
return (
this.conditionStack.length &&
this.conditionStack[this.conditionStack.length - 1]
) ?
this.conditions[
this.conditionStack[this.conditionStack.length - 1]
].rules
: this.conditions.INITIAL.rules;
},
topState: function (k) {
return (
(k = this.conditionStack.length - 1 - Math.abs(k || 0)),
k >= 0 ? this.conditionStack[k] : 'INITIAL'
);
},
pushState: function (k) {
this.begin(k);
},
stateStackSize: function () {
return this.conditionStack.length;
},
options: {},
performAction: function (k, g, b, N) {
function l(u, at) {
return (g.yytext = g.yytext.substring(u, g.yyleng - at + u));
}
var Pt = N;
switch (b) {
case 0:
if (
(g.yytext.slice(-2) === '\\\\' ? (l(0, 1), this.begin('mu'))
: g.yytext.slice(-1) === '\\' ? (l(0, 1), this.begin('emu'))
: this.begin('mu'),
g.yytext)
)
return 15;
break;
case 1:
return 15;
case 2:
return this.popState(), 15;
break;
case 3:
return this.begin('raw'), 15;
break;
case 4:
return (
this.popState(),
(
this.conditionStack[this.conditionStack.length - 1] ===
'raw'
) ?
15
: (l(5, 9), 18)
);
case 5:
return 15;
case 6:
return this.popState(), 14;
break;
case 7:
return 64;
case 8:
return 67;
case 9:
return 19;
case 10:
return this.popState(), this.begin('raw'), 23;
break;
case 11:
return 56;
case 12:
return 60;
case 13:
return 29;
case 14:
return 47;
case 15:
return this.popState(), 44;
break;
case 16:
return this.popState(), 44;
break;
case 17:
return 34;
case 18:
return 39;
case 19:
return 52;
case 20:
return 48;
case 21:
this.unput(g.yytext), this.popState(), this.begin('com');
break;
case 22:
return this.popState(), 14;
break;
case 23:
return 48;
case 24:
return 72;
case 25:
return 71;
case 26:
return 71;
case 27:
return 86;
case 28:
break;
case 29:
return this.popState(), 55;
break;
case 30:
return this.popState(), 33;
break;
case 31:
return (g.yytext = l(1, 2).replace(/\\"/g, '"')), 79;
break;
case 32:
return (g.yytext = l(1, 2).replace(/\\'/g, "'")), 79;
break;
case 33:
return 84;
case 34:
return 81;
case 35:
return 81;
case 36:
return 82;
case 37:
return 83;
case 38:
return 80;
case 39:
return 74;
case 40:
return 76;
case 41:
return 71;
case 42:
return (g.yytext = g.yytext.replace(/\\([\\\]])/g, '$1')), 71;
break;
case 43:
return 'INVALID';
case 44:
return 5;
}
},
rules: [
/^(?:[^\x00]*?(?=(\{\{)))/,
/^(?:[^\x00]+)/,
/^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/,
/^(?:\{\{\{\{(?=[^/]))/,
/^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/,
/^(?:[^\x00]+?(?=(\{\{\{\{)))/,
/^(?:[\s\S]*?--(~)?\}\})/,
/^(?:\()/,
/^(?:\))/,
/^(?:\{\{\{\{)/,
/^(?:\}\}\}\})/,
/^(?:\{\{(~)?>)/,
/^(?:\{\{(~)?#>)/,
/^(?:\{\{(~)?#\*?)/,
/^(?:\{\{(~)?\/)/,
/^(?:\{\{(~)?\^\s*(~)?\}\})/,
/^(?:\{\{(~)?\s*else\s*(~)?\}\})/,
/^(?:\{\{(~)?\^)/,
/^(?:\{\{(~)?\s*else\b)/,
/^(?:\{\{(~)?\{)/,
/^(?:\{\{(~)?&)/,
/^(?:\{\{(~)?!--)/,
/^(?:\{\{(~)?![\s\S]*?\}\})/,
/^(?:\{\{(~)?\*?)/,
/^(?:=)/,
/^(?:\.\.)/,
/^(?:\.(?=([=~}\s\/.)|])))/,
/^(?:[\/.])/,
/^(?:\s+)/,
/^(?:\}(~)?\}\})/,
/^(?:(~)?\}\})/,
/^(?:"(\\["]|[^"])*")/,
/^(?:'(\\[']|[^'])*')/,
/^(?:@)/,
/^(?:true(?=([~}\s)])))/,
/^(?:false(?=([~}\s)])))/,
/^(?:undefined(?=([~}\s)])))/,
/^(?:null(?=([~}\s)])))/,
/^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/,
/^(?:as\s+\|)/,
/^(?:\|)/,
/^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)|]))))/,
/^(?:\[(\\\]|[^\]])*\])/,
/^(?:.)/,
/^(?:$)/,
],
conditions: {
mu: {
rules: [
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44,
],
inclusive: !1,
},
emu: { rules: [2], inclusive: !1 },
com: { rules: [6], inclusive: !1 },
raw: { rules: [3, 4, 5], inclusive: !1 },
INITIAL: { rules: [0, 1, 44], inclusive: !0 },
},
};
return it;
})();
_e.lexer = Ms;
function Oe() {
this.yy = {};
}
return (Oe.prototype = _e), (_e.Parser = Oe), new Oe();
})(),
Se = Fn;
var er = [
'description',
'fileName',
'lineNumber',
'endLineNumber',
'message',
'name',
'number',
'stack',
];
function rr(e, t) {
var r = t && t.loc,
s,
n,
i,
a;
r &&
((s = r.start.line),
(n = r.end.line),
(i = r.start.column),
(a = r.end.column),
(e += ' - ' + s + ':' + i));
for (
var o = Error.prototype.constructor.call(this, e), c = 0;
c < er.length;
c++
)
this[er[c]] = o[er[c]];
Error.captureStackTrace && Error.captureStackTrace(this, rr);
try {
r &&
((this.lineNumber = s),
(this.endLineNumber = n),
Object.defineProperty ?
(Object.defineProperty(this, 'column', { value: i, enumerable: !0 }),
Object.defineProperty(this, 'endColumn', { value: a, enumerable: !0 }))
: ((this.column = i), (this.endColumn = a)));
} catch {}
}
rr.prototype = new Error();
var ot = rr;
function ve() {
this.parents = [];
}
ve.prototype = {
constructor: ve,
mutating: !1,
acceptKey: function (e, t) {
var r = this.accept(e[t]);
if (this.mutating) {
if (r && !ve.prototype[r.type])
throw new ot(
'Unexpected node type "' +
r.type +
'" found when accepting ' +
t +
' on ' +
e.type
);
e[t] = r;
}
},
acceptRequired: function (e, t) {
if ((this.acceptKey(e, t), !e[t])) throw new ot(e.type + ' requires ' + t);
},
acceptArray: function (e) {
for (var t = 0, r = e.length; t < r; t++)
this.acceptKey(e, t), e[t] || (e.splice(t, 1), t--, r--);
},
accept: function (e) {
if (e) {
if (!this[e.type]) throw new ot('Unknown type: ' + e.type, e);
this.current && this.parents.unshift(this.current), (this.current = e);
var t = this[e.type](e);
if (((this.current = this.parents.shift()), !this.mutating || t))
return t;
if (t !== !1) return e;
}
},
Program: function (e) {
this.acceptArray(e.body);
},
MustacheStatement: Ee,
Decorator: Ee,
BlockStatement: gs,
DecoratorBlock: gs,
PartialStatement: bs,
PartialBlockStatement: function (e) {
bs.call(this, e), this.acceptKey(e, 'program');
},
ContentStatement: function () {},
CommentStatement: function () {},
SubExpression: Ee,
PathExpression: function () {},
StringLiteral: function () {},
NumberLiteral: function () {},
BooleanLiteral: function () {},
UndefinedLiteral: function () {},
NullLiteral: function () {},
Hash: function (e) {
this.acceptArray(e.pairs);
},
HashPair: function (e) {
this.acceptRequired(e, 'value');
},
};
function Ee(e) {
this.acceptRequired(e, 'path'),
this.acceptArray(e.params),
this.acceptKey(e, 'hash');
}
function gs(e) {
Ee.call(this, e), this.acceptKey(e, 'program'), this.acceptKey(e, 'inverse');
}
function bs(e) {
this.acceptRequired(e, 'name'),
this.acceptArray(e.params),
this.acceptKey(e, 'hash');
}
var ys = ve;
function Q(e) {
e === void 0 && (e = {}), (this.options = e);
}
Q.prototype = new ys();
Q.prototype.Program = function (e) {
var t = !this.options.ignoreStandalone,
r = !this.isRootSeen;
this.isRootSeen = !0;
for (var s = e.body, n = 0, i = s.length; n < i; n++) {
var a = s[n],
o = this.accept(a);
if (o) {
var c = sr(s, n, r),
h = nr(s, n, r),
p = o.openStandalone && c,
m = o.closeStandalone && h,
S = o.inlineStandalone && c && h;
o.close && vt(s, n, !0),
o.open && lt(s, n, !0),
t &&
S &&
(vt(s, n),
lt(s, n) &&
a.type === 'PartialStatement' &&
(a.indent = /([ \t]+$)/.exec(s[n - 1].original)[1])),
t && p && (vt((a.program || a.inverse).body), lt(s, n)),
t && m && (vt(s, n), lt((a.inverse || a.program).body));
}
}
return e;
};
Q.prototype.BlockStatement =
Q.prototype.DecoratorBlock =
Q.prototype.PartialBlockStatement =
function (e) {
this.accept(e.program), this.accept(e.inverse);
var t = e.program || e.inverse,
r = e.program && e.inverse,
s = r,
n = r;
if (r && r.chained)
for (s = r.body[0].program; n.chained; )
n = n.body[n.body.length - 1].program;
var i = {
open: e.openStrip.open,
close: e.closeStrip.close,
openStandalone: nr(t.body),
closeStandalone: sr((s || t).body),
};
if ((e.openStrip.close && vt(t.body, null, !0), r)) {
var a = e.inverseStrip;
a.open && lt(t.body, null, !0),
a.close && vt(s.body, null, !0),
e.closeStrip.open && lt(n.body, null, !0),
!this.options.ignoreStandalone &&
sr(t.body) &&
nr(s.body) &&
(lt(t.body), vt(s.body));
} else e.closeStrip.open && lt(t.body, null, !0);
return i;
};
Q.prototype.Decorator = Q.prototype.MustacheStatement = function (e) {
return e.strip;
};
Q.prototype.PartialStatement = Q.prototype.CommentStatement = function (e) {
var t = e.strip || {};
return { inlineStandalone: !0, open: t.open, close: t.close };
};
function sr(e, t, r) {
t === void 0 && (t = e.length);
var s = e[t - 1],
n = e[t - 2];
if (!s) return r;
if (s.type === 'ContentStatement')
return (n || !r ? /\r?\n\s*?$/ : /(^|\r?\n)\s*?$/).test(s.original);
}
function nr(e, t, r) {
t === void 0 && (t = -1);
var s = e[t + 1],
n = e[t + 2];
if (!s) return r;
if (s.type === 'ContentStatement')
return (n || !r ? /^\s*?\r?\n/ : /^\s*?(\r?\n|$)/).test(s.original);
}
function vt(e, t, r) {
var s = e[t == null ? 0 : t + 1];
if (!(!s || s.type !== 'ContentStatement' || (!r && s.rightStripped))) {
var n = s.value;
(s.value = s.value.replace(r ? /^\s+/ : /^[ \t]*\r?\n?/, '')),
(s.rightStripped = s.value !== n);
}
}
function lt(e, t, r) {
var s = e[t == null ? e.length - 1 : t - 1];
if (!(!s || s.type !== 'ContentStatement' || (!r && s.leftStripped))) {
var n = s.value;
return (
(s.value = s.value.replace(r ? /\s+$/ : /[ \t]+$/, '')),
(s.leftStripped = s.value !== n),
s.leftStripped
);
}
}
var ks = Q;
var ne = {};
Fe(ne, {
SourceLocation: () => ar,
id: () => Hn,
prepareBlock: () => Kn,
prepareMustache: () => Yn,
preparePartialBlock: () => jn,
preparePath: () => zn,
prepareProgram: () => Wn,
prepareRawBlock: () => Gn,
stripComment: () => Mn,
stripFlags: () => Un,
});
function ir(e, t) {
if (((t = t.path ? t.path.original : t), e.path.original !== t)) {
var r = { loc: e.path.loc };
throw new ot(e.path.original + " doesn't match " + t, r);
}
}
function ar(e, t) {
(this.source = e),
(this.start = { line: t.first_line, column: t.first_column }),
(this.end = { line: t.last_line, column: t.last_column });
}
function Hn(e) {
return /^\[.*\]$/.test(e) ? e.substring(1, e.length - 1) : e;
}
function Un(e, t) {
return { open: e.charAt(2) === '~', close: t.charAt(t.length - 3) === '~' };
}
function Mn(e) {
return e.replace(/^\{\{~?!-?-?/, '').replace(/-?-?~?\}\}$/, '');
}
function zn(e, t, r) {
r = this.locInfo(r);
for (var s = e ? '@' : '', n = [], i = 0, a = 0, o = t.length; a < o; a++) {
var c = t[a].part,
h = t[a].original !== c;
if (
((s += (t[a].separator || '') + c),
!h && (c === '..' || c === '.' || c === 'this'))
) {
if (n.length > 0) throw new ot('Invalid path: ' + s, { loc: r });
c === '..' && i++;
} else n.push(c);
}
return {
type: 'PathExpression',
data: e,
depth: i,
parts: n,
original: s,
loc: r,
};
}
function Yn(e, t, r, s, n, i) {
var a = s.charAt(3) || s.charAt(2),
o = a !== '{' && a !== '&',
c = /\*/.test(s);
return {
type: c ? 'Decorator' : 'MustacheStatement',
path: e,
params: t,
hash: r,
escaped: o,
strip: n,
loc: this.locInfo(i),
};
}
function Gn(e, t, r, s) {
ir(e, r), (s = this.locInfo(s));
var n = { type: 'Program', body: t, strip: {}, loc: s };
return {
type: 'BlockStatement',
path: e.path,
params: e.params,
hash: e.hash,
program: n,
openStrip: {},
inverseStrip: {},
closeStrip: {},
loc: s,
};
}
function Kn(e, t, r, s, n, i) {
s && s.path && ir(e, s);
var a = /\*/.test(e.open);
t.blockParams = e.blockParams;
var o, c;
if (r) {
if (a) throw new ot('Unexpected inverse block on decorator', r);
r.chain && (r.program.body[0].closeStrip = s.strip),
(c = r.strip),
(o = r.program);
}
return (
n && ((n = o), (o = t), (t = n)),
{
type: a ? 'DecoratorBlock' : 'BlockStatement',
path: e.path,
params: e.params,
hash: e.hash,
program: t,
inverse: o,
openStrip: e.strip,
inverseStrip: c,
closeStrip: s && s.strip,
loc: this.locInfo(i),
}
);
}
function Wn(e, t) {
if (!t && e.length) {
var r = e[0].loc,
s = e[e.length - 1].loc;
r &&
s &&
(t = {
source: r.source,
start: { line: r.start.line, column: r.start.column },
end: { line: s.end.line, column: s.end.column },
});
}
return { type: 'Program', body: e, strip: {}, loc: t };
}
function jn(e, t, r, s) {
return (
ir(e, r),
{
type: 'PartialBlockStatement',
name: e.path,
params: e.params,
hash: e.hash,
program: t,
openStrip: e.strip,
closeStrip: r && r.strip,
loc: this.locInfo(s),
}
);
}
var Ss = {};
for (we in ne)
Object.prototype.hasOwnProperty.call(ne, we) && (Ss[we] = ne[we]);
var we;
function Te(e, t) {
if (e.type === 'Program') return e;
(Se.yy = Ss),
(Se.yy.locInfo = function (s) {
return new ar(t && t.srcName, s);
});
var r = Se.parse(e);
return r;
}
function or(e, t) {
var r = Te(e, t),
s = new ks(t);
return s.accept(r);
}
var Es = {
Aacute: '\xC1',
aacute: '\xE1',
Abreve: '\u0102',
abreve: '\u0103',
ac: '\u223E',
acd: '\u223F',
acE: '\u223E\u0333',
Acirc: '\xC2',
acirc: '\xE2',
acute: '\xB4',
Acy: '\u0410',
acy: '\u0430',
AElig: '\xC6',
aelig: '\xE6',
af: '\u2061',
Afr: '\u{1D504}',
afr: '\u{1D51E}',
Agrave: '\xC0',
agrave: '\xE0',
alefsym: '\u2135',
aleph: '\u2135',
Alpha: '\u0391',
alpha: '\u03B1',
Amacr: '\u0100',
amacr: '\u0101',
amalg: '\u2A3F',
amp: '&',
AMP: '&',
andand: '\u2A55',
And: '\u2A53',
and: '\u2227',
andd: '\u2A5C',
andslope: '\u2A58',
andv: '\u2A5A',
ang: '\u2220',
ange: '\u29A4',
angle: '\u2220',
angmsdaa: '\u29A8',
angmsdab: '\u29A9',
angmsdac: '\u29AA',
angmsdad: '\u29AB',
angmsdae: '\u29AC',
angmsdaf: '\u29AD',
angmsdag: '\u29AE',
angmsdah: '\u29AF',
angmsd: '\u2221',
angrt: '\u221F',
angrtvb: '\u22BE',
angrtvbd: '\u299D',
angsph: '\u2222',
angst: '\xC5',
angzarr: '\u237C',
Aogon: '\u0104',
aogon: '\u0105',
Aopf: '\u{1D538}',
aopf: '\u{1D552}',
apacir: '\u2A6F',
ap: '\u2248',
apE: '\u2A70',
ape: '\u224A',
apid: '\u224B',
apos: "'",
ApplyFunction: '\u2061',
approx: '\u2248',
approxeq: '\u224A',
Aring: '\xC5',
aring: '\xE5',
Ascr: '\u{1D49C}',
ascr: '\u{1D4B6}',
Assign: '\u2254',
ast: '*',
asymp: '\u2248',
asympeq: '\u224D',
Atilde: '\xC3',
atilde: '\xE3',
Auml: '\xC4',
auml: '\xE4',
awconint: '\u2233',
awint: '\u2A11',
backcong: '\u224C',
backepsilon: '\u03F6',
backprime: '\u2035',
backsim: '\u223D',
backsimeq: '\u22CD',
Backslash: '\u2216',
Barv: '\u2AE7',
barvee: '\u22BD',
barwed: '\u2305',
Barwed: '\u2306',
barwedge: '\u2305',
bbrk: '\u23B5',
bbrktbrk: '\u23B6',
bcong: '\u224C',
Bcy: '\u0411',
bcy: '\u0431',
bdquo: '\u201E',
becaus: '\u2235',
because: '\u2235',
Because: '\u2235',
bemptyv: '\u29B0',
bepsi: '\u03F6',
bernou: '\u212C',
Bernoullis: '\u212C',
Beta: '\u0392',
beta: '\u03B2',
beth: '\u2136',
between: '\u226C',
Bfr: '\u{1D505}',
bfr: '\u{1D51F}',
bigcap: '\u22C2',
bigcirc: '\u25EF',
bigcup: '\u22C3',
bigodot: '\u2A00',
bigoplus: '\u2A01',
bigotimes: '\u2A02',
bigsqcup: '\u2A06',
bigstar: '\u2605',
bigtriangledown: '\u25BD',
bigtriangleup: '\u25B3',
biguplus: '\u2A04',
bigvee: '\u22C1',
bigwedge: '\u22C0',
bkarow: '\u290D',
blacklozenge: '\u29EB',
blacksquare: '\u25AA',
blacktriangle: '\u25B4',
blacktriangledown: '\u25BE',
blacktriangleleft: '\u25C2',
blacktriangleright: '\u25B8',
blank: '\u2423',
blk12: '\u2592',
blk14: '\u2591',
blk34: '\u2593',
block: '\u2588',
bne: '=\u20E5',
bnequiv: '\u2261\u20E5',
bNot: '\u2AED',
bnot: '\u2310',
Bopf: '\u{1D539}',
bopf: '\u{1D553}',
bot: '\u22A5',
bottom: '\u22A5',
bowtie: '\u22C8',
boxbox: '\u29C9',
boxdl: '\u2510',
boxdL: '\u2555',
boxDl: '\u2556',
boxDL: '\u2557',
boxdr: '\u250C',
boxdR: '\u2552',
boxDr: '\u2553',
boxDR: '\u2554',
boxh: '\u2500',
boxH: '\u2550',
boxhd: '\u252C',
boxHd: '\u2564',
boxhD: '\u2565',
boxHD: '\u2566',
boxhu: '\u2534',
boxHu: '\u2567',
boxhU: '\u2568',
boxHU: '\u2569',
boxminus: '\u229F',
boxplus: '\u229E',
boxtimes: '\u22A0',
boxul: '\u2518',
boxuL: '\u255B',
boxUl: '\u255C',
boxUL: '\u255D',
boxur: '\u2514',
boxuR: '\u2558',
boxUr: '\u2559',
boxUR: '\u255A',
boxv: '\u2502',
boxV: '\u2551',
boxvh: '\u253C',
boxvH: '\u256A',
boxVh: '\u256B',
boxVH: '\u256C',
boxvl: '\u2524',
boxvL: '\u2561',
boxVl: '\u2562',
boxVL: '\u2563',
boxvr: '\u251C',
boxvR: '\u255E',
boxVr: '\u255F',
boxVR: '\u2560',
bprime: '\u2035',
breve: '\u02D8',
Breve: '\u02D8',
brvbar: '\xA6',
bscr: '\u{1D4B7}',
Bscr: '\u212C',
bsemi: '\u204F',
bsim: '\u223D',
bsime: '\u22CD',
bsolb: '\u29C5',
bsol: '\\',
bsolhsub: '\u27C8',
bull: '\u2022',
bullet: '\u2022',
bump: '\u224E',
bumpE: '\u2AAE',
bumpe: '\u224F',
Bumpeq: '\u224E',
bumpeq: '\u224F',
Cacute: '\u0106',
cacute: '\u0107',
capand: '\u2A44',
capbrcup: '\u2A49',
capcap: '\u2A4B',
cap: '\u2229',
Cap: '\u22D2',
capcup: '\u2A47',
capdot: '\u2A40',
CapitalDifferentialD: '\u2145',
caps: '\u2229\uFE00',
caret: '\u2041',
caron: '\u02C7',
Cayleys: '\u212D',
ccaps: '\u2A4D',
Ccaron: '\u010C',
ccaron: '\u010D',
Ccedil: '\xC7',
ccedil: '\xE7',
Ccirc: '\u0108',
ccirc: '\u0109',
Cconint: '\u2230',
ccups: '\u2A4C',
ccupssm: '\u2A50',
Cdot: '\u010A',
cdot: '\u010B',
cedil: '\xB8',
Cedilla: '\xB8',
cemptyv: '\u29B2',
cent: '\xA2',
centerdot: '\xB7',
CenterDot: '\xB7',
cfr: '\u{1D520}',
Cfr: '\u212D',
CHcy: '\u0427',
chcy: '\u0447',
check: '\u2713',
checkmark: '\u2713',
Chi: '\u03A7',
chi: '\u03C7',
circ: '\u02C6',
circeq: '\u2257',
circlearrowleft: '\u21BA',
circlearrowright: '\u21BB',
circledast: '\u229B',
circledcirc: '\u229A',
circleddash: '\u229D',
CircleDot: '\u2299',
circledR: '\xAE',
circledS: '\u24C8',
CircleMinus: '\u2296',
CirclePlus: '\u2295',
CircleTimes: '\u2297',
cir: '\u25CB',
cirE: '\u29C3',
cire: '\u2257',
cirfnint: '\u2A10',
cirmid: '\u2AEF',
cirscir: '\u29C2',
ClockwiseContourIntegral: '\u2232',
CloseCurlyDoubleQuote: '\u201D',
CloseCurlyQuote: '\u2019',
clubs: '\u2663',
clubsuit: '\u2663',
colon: ':',
Colon: '\u2237',
Colone: '\u2A74',
colone: '\u2254',
coloneq: '\u2254',
comma: ',',
commat: '@',
comp: '\u2201',
compfn: '\u2218',
complement: '\u2201',
complexes: '\u2102',
cong: '\u2245',
congdot: '\u2A6D',
Congruent: '\u2261',
conint: '\u222E',
Conint: '\u222F',
ContourIntegral: '\u222E',
copf: '\u{1D554}',
Copf: '\u2102',
coprod: '\u2210',
Coproduct: '\u2210',
copy: '\xA9',
COPY: '\xA9',
copysr: '\u2117',
CounterClockwiseContourIntegral: '\u2233',
crarr: '\u21B5',
cross: '\u2717',
Cross: '\u2A2F',
Cscr: '\u{1D49E}',
cscr: '\u{1D4B8}',
csub: '\u2ACF',
csube: '\u2AD1',
csup: '\u2AD0',
csupe: '\u2AD2',
ctdot: '\u22EF',
cudarrl: '\u2938',
cudarrr: '\u2935',
cuepr: '\u22DE',
cuesc: '\u22DF',
cularr: '\u21B6',
cularrp: '\u293D',
cupbrcap: '\u2A48',
cupcap: '\u2A46',
CupCap: '\u224D',
cup: '\u222A',
Cup: '\u22D3',
cupcup: '\u2A4A',
cupdot: '\u228D',
cupor: '\u2A45',
cups: '\u222A\uFE00',
curarr: '\u21B7',
curarrm: '\u293C',
curlyeqprec: '\u22DE',
curlyeqsucc: '\u22DF',
curlyvee: '\u22CE',
curlywedge: '\u22CF',
curren: '\xA4',
curvearrowleft: '\u21B6',
curvearrowright: '\u21B7',
cuvee: '\u22CE',
cuwed: '\u22CF',
cwconint: '\u2232',
cwint: '\u2231',
cylcty: '\u232D',
dagger: '\u2020',
Dagger: '\u2021',
daleth: '\u2138',
darr: '\u2193',
Darr: '\u21A1',
dArr: '\u21D3',
dash: '\u2010',
Dashv: '\u2AE4',
dashv: '\u22A3',
dbkarow: '\u290F',
dblac: '\u02DD',
Dcaron: '\u010E',
dcaron: '\u010F',
Dcy: '\u0414',
dcy: '\u0434',
ddagger: '\u2021',
ddarr: '\u21CA',
DD: '\u2145',
dd: '\u2146',
DDotrahd: '\u2911',
ddotseq: '\u2A77',
deg: '\xB0',
Del: '\u2207',
Delta: '\u0394',
delta: '\u03B4',
demptyv: '\u29B1',
dfisht: '\u297F',
Dfr: '\u{1D507}',
dfr: '\u{1D521}',
dHar: '\u2965',
dharl: '\u21C3',
dharr: '\u21C2',
DiacriticalAcute: '\xB4',
DiacriticalDot: '\u02D9',
DiacriticalDoubleAcute: '\u02DD',
DiacriticalGrave: '`',
DiacriticalTilde: '\u02DC',
diam: '\u22C4',
diamond: '\u22C4',
Diamond: '\u22C4',
diamondsuit: '\u2666',
diams: '\u2666',
die: '\xA8',
DifferentialD: '\u2146',
digamma: '\u03DD',
disin: '\u22F2',
div: '\xF7',
divide: '\xF7',
divideontimes: '\u22C7',
divonx: '\u22C7',
DJcy: '\u0402',
djcy: '\u0452',
dlcorn: '\u231E',
dlcrop: '\u230D',
dollar: '$',
Dopf: '\u{1D53B}',
dopf: '\u{1D555}',
Dot: '\xA8',
dot: '\u02D9',
DotDot: '\u20DC',
doteq: '\u2250',
doteqdot: '\u2251',
DotEqual: '\u2250',
dotminus: '\u2238',
dotplus: '\u2214',
dotsquare: '\u22A1',
doublebarwedge: '\u2306',
DoubleContourIntegral: '\u222F',
DoubleDot: '\xA8',
DoubleDownArrow: '\u21D3',
DoubleLeftArrow: '\u21D0',
DoubleLeftRightArrow: '\u21D4',
DoubleLeftTee: '\u2AE4',
DoubleLongLeftArrow: '\u27F8',
DoubleLongLeftRightArrow: '\u27FA',
DoubleLongRightArrow: '\u27F9',
DoubleRightArrow: '\u21D2',
DoubleRightTee: '\u22A8',
DoubleUpArrow: '\u21D1',
DoubleUpDownArrow: '\u21D5',
DoubleVerticalBar: '\u2225',
DownArrowBar: '\u2913',
downarrow: '\u2193',
DownArrow: '\u2193',
Downarrow: '\u21D3',
DownArrowUpArrow: '\u21F5',
DownBreve: '\u0311',
downdownarrows: '\u21CA',
downharpoonleft: '\u21C3',
downharpoonright: '\u21C2',
DownLeftRightVector: '\u2950',
DownLeftTeeVector: '\u295E',
DownLeftVectorBar: '\u2956',
DownLeftVector: '\u21BD',
DownRightTeeVector: '\u295F',
DownRightVectorBar: '\u2957',
DownRightVector: '\u21C1',
DownTeeArrow: '\u21A7',
DownTee: '\u22A4',
drbkarow: '\u2910',
drcorn: '\u231F',
drcrop: '\u230C',
Dscr: '\u{1D49F}',
dscr: '\u{1D4B9}',
DScy: '\u0405',
dscy: '\u0455',
dsol: '\u29F6',
Dstrok: '\u0110',
dstrok: '\u0111',
dtdot: '\u22F1',
dtri: '\u25BF',
dtrif: '\u25BE',
duarr: '\u21F5',
duhar: '\u296F',
dwangle: '\u29A6',
DZcy: '\u040F',
dzcy: '\u045F',
dzigrarr: '\u27FF',
Eacute: '\xC9',
eacute: '\xE9',
easter: '\u2A6E',
Ecaron: '\u011A',
ecaron: '\u011B',
Ecirc: '\xCA',
ecirc: '\xEA',
ecir: '\u2256',
ecolon: '\u2255',
Ecy: '\u042D',
ecy: '\u044D',
eDDot: '\u2A77',
Edot: '\u0116',
edot: '\u0117',
eDot: '\u2251',
ee: '\u2147',
efDot: '\u2252',
Efr: '\u{1D508}',
efr: '\u{1D522}',
eg: '\u2A9A',
Egrave: '\xC8',
egrave: '\xE8',
egs: '\u2A96',
egsdot: '\u2A98',
el: '\u2A99',
Element: '\u2208',
elinters: '\u23E7',
ell: '\u2113',
els: '\u2A95',
elsdot: '\u2A97',
Emacr: '\u0112',
emacr: '\u0113',
empty: '\u2205',
emptyset: '\u2205',
EmptySmallSquare: '\u25FB',
emptyv: '\u2205',
EmptyVerySmallSquare: '\u25AB',
emsp13: '\u2004',
emsp14: '\u2005',
emsp: '\u2003',
ENG: '\u014A',
eng: '\u014B',
ensp: '\u2002',
Eogon: '\u0118',
eogon: '\u0119',
Eopf: '\u{1D53C}',
eopf: '\u{1D556}',
epar: '\u22D5',
eparsl: '\u29E3',
eplus: '\u2A71',
epsi: '\u03B5',
Epsilon: '\u0395',
epsilon: '\u03B5',
epsiv: '\u03F5',
eqcirc: '\u2256',
eqcolon: '\u2255',
eqsim: '\u2242',
eqslantgtr: '\u2A96',
eqslantless: '\u2A95',
Equal: '\u2A75',
equals: '=',
EqualTilde: '\u2242',
equest: '\u225F',
Equilibrium: '\u21CC',
equiv: '\u2261',
equivDD: '\u2A78',
eqvparsl: '\u29E5',
erarr: '\u2971',
erDot: '\u2253',
escr: '\u212F',
Escr: '\u2130',
esdot: '\u2250',
Esim: '\u2A73',
esim: '\u2242',
Eta: '\u0397',
eta: '\u03B7',
ETH: '\xD0',
eth: '\xF0',
Euml: '\xCB',
euml: '\xEB',
euro: '\u20AC',
excl: '!',
exist: '\u2203',
Exists: '\u2203',
expectation: '\u2130',
exponentiale: '\u2147',
ExponentialE: '\u2147',
fallingdotseq: '\u2252',
Fcy: '\u0424',
fcy: '\u0444',
female: '\u2640',
ffilig: '\uFB03',
fflig: '\uFB00',
ffllig: '\uFB04',
Ffr: '\u{1D509}',
ffr: '\u{1D523}',
filig: '\uFB01',
FilledSmallSquare: '\u25FC',
FilledVerySmallSquare: '\u25AA',
fjlig: 'fj',
flat: '\u266D',
fllig: '\uFB02',
fltns: '\u25B1',
fnof: '\u0192',
Fopf: '\u{1D53D}',
fopf: '\u{1D557}',
forall: '\u2200',
ForAll: '\u2200',
fork: '\u22D4',
forkv: '\u2AD9',
Fouriertrf: '\u2131',
fpartint: '\u2A0D',
frac12: '\xBD',
frac13: '\u2153',
frac14: '\xBC',
frac15: '\u2155',
frac16: '\u2159',
frac18: '\u215B',
frac23: '\u2154',
frac25: '\u2156',
frac34: '\xBE',
frac35: '\u2157',
frac38: '\u215C',
frac45: '\u2158',
frac56: '\u215A',
frac58: '\u215D',
frac78: '\u215E',
frasl: '\u2044',
frown: '\u2322',
fscr: '\u{1D4BB}',
Fscr: '\u2131',
gacute: '\u01F5',
Gamma: '\u0393',
gamma: '\u03B3',
Gammad: '\u03DC',
gammad: '\u03DD',
gap: '\u2A86',
Gbreve: '\u011E',
gbreve: '\u011F',
Gcedil: '\u0122',
Gcirc: '\u011C',
gcirc: '\u011D',
Gcy: '\u0413',
gcy: '\u0433',
Gdot: '\u0120',
gdot: '\u0121',
ge: '\u2265',
gE: '\u2267',
gEl: '\u2A8C',
gel: '\u22DB',
geq: '\u2265',
geqq: '\u2267',
geqslant: '\u2A7E',
gescc: '\u2AA9',
ges: '\u2A7E',
gesdot: '\u2A80',
gesdoto: '\u2A82',
gesdotol: '\u2A84',
gesl: '\u22DB\uFE00',
gesles: '\u2A94',
Gfr: '\u{1D50A}',
gfr: '\u{1D524}',
gg: '\u226B',
Gg: '\u22D9',
ggg: '\u22D9',
gimel: '\u2137',
GJcy: '\u0403',
gjcy: '\u0453',
gla: '\u2AA5',
gl: '\u2277',
glE: '\u2A92',
glj: '\u2AA4',
gnap: '\u2A8A',
gnapprox: '\u2A8A',
gne: '\u2A88',
gnE: '\u2269',
gneq: '\u2A88',
gneqq: '\u2269',
gnsim: '\u22E7',
Gopf: '\u{1D53E}',
gopf: '\u{1D558}',
grave: '`',
GreaterEqual: '\u2265',
GreaterEqualLess: '\u22DB',
GreaterFullEqual: '\u2267',
GreaterGreater: '\u2AA2',
GreaterLess: '\u2277',
GreaterSlantEqual: '\u2A7E',
GreaterTilde: '\u2273',
Gscr: '\u{1D4A2}',
gscr: '\u210A',
gsim: '\u2273',
gsime: '\u2A8E',
gsiml: '\u2A90',
gtcc: '\u2AA7',
gtcir: '\u2A7A',
gt: '>',
GT: '>',
Gt: '\u226B',
gtdot: '\u22D7',
gtlPar: '\u2995',
gtquest: '\u2A7C',
gtrapprox: '\u2A86',
gtrarr: '\u2978',
gtrdot: '\u22D7',
gtreqless: '\u22DB',
gtreqqless: '\u2A8C',
gtrless: '\u2277',
gtrsim: '\u2273',
gvertneqq: '\u2269\uFE00',
gvnE: '\u2269\uFE00',
Hacek: '\u02C7',
hairsp: '\u200A',
half: '\xBD',
hamilt: '\u210B',
HARDcy: '\u042A',
hardcy: '\u044A',
harrcir: '\u2948',
harr: '\u2194',
hArr: '\u21D4',
harrw: '\u21AD',
Hat: '^',
hbar: '\u210F',
Hcirc: '\u0124',
hcirc: '\u0125',
hearts: '\u2665',
heartsuit: '\u2665',
hellip: '\u2026',
hercon: '\u22B9',
hfr: '\u{1D525}',
Hfr: '\u210C',
HilbertSpace: '\u210B',
hksearow: '\u2925',
hkswarow: '\u2926',
hoarr: '\u21FF',
homtht: '\u223B',
hookleftarrow: '\u21A9',
hookrightarrow: '\u21AA',
hopf: '\u{1D559}',
Hopf: '\u210D',
horbar: '\u2015',
HorizontalLine: '\u2500',
hscr: '\u{1D4BD}',
Hscr: '\u210B',
hslash: '\u210F',
Hstrok: '\u0126',
hstrok: '\u0127',
HumpDownHump: '\u224E',
HumpEqual: '\u224F',
hybull: '\u2043',
hyphen: '\u2010',
Iacute: '\xCD',
iacute: '\xED',
ic: '\u2063',
Icirc: '\xCE',
icirc: '\xEE',
Icy: '\u0418',
icy: '\u0438',
Idot: '\u0130',
IEcy: '\u0415',
iecy: '\u0435',
iexcl: '\xA1',
iff: '\u21D4',
ifr: '\u{1D526}',
Ifr: '\u2111',
Igrave: '\xCC',
igrave: '\xEC',
ii: '\u2148',
iiiint: '\u2A0C',
iiint: '\u222D',
iinfin: '\u29DC',
iiota: '\u2129',
IJlig: '\u0132',
ijlig: '\u0133',
Imacr: '\u012A',
imacr: '\u012B',
image: '\u2111',
ImaginaryI: '\u2148',
imagline: '\u2110',
imagpart: '\u2111',
imath: '\u0131',
Im: '\u2111',
imof: '\u22B7',
imped: '\u01B5',
Implies: '\u21D2',
incare: '\u2105',
in: '\u2208',
infin: '\u221E',
infintie: '\u29DD',
inodot: '\u0131',
intcal: '\u22BA',
int: '\u222B',
Int: '\u222C',
integers: '\u2124',
Integral: '\u222B',
intercal: '\u22BA',
Intersection: '\u22C2',
intlarhk: '\u2A17',
intprod: '\u2A3C',
InvisibleComma: '\u2063',
InvisibleTimes: '\u2062',
IOcy: '\u0401',
iocy: '\u0451',
Iogon: '\u012E',
iogon: '\u012F',
Iopf: '\u{1D540}',
iopf: '\u{1D55A}',
Iota: '\u0399',
iota: '\u03B9',
iprod: '\u2A3C',
iquest: '\xBF',
iscr: '\u{1D4BE}',
Iscr: '\u2110',
isin: '\u2208',
isindot: '\u22F5',
isinE: '\u22F9',
isins: '\u22F4',
isinsv: '\u22F3',
isinv: '\u2208',
it: '\u2062',
Itilde: '\u0128',
itilde: '\u0129',
Iukcy: '\u0406',
iukcy: '\u0456',
Iuml: '\xCF',
iuml: '\xEF',
Jcirc: '\u0134',
jcirc: '\u0135',
Jcy: '\u0419',
jcy: '\u0439',
Jfr: '\u{1D50D}',
jfr: '\u{1D527}',
jmath: '\u0237',
Jopf: '\u{1D541}',
jopf: '\u{1D55B}',
Jscr: '\u{1D4A5}',
jscr: '\u{1D4BF}',
Jsercy: '\u0408',
jsercy: '\u0458',
Jukcy: '\u0404',
jukcy: '\u0454',
Kappa: '\u039A',
kappa: '\u03BA',
kappav: '\u03F0',
Kcedil: '\u0136',
kcedil: '\u0137',
Kcy: '\u041A',
kcy: '\u043A',
Kfr: '\u{1D50E}',
kfr: '\u{1D528}',
kgreen: '\u0138',
KHcy: '\u0425',
khcy: '\u0445',
KJcy: '\u040C',
kjcy: '\u045C',
Kopf: '\u{1D542}',
kopf: '\u{1D55C}',
Kscr: '\u{1D4A6}',
kscr: '\u{1D4C0}',
lAarr: '\u21DA',
Lacute: '\u0139',
lacute: '\u013A',
laemptyv: '\u29B4',
lagran: '\u2112',
Lambda: '\u039B',
lambda: '\u03BB',
lang: '\u27E8',
Lang: '\u27EA',
langd: '\u2991',
langle: '\u27E8',
lap: '\u2A85',
Laplacetrf: '\u2112',
laquo: '\xAB',
larrb: '\u21E4',
larrbfs: '\u291F',
larr: '\u2190',
Larr: '\u219E',
lArr: '\u21D0',
larrfs: '\u291D',
larrhk: '\u21A9',
larrlp: '\u21AB',
larrpl: '\u2939',
larrsim: '\u2973',
larrtl: '\u21A2',
latail: '\u2919',
lAtail: '\u291B',
lat: '\u2AAB',
late: '\u2AAD',
lates: '\u2AAD\uFE00',
lbarr: '\u290C',
lBarr: '\u290E',
lbbrk: '\u2772',
lbrace: '{',
lbrack: '[',
lbrke: '\u298B',
lbrksld: '\u298F',
lbrkslu: '\u298D',
Lcaron: '\u013D',
lcaron: '\u013E',
Lcedil: '\u013B',
lcedil: '\u013C',
lceil: '\u2308',
lcub: '{',
Lcy: '\u041B',
lcy: '\u043B',
ldca: '\u2936',
ldquo: '\u201C',
ldquor: '\u201E',
ldrdhar: '\u2967',
ldrushar: '\u294B',
ldsh: '\u21B2',
le: '\u2264',
lE: '\u2266',
LeftAngleBracket: '\u27E8',
LeftArrowBar: '\u21E4',
leftarrow: '\u2190',
LeftArrow: '\u2190',
Leftarrow: '\u21D0',
LeftArrowRightArrow: '\u21C6',
leftarrowtail: '\u21A2',
LeftCeiling: '\u2308',
LeftDoubleBracket: '\u27E6',
LeftDownTeeVector: '\u2961',
LeftDownVectorBar: '\u2959',
LeftDownVector: '\u21C3',
LeftFloor: '\u230A',
leftharpoondown: '\u21BD',
leftharpoonup: '\u21BC',
leftleftarrows: '\u21C7',
leftrightarrow: '\u2194',
LeftRightArrow: '\u2194',
Leftrightarrow: '\u21D4',
leftrightarrows: '\u21C6',
leftrightharpoons: '\u21CB',
leftrightsquigarrow: '\u21AD',
LeftRightVector: '\u294E',
LeftTeeArrow: '\u21A4',
LeftTee: '\u22A3',
LeftTeeVector: '\u295A',
leftthreetimes: '\u22CB',
LeftTriangleBar: '\u29CF',
LeftTriangle: '\u22B2',
LeftTriangleEqual: '\u22B4',
LeftUpDownVector: '\u2951',
LeftUpTeeVector: '\u2960',
LeftUpVectorBar: '\u2958',
LeftUpVector: '\u21BF',
LeftVectorBar: '\u2952',
LeftVector: '\u21BC',
lEg: '\u2A8B',
leg: '\u22DA',
leq: '\u2264',
leqq: '\u2266',
leqslant: '\u2A7D',
lescc: '\u2AA8',
les: '\u2A7D',
lesdot: '\u2A7F',
lesdoto: '\u2A81',
lesdotor: '\u2A83',
lesg: '\u22DA\uFE00',
lesges: '\u2A93',
lessapprox: '\u2A85',
lessdot: '\u22D6',
lesseqgtr: '\u22DA',
lesseqqgtr: '\u2A8B',
LessEqualGreater: '\u22DA',
LessFullEqual: '\u2266',
LessGreater: '\u2276',
lessgtr: '\u2276',
LessLess: '\u2AA1',
lesssim: '\u2272',
LessSlantEqual: '\u2A7D',
LessTilde: '\u2272',
lfisht: '\u297C',
lfloor: '\u230A',
Lfr: '\u{1D50F}',
lfr: '\u{1D529}',
lg: '\u2276',
lgE: '\u2A91',
lHar: '\u2962',
lhard: '\u21BD',
lharu: '\u21BC',
lharul: '\u296A',
lhblk: '\u2584',
LJcy: '\u0409',
ljcy: '\u0459',
llarr: '\u21C7',
ll: '\u226A',
Ll: '\u22D8',
llcorner: '\u231E',
Lleftarrow: '\u21DA',
llhard: '\u296B',
lltri: '\u25FA',
Lmidot: '\u013F',
lmidot: '\u0140',
lmoustache: '\u23B0',
lmoust: '\u23B0',
lnap: '\u2A89',
lnapprox: '\u2A89',
lne: '\u2A87',
lnE: '\u2268',
lneq: '\u2A87',
lneqq: '\u2268',
lnsim: '\u22E6',
loang: '\u27EC',
loarr: '\u21FD',
lobrk: '\u27E6',
longleftarrow: '\u27F5',
LongLeftArrow: '\u27F5',
Longleftarrow: '\u27F8',
longleftrightarrow: '\u27F7',
LongLeftRightArrow: '\u27F7',
Longleftrightarrow: '\u27FA',
longmapsto: '\u27FC',
longrightarrow: '\u27F6',
LongRightArrow: '\u27F6',
Longrightarrow: '\u27F9',
looparrowleft: '\u21AB',
looparrowright: '\u21AC',
lopar: '\u2985',
Lopf: '\u{1D543}',
lopf: '\u{1D55D}',
loplus: '\u2A2D',
lotimes: '\u2A34',
lowast: '\u2217',
lowbar: '_',
LowerLeftArrow: '\u2199',
LowerRightArrow: '\u2198',
loz: '\u25CA',
lozenge: '\u25CA',
lozf: '\u29EB',
lpar: '(',
lparlt: '\u2993',
lrarr: '\u21C6',
lrcorner: '\u231F',
lrhar: '\u21CB',
lrhard: '\u296D',
lrm: '\u200E',
lrtri: '\u22BF',
lsaquo: '\u2039',
lscr: '\u{1D4C1}',
Lscr: '\u2112',
lsh: '\u21B0',
Lsh: '\u21B0',
lsim: '\u2272',
lsime: '\u2A8D',
lsimg: '\u2A8F',
lsqb: '[',
lsquo: '\u2018',
lsquor: '\u201A',
Lstrok: '\u0141',
lstrok: '\u0142',
ltcc: '\u2AA6',
ltcir: '\u2A79',
lt: '<',
LT: '<',
Lt: '\u226A',
ltdot: '\u22D6',
lthree: '\u22CB',
ltimes: '\u22C9',
ltlarr: '\u2976',
ltquest: '\u2A7B',
ltri: '\u25C3',
ltrie: '\u22B4',
ltrif: '\u25C2',
ltrPar: '\u2996',
lurdshar: '\u294A',
luruhar: '\u2966',
lvertneqq: '\u2268\uFE00',
lvnE: '\u2268\uFE00',
macr: '\xAF',
male: '\u2642',
malt: '\u2720',
maltese: '\u2720',
Map: '\u2905',
map: '\u21A6',
mapsto: '\u21A6',
mapstodown: '\u21A7',
mapstoleft: '\u21A4',
mapstoup: '\u21A5',
marker: '\u25AE',
mcomma: '\u2A29',
Mcy: '\u041C',
mcy: '\u043C',
mdash: '\u2014',
mDDot: '\u223A',
measuredangle: '\u2221',
MediumSpace: '\u205F',
Mellintrf: '\u2133',
Mfr: '\u{1D510}',
mfr: '\u{1D52A}',
mho: '\u2127',
micro: '\xB5',
midast: '*',
midcir: '\u2AF0',
mid: '\u2223',
middot: '\xB7',
minusb: '\u229F',
minus: '\u2212',
minusd: '\u2238',
minusdu: '\u2A2A',
MinusPlus: '\u2213',
mlcp: '\u2ADB',
mldr: '\u2026',
mnplus: '\u2213',
models: '\u22A7',
Mopf: '\u{1D544}',
mopf: '\u{1D55E}',
mp: '\u2213',
mscr: '\u{1D4C2}',
Mscr: '\u2133',
mstpos: '\u223E',
Mu: '\u039C',
mu: '\u03BC',
multimap: '\u22B8',
mumap: '\u22B8',
nabla: '\u2207',
Nacute: '\u0143',
nacute: '\u0144',
nang: '\u2220\u20D2',
nap: '\u2249',
napE: '\u2A70\u0338',
napid: '\u224B\u0338',
napos: '\u0149',
napprox: '\u2249',
natural: '\u266E',
naturals: '\u2115',
natur: '\u266E',
nbsp: '\xA0',
nbump: '\u224E\u0338',
nbumpe: '\u224F\u0338',
ncap: '\u2A43',
Ncaron: '\u0147',
ncaron: '\u0148',
Ncedil: '\u0145',
ncedil: '\u0146',
ncong: '\u2247',
ncongdot: '\u2A6D\u0338',
ncup: '\u2A42',
Ncy: '\u041D',
ncy: '\u043D',
ndash: '\u2013',
nearhk: '\u2924',
nearr: '\u2197',
neArr: '\u21D7',
nearrow: '\u2197',
ne: '\u2260',
nedot: '\u2250\u0338',
NegativeMediumSpace: '\u200B',
NegativeThickSpace: '\u200B',
NegativeThinSpace: '\u200B',
NegativeVeryThinSpace: '\u200B',
nequiv: '\u2262',
nesear: '\u2928',
nesim: '\u2242\u0338',
NestedGreaterGreater: '\u226B',
NestedLessLess: '\u226A',
NewLine: `
`,
nexist: '\u2204',
nexists: '\u2204',
Nfr: '\u{1D511}',
nfr: '\u{1D52B}',
ngE: '\u2267\u0338',
nge: '\u2271',
ngeq: '\u2271',
ngeqq: '\u2267\u0338',
ngeqslant: '\u2A7E\u0338',
nges: '\u2A7E\u0338',
nGg: '\u22D9\u0338',
ngsim: '\u2275',
nGt: '\u226B\u20D2',
ngt: '\u226F',
ngtr: '\u226F',
nGtv: '\u226B\u0338',
nharr: '\u21AE',
nhArr: '\u21CE',
nhpar: '\u2AF2',
ni: '\u220B',
nis: '\u22FC',
nisd: '\u22FA',
niv: '\u220B',
NJcy: '\u040A',
njcy: '\u045A',
nlarr: '\u219A',
nlArr: '\u21CD',
nldr: '\u2025',
nlE: '\u2266\u0338',
nle: '\u2270',
nleftarrow: '\u219A',
nLeftarrow: '\u21CD',
nleftrightarrow: '\u21AE',
nLeftrightarrow: '\u21CE',
nleq: '\u2270',
nleqq: '\u2266\u0338',
nleqslant: '\u2A7D\u0338',
nles: '\u2A7D\u0338',
nless: '\u226E',
nLl: '\u22D8\u0338',
nlsim: '\u2274',
nLt: '\u226A\u20D2',
nlt: '\u226E',
nltri: '\u22EA',
nltrie: '\u22EC',
nLtv: '\u226A\u0338',
nmid: '\u2224',
NoBreak: '\u2060',
NonBreakingSpace: '\xA0',
nopf: '\u{1D55F}',
Nopf: '\u2115',
Not: '\u2AEC',
not: '\xAC',
NotCongruent: '\u2262',
NotCupCap: '\u226D',
NotDoubleVerticalBar: '\u2226',
NotElement: '\u2209',
NotEqual: '\u2260',
NotEqualTilde: '\u2242\u0338',
NotExists: '\u2204',
NotGreater: '\u226F',
NotGreaterEqual: '\u2271',
NotGreaterFullEqual: '\u2267\u0338',
NotGreaterGreater: '\u226B\u0338',
NotGreaterLess: '\u2279',
NotGreaterSlantEqual: '\u2A7E\u0338',
NotGreaterTilde: '\u2275',
NotHumpDownHump: '\u224E\u0338',
NotHumpEqual: '\u224F\u0338',
notin: '\u2209',
notindot: '\u22F5\u0338',
notinE: '\u22F9\u0338',
notinva: '\u2209',
notinvb: '\u22F7',
notinvc: '\u22F6',
NotLeftTriangleBar: '\u29CF\u0338',
NotLeftTriangle: '\u22EA',
NotLeftTriangleEqual: '\u22EC',
NotLess: '\u226E',
NotLessEqual: '\u2270',
NotLessGreater: '\u2278',
NotLessLess: '\u226A\u0338',
NotLessSlantEqual: '\u2A7D\u0338',
NotLessTilde: '\u2274',
NotNestedGreaterGreater: '\u2AA2\u0338',
NotNestedLessLess: '\u2AA1\u0338',
notni: '\u220C',
notniva: '\u220C',
notnivb: '\u22FE',
notnivc: '\u22FD',
NotPrecedes: '\u2280',
NotPrecedesEqual: '\u2AAF\u0338',
NotPrecedesSlantEqual: '\u22E0',
NotReverseElement: '\u220C',
NotRightTriangleBar: '\u29D0\u0338',
NotRightTriangle: '\u22EB',
NotRightTriangleEqual: '\u22ED',
NotSquareSubset: '\u228F\u0338',
NotSquareSubsetEqual: '\u22E2',
NotSquareSuperset: '\u2290\u0338',
NotSquareSupersetEqual: '\u22E3',
NotSubset: '\u2282\u20D2',
NotSubsetEqual: '\u2288',
NotSucceeds: '\u2281',
NotSucceedsEqual: '\u2AB0\u0338',
NotSucceedsSlantEqual: '\u22E1',
NotSucceedsTilde: '\u227F\u0338',
NotSuperset: '\u2283\u20D2',
NotSupersetEqual: '\u2289',
NotTilde: '\u2241',
NotTildeEqual: '\u2244',
NotTildeFullEqual: '\u2247',
NotTildeTilde: '\u2249',
NotVerticalBar: '\u2224',
nparallel: '\u2226',
npar: '\u2226',
nparsl: '\u2AFD\u20E5',
npart: '\u2202\u0338',
npolint: '\u2A14',
npr: '\u2280',
nprcue: '\u22E0',
nprec: '\u2280',
npreceq: '\u2AAF\u0338',
npre: '\u2AAF\u0338',
nrarrc: '\u2933\u0338',
nrarr: '\u219B',
nrArr: '\u21CF',
nrarrw: '\u219D\u0338',
nrightarrow: '\u219B',
nRightarrow: '\u21CF',
nrtri: '\u22EB',
nrtrie: '\u22ED',
nsc: '\u2281',
nsccue: '\u22E1',
nsce: '\u2AB0\u0338',
Nscr: '\u{1D4A9}',
nscr: '\u{1D4C3}',
nshortmid: '\u2224',
nshortparallel: '\u2226',
nsim: '\u2241',
nsime: '\u2244',
nsimeq: '\u2244',
nsmid: '\u2224',
nspar: '\u2226',
nsqsube: '\u22E2',
nsqsupe: '\u22E3',
nsub: '\u2284',
nsubE: '\u2AC5\u0338',
nsube: '\u2288',
nsubset: '\u2282\u20D2',
nsubseteq: '\u2288',
nsubseteqq: '\u2AC5\u0338',
nsucc: '\u2281',
nsucceq: '\u2AB0\u0338',
nsup: '\u2285',
nsupE: '\u2AC6\u0338',
nsupe: '\u2289',
nsupset: '\u2283\u20D2',
nsupseteq: '\u2289',
nsupseteqq: '\u2AC6\u0338',
ntgl: '\u2279',
Ntilde: '\xD1',
ntilde: '\xF1',
ntlg: '\u2278',
ntriangleleft: '\u22EA',
ntrianglelefteq: '\u22EC',
ntriangleright: '\u22EB',
ntrianglerighteq: '\u22ED',
Nu: '\u039D',
nu: '\u03BD',
num: '#',
numero: '\u2116',
numsp: '\u2007',
nvap: '\u224D\u20D2',
nvdash: '\u22AC',
nvDash: '\u22AD',
nVdash: '\u22AE',
nVDash: '\u22AF',
nvge: '\u2265\u20D2',
nvgt: '>\u20D2',
nvHarr: '\u2904',
nvinfin: '\u29DE',
nvlArr: '\u2902',
nvle: '\u2264\u20D2',
nvlt: '<\u20D2',
nvltrie: '\u22B4\u20D2',
nvrArr: '\u2903',
nvrtrie: '\u22B5\u20D2',
nvsim: '\u223C\u20D2',
nwarhk: '\u2923',
nwarr: '\u2196',
nwArr: '\u21D6',
nwarrow: '\u2196',
nwnear: '\u2927',
Oacute: '\xD3',
oacute: '\xF3',
oast: '\u229B',
Ocirc: '\xD4',
ocirc: '\xF4',
ocir: '\u229A',
Ocy: '\u041E',
ocy: '\u043E',
odash: '\u229D',
Odblac: '\u0150',
odblac: '\u0151',
odiv: '\u2A38',
odot: '\u2299',
odsold: '\u29BC',
OElig: '\u0152',
oelig: '\u0153',
ofcir: '\u29BF',
Ofr: '\u{1D512}',
ofr: '\u{1D52C}',
ogon: '\u02DB',
Ograve: '\xD2',
ograve: '\xF2',
ogt: '\u29C1',
ohbar: '\u29B5',
ohm: '\u03A9',
oint: '\u222E',
olarr: '\u21BA',
olcir: '\u29BE',
olcross: '\u29BB',
oline: '\u203E',
olt: '\u29C0',
Omacr: '\u014C',
omacr: '\u014D',
Omega: '\u03A9',
omega: '\u03C9',
Omicron: '\u039F',
omicron: '\u03BF',
omid: '\u29B6',
ominus: '\u2296',
Oopf: '\u{1D546}',
oopf: '\u{1D560}',
opar: '\u29B7',
OpenCurlyDoubleQuote: '\u201C',
OpenCurlyQuote: '\u2018',
operp: '\u29B9',
oplus: '\u2295',
orarr: '\u21BB',
Or: '\u2A54',
or: '\u2228',
ord: '\u2A5D',
order: '\u2134',
orderof: '\u2134',
ordf: '\xAA',
ordm: '\xBA',
origof: '\u22B6',
oror: '\u2A56',
orslope: '\u2A57',
orv: '\u2A5B',
oS: '\u24C8',
Oscr: '\u{1D4AA}',
oscr: '\u2134',
Oslash: '\xD8',
oslash: '\xF8',
osol: '\u2298',
Otilde: '\xD5',
otilde: '\xF5',
otimesas: '\u2A36',
Otimes: '\u2A37',
otimes: '\u2297',
Ouml: '\xD6',
ouml: '\xF6',
ovbar: '\u233D',
OverBar: '\u203E',
OverBrace: '\u23DE',
OverBracket: '\u23B4',
OverParenthesis: '\u23DC',
para: '\xB6',
parallel: '\u2225',
par: '\u2225',
parsim: '\u2AF3',
parsl: '\u2AFD',
part: '\u2202',
PartialD: '\u2202',
Pcy: '\u041F',
pcy: '\u043F',
percnt: '%',
period: '.',
permil: '\u2030',
perp: '\u22A5',
pertenk: '\u2031',
Pfr: '\u{1D513}',
pfr: '\u{1D52D}',
Phi: '\u03A6',
phi: '\u03C6',
phiv: '\u03D5',
phmmat: '\u2133',
phone: '\u260E',
Pi: '\u03A0',
pi: '\u03C0',
pitchfork: '\u22D4',
piv: '\u03D6',
planck: '\u210F',
planckh: '\u210E',
plankv: '\u210F',
plusacir: '\u2A23',
plusb: '\u229E',
pluscir: '\u2A22',
plus: '+',
plusdo: '\u2214',
plusdu: '\u2A25',
pluse: '\u2A72',
PlusMinus: '\xB1',
plusmn: '\xB1',
plussim: '\u2A26',
plustwo: '\u2A27',
pm: '\xB1',
Poincareplane: '\u210C',
pointint: '\u2A15',
popf: '\u{1D561}',
Popf: '\u2119',
pound: '\xA3',
prap: '\u2AB7',
Pr: '\u2ABB',
pr: '\u227A',
prcue: '\u227C',
precapprox: '\u2AB7',
prec: '\u227A',
preccurlyeq: '\u227C',
Precedes: '\u227A',
PrecedesEqual: '\u2AAF',
PrecedesSlantEqual: '\u227C',
PrecedesTilde: '\u227E',
preceq: '\u2AAF',
precnapprox: '\u2AB9',
precneqq: '\u2AB5',
precnsim: '\u22E8',
pre: '\u2AAF',
prE: '\u2AB3',
precsim: '\u227E',
prime: '\u2032',
Prime: '\u2033',
primes: '\u2119',
prnap: '\u2AB9',
prnE: '\u2AB5',
prnsim: '\u22E8',
prod: '\u220F',
Product: '\u220F',
profalar: '\u232E',
profline: '\u2312',
profsurf: '\u2313',
prop: '\u221D',
Proportional: '\u221D',
Proportion: '\u2237',
propto: '\u221D',
prsim: '\u227E',
prurel: '\u22B0',
Pscr: '\u{1D4AB}',
pscr: '\u{1D4C5}',
Psi: '\u03A8',
psi: '\u03C8',
puncsp: '\u2008',
Qfr: '\u{1D514}',
qfr: '\u{1D52E}',
qint: '\u2A0C',
qopf: '\u{1D562}',
Qopf: '\u211A',
qprime: '\u2057',
Qscr: '\u{1D4AC}',
qscr: '\u{1D4C6}',
quaternions: '\u210D',
quatint: '\u2A16',
quest: '?',
questeq: '\u225F',
quot: '"',
QUOT: '"',
rAarr: '\u21DB',
race: '\u223D\u0331',
Racute: '\u0154',
racute: '\u0155',
radic: '\u221A',
raemptyv: '\u29B3',
rang: '\u27E9',
Rang: '\u27EB',
rangd: '\u2992',
range: '\u29A5',
rangle: '\u27E9',
raquo: '\xBB',
rarrap: '\u2975',
rarrb: '\u21E5',
rarrbfs: '\u2920',
rarrc: '\u2933',
rarr: '\u2192',
Rarr: '\u21A0',
rArr: '\u21D2',
rarrfs: '\u291E',
rarrhk: '\u21AA',
rarrlp: '\u21AC',
rarrpl: '\u2945',
rarrsim: '\u2974',
Rarrtl: '\u2916',
rarrtl: '\u21A3',
rarrw: '\u219D',
ratail: '\u291A',
rAtail: '\u291C',
ratio: '\u2236',
rationals: '\u211A',
rbarr: '\u290D',
rBarr: '\u290F',
RBarr: '\u2910',
rbbrk: '\u2773',
rbrace: '}',
rbrack: ']',
rbrke: '\u298C',
rbrksld: '\u298E',
rbrkslu: '\u2990',
Rcaron: '\u0158',
rcaron: '\u0159',
Rcedil: '\u0156',
rcedil: '\u0157',
rceil: '\u2309',
rcub: '}',
Rcy: '\u0420',
rcy: '\u0440',
rdca: '\u2937',
rdldhar: '\u2969',
rdquo: '\u201D',
rdquor: '\u201D',
rdsh: '\u21B3',
real: '\u211C',
realine: '\u211B',
realpart: '\u211C',
reals: '\u211D',
Re: '\u211C',
rect: '\u25AD',
reg: '\xAE',
REG: '\xAE',
ReverseElement: '\u220B',
ReverseEquilibrium: '\u21CB',
ReverseUpEquilibrium: '\u296F',
rfisht: '\u297D',
rfloor: '\u230B',
rfr: '\u{1D52F}',
Rfr: '\u211C',
rHar: '\u2964',
rhard: '\u21C1',
rharu: '\u21C0',
rharul: '\u296C',
Rho: '\u03A1',
rho: '\u03C1',
rhov: '\u03F1',
RightAngleBracket: '\u27E9',
RightArrowBar: '\u21E5',
rightarrow: '\u2192',
RightArrow: '\u2192',
Rightarrow: '\u21D2',
RightArrowLeftArrow: '\u21C4',
rightarrowtail: '\u21A3',
RightCeiling: '\u2309',
RightDoubleBracket: '\u27E7',
RightDownTeeVector: '\u295D',
RightDownVectorBar: '\u2955',
RightDownVector: '\u21C2',
RightFloor: '\u230B',
rightharpoondown: '\u21C1',
rightharpoonup: '\u21C0',
rightleftarrows: '\u21C4',
rightleftharpoons: '\u21CC',
rightrightarrows: '\u21C9',
rightsquigarrow: '\u219D',
RightTeeArrow: '\u21A6',
RightTee: '\u22A2',
RightTeeVector: '\u295B',
rightthreetimes: '\u22CC',
RightTriangleBar: '\u29D0',
RightTriangle: '\u22B3',
RightTriangleEqual: '\u22B5',
RightUpDownVector: '\u294F',
RightUpTeeVector: '\u295C',
RightUpVectorBar: '\u2954',
RightUpVector: '\u21BE',
RightVectorBar: '\u2953',
RightVector: '\u21C0',
ring: '\u02DA',
risingdotseq: '\u2253',
rlarr: '\u21C4',
rlhar: '\u21CC',
rlm: '\u200F',
rmoustache: '\u23B1',
rmoust: '\u23B1',
rnmid: '\u2AEE',
roang: '\u27ED',
roarr: '\u21FE',
robrk: '\u27E7',
ropar: '\u2986',
ropf: '\u{1D563}',
Ropf: '\u211D',
roplus: '\u2A2E',
rotimes: '\u2A35',
RoundImplies: '\u2970',
rpar: ')',
rpargt: '\u2994',
rppolint: '\u2A12',
rrarr: '\u21C9',
Rrightarrow: '\u21DB',
rsaquo: '\u203A',
rscr: '\u{1D4C7}',
Rscr: '\u211B',
rsh: '\u21B1',
Rsh: '\u21B1',
rsqb: ']',
rsquo: '\u2019',
rsquor: '\u2019',
rthree: '\u22CC',
rtimes: '\u22CA',
rtri: '\u25B9',
rtrie: '\u22B5',
rtrif: '\u25B8',
rtriltri: '\u29CE',
RuleDelayed: '\u29F4',
ruluhar: '\u2968',
rx: '\u211E',
Sacute: '\u015A',
sacute: '\u015B',
sbquo: '\u201A',
scap: '\u2AB8',
Scaron: '\u0160',
scaron: '\u0161',
Sc: '\u2ABC',
sc: '\u227B',
sccue: '\u227D',
sce: '\u2AB0',
scE: '\u2AB4',
Scedil: '\u015E',
scedil: '\u015F',
Scirc: '\u015C',
scirc: '\u015D',
scnap: '\u2ABA',
scnE: '\u2AB6',
scnsim: '\u22E9',
scpolint: '\u2A13',
scsim: '\u227F',
Scy: '\u0421',
scy: '\u0441',
sdotb: '\u22A1',
sdot: '\u22C5',
sdote: '\u2A66',
searhk: '\u2925',
searr: '\u2198',
seArr: '\u21D8',
searrow: '\u2198',
sect: '\xA7',
semi: ';',
seswar: '\u2929',
setminus: '\u2216',
setmn: '\u2216',
sext: '\u2736',
Sfr: '\u{1D516}',
sfr: '\u{1D530}',
sfrown: '\u2322',
sharp: '\u266F',
SHCHcy: '\u0429',
shchcy: '\u0449',
SHcy: '\u0428',
shcy: '\u0448',
ShortDownArrow: '\u2193',
ShortLeftArrow: '\u2190',
shortmid: '\u2223',
shortparallel: '\u2225',
ShortRightArrow: '\u2192',
ShortUpArrow: '\u2191',
shy: '\xAD',
Sigma: '\u03A3',
sigma: '\u03C3',
sigmaf: '\u03C2',
sigmav: '\u03C2',
sim: '\u223C',
simdot: '\u2A6A',
sime: '\u2243',
simeq: '\u2243',
simg: '\u2A9E',
simgE: '\u2AA0',
siml: '\u2A9D',
simlE: '\u2A9F',
simne: '\u2246',
simplus: '\u2A24',
simrarr: '\u2972',
slarr: '\u2190',
SmallCircle: '\u2218',
smallsetminus: '\u2216',
smashp: '\u2A33',
smeparsl: '\u29E4',
smid: '\u2223',
smile: '\u2323',
smt: '\u2AAA',
smte: '\u2AAC',
smtes: '\u2AAC\uFE00',
SOFTcy: '\u042C',
softcy: '\u044C',
solbar: '\u233F',
solb: '\u29C4',
sol: '/',
Sopf: '\u{1D54A}',
sopf: '\u{1D564}',
spades: '\u2660',
spadesuit: '\u2660',
spar: '\u2225',
sqcap: '\u2293',
sqcaps: '\u2293\uFE00',
sqcup: '\u2294',
sqcups: '\u2294\uFE00',
Sqrt: '\u221A',
sqsub: '\u228F',
sqsube: '\u2291',
sqsubset: '\u228F',
sqsubseteq: '\u2291',
sqsup: '\u2290',
sqsupe: '\u2292',
sqsupset: '\u2290',
sqsupseteq: '\u2292',
square: '\u25A1',
Square: '\u25A1',
SquareIntersection: '\u2293',
SquareSubset: '\u228F',
SquareSubsetEqual: '\u2291',
SquareSuperset: '\u2290',
SquareSupersetEqual: '\u2292',
SquareUnion: '\u2294',
squarf: '\u25AA',
squ: '\u25A1',
squf: '\u25AA',
srarr: '\u2192',
Sscr: '\u{1D4AE}',
sscr: '\u{1D4C8}',
ssetmn: '\u2216',
ssmile: '\u2323',
sstarf: '\u22C6',
Star: '\u22C6',
star: '\u2606',
starf: '\u2605',
straightepsilon: '\u03F5',
straightphi: '\u03D5',
strns: '\xAF',
sub: '\u2282',
Sub: '\u22D0',
subdot: '\u2ABD',
subE: '\u2AC5',
sube: '\u2286',
subedot: '\u2AC3',
submult: '\u2AC1',
subnE: '\u2ACB',
subne: '\u228A',
subplus: '\u2ABF',
subrarr: '\u2979',
subset: '\u2282',
Subset: '\u22D0',
subseteq: '\u2286',
subseteqq: '\u2AC5',
SubsetEqual: '\u2286',
subsetneq: '\u228A',
subsetneqq: '\u2ACB',
subsim: '\u2AC7',
subsub: '\u2AD5',
subsup: '\u2AD3',
succapprox: '\u2AB8',
succ: '\u227B',
succcurlyeq: '\u227D',
Succeeds: '\u227B',
SucceedsEqual: '\u2AB0',
SucceedsSlantEqual: '\u227D',
SucceedsTilde: '\u227F',
succeq: '\u2AB0',
succnapprox: '\u2ABA',
succneqq: '\u2AB6',
succnsim: '\u22E9',
succsim: '\u227F',
SuchThat: '\u220B',
sum: '\u2211',
Sum: '\u2211',
sung: '\u266A',
sup1: '\xB9',
sup2: '\xB2',
sup3: '\xB3',
sup: '\u2283',
Sup: '\u22D1',
supdot: '\u2ABE',
supdsub: '\u2AD8',
supE: '\u2AC6',
supe: '\u2287',
supedot: '\u2AC4',
Superset: '\u2283',
SupersetEqual: '\u2287',
suphsol: '\u27C9',
suphsub: '\u2AD7',
suplarr: '\u297B',
supmult: '\u2AC2',
supnE: '\u2ACC',
supne: '\u228B',
supplus: '\u2AC0',
supset: '\u2283',
Supset: '\u22D1',
supseteq: '\u2287',
supseteqq: '\u2AC6',
supsetneq: '\u228B',
supsetneqq: '\u2ACC',
supsim: '\u2AC8',
supsub: '\u2AD4',
supsup: '\u2AD6',
swarhk: '\u2926',
swarr: '\u2199',
swArr: '\u21D9',
swarrow: '\u2199',
swnwar: '\u292A',
szlig: '\xDF',
Tab: ' ',
target: '\u2316',
Tau: '\u03A4',
tau: '\u03C4',
tbrk: '\u23B4',
Tcaron: '\u0164',
tcaron: '\u0165',
Tcedil: '\u0162',
tcedil: '\u0163',
Tcy: '\u0422',
tcy: '\u0442',
tdot: '\u20DB',
telrec: '\u2315',
Tfr: '\u{1D517}',
tfr: '\u{1D531}',
there4: '\u2234',
therefore: '\u2234',
Therefore: '\u2234',
Theta: '\u0398',
theta: '\u03B8',
thetasym: '\u03D1',
thetav: '\u03D1',
thickapprox: '\u2248',
thicksim: '\u223C',
ThickSpace: '\u205F\u200A',
ThinSpace: '\u2009',
thinsp: '\u2009',
thkap: '\u2248',
thksim: '\u223C',
THORN: '\xDE',
thorn: '\xFE',
tilde: '\u02DC',
Tilde: '\u223C',
TildeEqual: '\u2243',
TildeFullEqual: '\u2245',
TildeTilde: '\u2248',
timesbar: '\u2A31',
timesb: '\u22A0',
times: '\xD7',
timesd: '\u2A30',
tint: '\u222D',
toea: '\u2928',
topbot: '\u2336',
topcir: '\u2AF1',
top: '\u22A4',
Topf: '\u{1D54B}',
topf: '\u{1D565}',
topfork: '\u2ADA',
tosa: '\u2929',
tprime: '\u2034',
trade: '\u2122',
TRADE: '\u2122',
triangle: '\u25B5',
triangledown: '\u25BF',
triangleleft: '\u25C3',
trianglelefteq: '\u22B4',
triangleq: '\u225C',
triangleright: '\u25B9',
trianglerighteq: '\u22B5',
tridot: '\u25EC',
trie: '\u225C',
triminus: '\u2A3A',
TripleDot: '\u20DB',
triplus: '\u2A39',
trisb: '\u29CD',
tritime: '\u2A3B',
trpezium: '\u23E2',
Tscr: '\u{1D4AF}',
tscr: '\u{1D4C9}',
TScy: '\u0426',
tscy: '\u0446',
TSHcy: '\u040B',
tshcy: '\u045B',
Tstrok: '\u0166',
tstrok: '\u0167',
twixt: '\u226C',
twoheadleftarrow: '\u219E',
twoheadrightarrow: '\u21A0',
Uacute: '\xDA',
uacute: '\xFA',
uarr: '\u2191',
Uarr: '\u219F',
uArr: '\u21D1',
Uarrocir: '\u2949',
Ubrcy: '\u040E',
ubrcy: '\u045E',
Ubreve: '\u016C',
ubreve: '\u016D',
Ucirc: '\xDB',
ucirc: '\xFB',
Ucy: '\u0423',
ucy: '\u0443',
udarr: '\u21C5',
Udblac: '\u0170',
udblac: '\u0171',
udhar: '\u296E',
ufisht: '\u297E',
Ufr: '\u{1D518}',
ufr: '\u{1D532}',
Ugrave: '\xD9',
ugrave: '\xF9',
uHar: '\u2963',
uharl: '\u21BF',
uharr: '\u21BE',
uhblk: '\u2580',
ulcorn: '\u231C',
ulcorner: '\u231C',
ulcrop: '\u230F',
ultri: '\u25F8',
Umacr: '\u016A',
umacr: '\u016B',
uml: '\xA8',
UnderBar: '_',
UnderBrace: '\u23DF',
UnderBracket: '\u23B5',
UnderParenthesis: '\u23DD',
Union: '\u22C3',
UnionPlus: '\u228E',
Uogon: '\u0172',
uogon: '\u0173',
Uopf: '\u{1D54C}',
uopf: '\u{1D566}',
UpArrowBar: '\u2912',
uparrow: '\u2191',
UpArrow: '\u2191',
Uparrow: '\u21D1',
UpArrowDownArrow: '\u21C5',
updownarrow: '\u2195',
UpDownArrow: '\u2195',
Updownarrow: '\u21D5',
UpEquilibrium: '\u296E',
upharpoonleft: '\u21BF',
upharpoonright: '\u21BE',
uplus: '\u228E',
UpperLeftArrow: '\u2196',
UpperRightArrow: '\u2197',
upsi: '\u03C5',
Upsi: '\u03D2',
upsih: '\u03D2',
Upsilon: '\u03A5',
upsilon: '\u03C5',
UpTeeArrow: '\u21A5',
UpTee: '\u22A5',
upuparrows: '\u21C8',
urcorn: '\u231D',
urcorner: '\u231D',
urcrop: '\u230E',
Uring: '\u016E',
uring: '\u016F',
urtri: '\u25F9',
Uscr: '\u{1D4B0}',
uscr: '\u{1D4CA}',
utdot: '\u22F0',
Utilde: '\u0168',
utilde: '\u0169',
utri: '\u25B5',
utrif: '\u25B4',
uuarr: '\u21C8',
Uuml: '\xDC',
uuml: '\xFC',
uwangle: '\u29A7',
vangrt: '\u299C',
varepsilon: '\u03F5',
varkappa: '\u03F0',
varnothing: '\u2205',
varphi: '\u03D5',
varpi: '\u03D6',
varpropto: '\u221D',
varr: '\u2195',
vArr: '\u21D5',
varrho: '\u03F1',
varsigma: '\u03C2',
varsubsetneq: '\u228A\uFE00',
varsubsetneqq: '\u2ACB\uFE00',
varsupsetneq: '\u228B\uFE00',
varsupsetneqq: '\u2ACC\uFE00',
vartheta: '\u03D1',
vartriangleleft: '\u22B2',
vartriangleright: '\u22B3',
vBar: '\u2AE8',
Vbar: '\u2AEB',
vBarv: '\u2AE9',
Vcy: '\u0412',
vcy: '\u0432',
vdash: '\u22A2',
vDash: '\u22A8',
Vdash: '\u22A9',
VDash: '\u22AB',
Vdashl: '\u2AE6',
veebar: '\u22BB',
vee: '\u2228',
Vee: '\u22C1',
veeeq: '\u225A',
vellip: '\u22EE',
verbar: '|',
Verbar: '\u2016',
vert: '|',
Vert: '\u2016',
VerticalBar: '\u2223',
VerticalLine: '|',
VerticalSeparator: '\u2758',
VerticalTilde: '\u2240',
VeryThinSpace: '\u200A',
Vfr: '\u{1D519}',
vfr: '\u{1D533}',
vltri: '\u22B2',
vnsub: '\u2282\u20D2',
vnsup: '\u2283\u20D2',
Vopf: '\u{1D54D}',
vopf: '\u{1D567}',
vprop: '\u221D',
vrtri: '\u22B3',
Vscr: '\u{1D4B1}',
vscr: '\u{1D4CB}',
vsubnE: '\u2ACB\uFE00',
vsubne: '\u228A\uFE00',
vsupnE: '\u2ACC\uFE00',
vsupne: '\u228B\uFE00',
Vvdash: '\u22AA',
vzigzag: '\u299A',
Wcirc: '\u0174',
wcirc: '\u0175',
wedbar: '\u2A5F',
wedge: '\u2227',
Wedge: '\u22C0',
wedgeq: '\u2259',
weierp: '\u2118',
Wfr: '\u{1D51A}',
wfr: '\u{1D534}',
Wopf: '\u{1D54E}',
wopf: '\u{1D568}',
wp: '\u2118',
wr: '\u2240',
wreath: '\u2240',
Wscr: '\u{1D4B2}',
wscr: '\u{1D4CC}',
xcap: '\u22C2',
xcirc: '\u25EF',
xcup: '\u22C3',
xdtri: '\u25BD',
Xfr: '\u{1D51B}',
xfr: '\u{1D535}',
xharr: '\u27F7',
xhArr: '\u27FA',
Xi: '\u039E',
xi: '\u03BE',
xlarr: '\u27F5',
xlArr: '\u27F8',
xmap: '\u27FC',
xnis: '\u22FB',
xodot: '\u2A00',
Xopf: '\u{1D54F}',
xopf: '\u{1D569}',
xoplus: '\u2A01',
xotime: '\u2A02',
xrarr: '\u27F6',
xrArr: '\u27F9',
Xscr: '\u{1D4B3}',
xscr: '\u{1D4CD}',
xsqcup: '\u2A06',
xuplus: '\u2A04',
xutri: '\u25B3',
xvee: '\u22C1',
xwedge: '\u22C0',
Yacute: '\xDD',
yacute: '\xFD',
YAcy: '\u042F',
yacy: '\u044F',
Ycirc: '\u0176',
ycirc: '\u0177',
Ycy: '\u042B',
ycy: '\u044B',
yen: '\xA5',
Yfr: '\u{1D51C}',
yfr: '\u{1D536}',
YIcy: '\u0407',
yicy: '\u0457',
Yopf: '\u{1D550}',
yopf: '\u{1D56A}',
Yscr: '\u{1D4B4}',
yscr: '\u{1D4CE}',
YUcy: '\u042E',
yucy: '\u044E',
yuml: '\xFF',
Yuml: '\u0178',
Zacute: '\u0179',
zacute: '\u017A',
Zcaron: '\u017D',
zcaron: '\u017E',
Zcy: '\u0417',
zcy: '\u0437',
Zdot: '\u017B',
zdot: '\u017C',
zeetrf: '\u2128',
ZeroWidthSpace: '\u200B',
Zeta: '\u0396',
zeta: '\u03B6',
zfr: '\u{1D537}',
Zfr: '\u2128',
ZHcy: '\u0416',
zhcy: '\u0436',
zigrarr: '\u21DD',
zopf: '\u{1D56B}',
Zopf: '\u2124',
Zscr: '\u{1D4B5}',
zscr: '\u{1D4CF}',
zwj: '\u200D',
zwnj: '\u200C',
},
Qn = /^#[xX]([A-Fa-f0-9]+)$/,
Jn = /^#([0-9]+)$/,
$n = /^([A-Za-z0-9]+)$/,
lr = (function () {
function e(t) {
this.named = t;
}
return (
(e.prototype.parse = function (t) {
if (t) {
var r = t.match(Qn);
if (r) return String.fromCharCode(parseInt(r[1], 16));
if (((r = t.match(Jn)), r))
return String.fromCharCode(parseInt(r[1], 10));
if (((r = t.match($n)), r)) return this.named[r[1]];
}
}),
e
);
})(),
Xn = /[\t\n\f ]/,
Zn = /[A-Za-z]/,
ti = /\r\n?/g;
function _(e) {
return Xn.test(e);
}
function vs(e) {
return Zn.test(e);
}
function ei(e) {
return e.replace(
ti,
`
`
);
}
var cr = (function () {
function e(t, r, s) {
s === void 0 && (s = 'precompile'),
(this.delegate = t),
(this.entityParser = r),
(this.mode = s),
(this.state = 'beforeData'),
(this.line = -1),
(this.column = -1),
(this.input = ''),
(this.index = -1),
(this.tagNameBuffer = ''),
(this.states = {
beforeData: function () {
var n = this.peek();
if (n === '<' && !this.isIgnoredEndTag())
this.transitionTo('tagOpen'), this.markTagStart(), this.consume();
else {
if (
this.mode === 'precompile' &&
n ===
`
`
) {
var i = this.tagNameBuffer.toLowerCase();
(i === 'pre' || i === 'textarea') && this.consume();
}
this.transitionTo('data'), this.delegate.beginData();
}
},
data: function () {
var n = this.peek(),
i = this.tagNameBuffer;
n === '<' && !this.isIgnoredEndTag() ?
(this.delegate.finishData(),
this.transitionTo('tagOpen'),
this.markTagStart(),
this.consume())
: n === '&' && i !== 'script' && i !== 'style' ?
(this.consume(),
this.delegate.appendToData(this.consumeCharRef() || '&'))
: (this.consume(), this.delegate.appendToData(n));
},
tagOpen: function () {
var n = this.consume();
n === '!' ? this.transitionTo('markupDeclarationOpen')
: n === '/' ? this.transitionTo('endTagOpen')
: (n === '@' || n === ':' || vs(n)) &&
(this.transitionTo('tagName'),
(this.tagNameBuffer = ''),
this.delegate.beginStartTag(),
this.appendToTagName(n));
},
markupDeclarationOpen: function () {
var n = this.consume();
if (n === '-' && this.peek() === '-')
this.consume(),
this.transitionTo('commentStart'),
this.delegate.beginComment();
else {
var i =
n.toUpperCase() +
this.input.substring(this.index, this.index + 6).toUpperCase();
i === 'DOCTYPE' &&
(this.consume(),
this.consume(),
this.consume(),
this.consume(),
this.consume(),
this.consume(),
this.transitionTo('doctype'),
this.delegate.beginDoctype && this.delegate.beginDoctype());
}
},
doctype: function () {
var n = this.consume();
_(n) && this.transitionTo('beforeDoctypeName');
},
beforeDoctypeName: function () {
var n = this.consume();
_(n) ||
(this.transitionTo('doctypeName'),
this.delegate.appendToDoctypeName &&
this.delegate.appendToDoctypeName(n.toLowerCase()));
},
doctypeName: function () {
var n = this.consume();
_(n) ? this.transitionTo('afterDoctypeName')
: n === '>' ?
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'))
: this.delegate.appendToDoctypeName &&
this.delegate.appendToDoctypeName(n.toLowerCase());
},
afterDoctypeName: function () {
var n = this.consume();
if (!_(n))
if (n === '>')
this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData');
else {
var i =
n.toUpperCase() +
this.input
.substring(this.index, this.index + 5)
.toUpperCase(),
a = i.toUpperCase() === 'PUBLIC',
o = i.toUpperCase() === 'SYSTEM';
(a || o) &&
(this.consume(),
this.consume(),
this.consume(),
this.consume(),
this.consume(),
this.consume()),
a ?
this.transitionTo('afterDoctypePublicKeyword')
: o && this.transitionTo('afterDoctypeSystemKeyword');
}
},
afterDoctypePublicKeyword: function () {
var n = this.peek();
_(n) ?
(this.transitionTo('beforeDoctypePublicIdentifier'),
this.consume())
: n === '"' ?
(this.transitionTo('doctypePublicIdentifierDoubleQuoted'),
this.consume())
: n === "'" ?
(this.transitionTo('doctypePublicIdentifierSingleQuoted'),
this.consume())
: n === '>' &&
(this.consume(),
this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'));
},
doctypePublicIdentifierDoubleQuoted: function () {
var n = this.consume();
n === '"' ? this.transitionTo('afterDoctypePublicIdentifier')
: n === '>' ?
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'))
: this.delegate.appendToDoctypePublicIdentifier &&
this.delegate.appendToDoctypePublicIdentifier(n);
},
doctypePublicIdentifierSingleQuoted: function () {
var n = this.consume();
n === "'" ? this.transitionTo('afterDoctypePublicIdentifier')
: n === '>' ?
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'))
: this.delegate.appendToDoctypePublicIdentifier &&
this.delegate.appendToDoctypePublicIdentifier(n);
},
afterDoctypePublicIdentifier: function () {
var n = this.consume();
_(n) ? this.transitionTo('betweenDoctypePublicAndSystemIdentifiers')
: n === '>' ?
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'))
: n === '"' ?
this.transitionTo('doctypeSystemIdentifierDoubleQuoted')
: n === "'" &&
this.transitionTo('doctypeSystemIdentifierSingleQuoted');
},
betweenDoctypePublicAndSystemIdentifiers: function () {
var n = this.consume();
_(n) ||
(n === '>' ?
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'))
: n === '"' ?
this.transitionTo('doctypeSystemIdentifierDoubleQuoted')
: n === "'" &&
this.transitionTo('doctypeSystemIdentifierSingleQuoted'));
},
doctypeSystemIdentifierDoubleQuoted: function () {
var n = this.consume();
n === '"' ? this.transitionTo('afterDoctypeSystemIdentifier')
: n === '>' ?
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'))
: this.delegate.appendToDoctypeSystemIdentifier &&
this.delegate.appendToDoctypeSystemIdentifier(n);
},
doctypeSystemIdentifierSingleQuoted: function () {
var n = this.consume();
n === "'" ? this.transitionTo('afterDoctypeSystemIdentifier')
: n === '>' ?
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData'))
: this.delegate.appendToDoctypeSystemIdentifier &&
this.delegate.appendToDoctypeSystemIdentifier(n);
},
afterDoctypeSystemIdentifier: function () {
var n = this.consume();
_(n) ||
(n === '>' &&
(this.delegate.endDoctype && this.delegate.endDoctype(),
this.transitionTo('beforeData')));
},
commentStart: function () {
var n = this.consume();
n === '-' ? this.transitionTo('commentStartDash')
: n === '>' ?
(this.delegate.finishComment(), this.transitionTo('beforeData'))
: (this.delegate.appendToCommentData(n),
this.transitionTo('comment'));
},
commentStartDash: function () {
var n = this.consume();
n === '-' ? this.transitionTo('commentEnd')
: n === '>' ?
(this.delegate.finishComment(), this.transitionTo('beforeData'))
: (this.delegate.appendToCommentData('-'),
this.transitionTo('comment'));
},
comment: function () {
var n = this.consume();
n === '-' ?
this.transitionTo('commentEndDash')
: this.delegate.appendToCommentData(n);
},
commentEndDash: function () {
var n = this.consume();
n === '-' ?
this.transitionTo('commentEnd')
: (this.delegate.appendToCommentData('-' + n),
this.transitionTo('comment'));
},
commentEnd: function () {
var n = this.consume();
n === '>' ?
(this.delegate.finishComment(), this.transitionTo('beforeData'))
: (this.delegate.appendToCommentData('--' + n),
this.transitionTo('comment'));
},
tagName: function () {
var n = this.consume();
_(n) ? this.transitionTo('beforeAttributeName')
: n === '/' ? this.transitionTo('selfClosingStartTag')
: n === '>' ?
(this.delegate.finishTag(), this.transitionTo('beforeData'))
: this.appendToTagName(n);
},
endTagName: function () {
var n = this.consume();
_(n) ?
(this.transitionTo('beforeAttributeName'),
(this.tagNameBuffer = ''))
: n === '/' ?
(this.transitionTo('selfClosingStartTag'),
(this.tagNameBuffer = ''))
: n === '>' ?
(this.delegate.finishTag(),
this.transitionTo('beforeData'),
(this.tagNameBuffer = ''))
: this.appendToTagName(n);
},
beforeAttributeName: function () {
var n = this.peek();
if (_(n)) {
this.consume();
return;
} else
n === '/' ?
(this.transitionTo('selfClosingStartTag'), this.consume())
: n === '>' ?
(this.consume(),
this.delegate.finishTag(),
this.transitionTo('beforeData'))
: n === '=' ?
(this.delegate.reportSyntaxError(
'attribute name cannot start with equals sign'
),
this.transitionTo('attributeName'),
this.delegate.beginAttribute(),
this.consume(),
this.delegate.appendToAttributeName(n))
: (this.transitionTo('attributeName'),
this.delegate.beginAttribute());
},
attributeName: function () {
var n = this.peek();
_(n) ? (this.transitionTo('afterAttributeName'), this.consume())
: n === '/' ?
(this.delegate.beginAttributeValue(!1),
this.delegate.finishAttributeValue(),
this.consume(),
this.transitionTo('selfClosingStartTag'))
: n === '=' ?
(this.transitionTo('beforeAttributeValue'), this.consume())
: n === '>' ?
(this.delegate.beginAttributeValue(!1),
this.delegate.finishAttributeValue(),
this.consume(),
this.delegate.finishTag(),
this.transitionTo('beforeData'))
: n === '"' || n === "'" || n === '<' ?
(this.delegate.reportSyntaxError(
n + ' is not a valid character within attribute names'
),
this.consume(),
this.delegate.appendToAttributeName(n))
: (this.consume(), this.delegate.appendToAttributeName(n));
},
afterAttributeName: function () {
var n = this.peek();
if (_(n)) {
this.consume();
return;
} else
n === '/' ?
(this.delegate.beginAttributeValue(!1),
this.delegate.finishAttributeValue(),
this.consume(),
this.transitionTo('selfClosingStartTag'))
: n === '=' ?
(this.consume(), this.transitionTo('beforeAttributeValue'))
: n === '>' ?
(this.delegate.beginAttributeValue(!1),
this.delegate.finishAttributeValue(),
this.consume(),
this.delegate.finishTag(),
this.transitionTo('beforeData'))
: (this.delegate.beginAttributeValue(!1),
this.delegate.finishAttributeValue(),
this.transitionTo('attributeName'),
this.delegate.beginAttribute(),
this.consume(),
this.delegate.appendToAttributeName(n));
},
beforeAttributeValue: function () {
var n = this.peek();
_(n) ? this.consume()
: n === '"' ?
(this.transitionTo('attributeValueDoubleQuoted'),
this.delegate.beginAttributeValue(!0),
this.consume())
: n === "'" ?
(this.transitionTo('attributeValueSingleQuoted'),
this.delegate.beginAttributeValue(!0),
this.consume())
: n === '>' ?
(this.delegate.beginAttributeValue(!1),
this.delegate.finishAttributeValue(),
this.consume(),
this.delegate.finishTag(),
this.transitionTo('beforeData'))
: (this.transitionTo('attributeValueUnquoted'),
this.delegate.beginAttributeValue(!1),
this.consume(),
this.delegate.appendToAttributeValue(n));
},
attributeValueDoubleQuoted: function () {
var n = this.consume();
n === '"' ?
(this.delegate.finishAttributeValue(),
this.transitionTo('afterAttributeValueQuoted'))
: n === '&' ?
this.delegate.appendToAttributeValue(this.consumeCharRef() || '&')
: this.delegate.appendToAttributeValue(n);
},
attributeValueSingleQuoted: function () {
var n = this.consume();
n === "'" ?
(this.delegate.finishAttributeValue(),
this.transitionTo('afterAttributeValueQuoted'))
: n === '&' ?
this.delegate.appendToAttributeValue(this.consumeCharRef() || '&')
: this.delegate.appendToAttributeValue(n);
},
attributeValueUnquoted: function () {
var n = this.peek();
_(n) ?
(this.delegate.finishAttributeValue(),
this.consume(),
this.transitionTo('beforeAttributeName'))
: n === '/' ?
(this.delegate.finishAttributeValue(),
this.consume(),
this.transitionTo('selfClosingStartTag'))
: n === '&' ?
(this.consume(),
this.delegate.appendToAttributeValue(
this.consumeCharRef() || '&'
))
: n === '>' ?
(this.delegate.finishAttributeValue(),
this.consume(),
this.delegate.finishTag(),
this.transitionTo('beforeData'))
: (this.consume(), this.delegate.appendToAttributeValue(n));
},
afterAttributeValueQuoted: function () {
var n = this.peek();
_(n) ? (this.consume(), this.transitionTo('beforeAttributeName'))
: n === '/' ?
(this.consume(), this.transitionTo('selfClosingStartTag'))
: n === '>' ?
(this.consume(),
this.delegate.finishTag(),
this.transitionTo('beforeData'))
: this.transitionTo('beforeAttributeName');
},
selfClosingStartTag: function () {
var n = this.peek();
n === '>' ?
(this.consume(),
this.delegate.markTagAsSelfClosing(),
this.delegate.finishTag(),
this.transitionTo('beforeData'))
: this.transitionTo('beforeAttributeName');
},
endTagOpen: function () {
var n = this.consume();
(n === '@' || n === ':' || vs(n)) &&
(this.transitionTo('endTagName'),
(this.tagNameBuffer = ''),
this.delegate.beginEndTag(),
this.appendToTagName(n));
},
}),
this.reset();
}
return (
(e.prototype.reset = function () {
this.transitionTo('beforeData'),
(this.input = ''),
(this.tagNameBuffer = ''),
(this.index = 0),
(this.line = 1),
(this.column = 0),
this.delegate.reset();
}),
(e.prototype.transitionTo = function (t) {
this.state = t;
}),
(e.prototype.tokenize = function (t) {
this.reset(), this.tokenizePart(t), this.tokenizeEOF();
}),
(e.prototype.tokenizePart = function (t) {
for (this.input += ei(t); this.index < this.input.length; ) {
var r = this.states[this.state];
if (r !== void 0) r.call(this);
else throw new Error('unhandled state ' + this.state);
}
}),
(e.prototype.tokenizeEOF = function () {
this.flushData();
}),
(e.prototype.flushData = function () {
this.state === 'data' &&
(this.delegate.finishData(), this.transitionTo('beforeData'));
}),
(e.prototype.peek = function () {
return this.input.charAt(this.index);
}),
(e.prototype.consume = function () {
var t = this.peek();
return (
this.index++,
(
t ===
`
`
) ?
(this.line++, (this.column = 0))
: this.column++,
t
);
}),
(e.prototype.consumeCharRef = function () {
var t = this.input.indexOf(';', this.index);
if (t !== -1) {
var r = this.input.slice(this.index, t),
s = this.entityParser.parse(r);
if (s) {
for (var n = r.length; n; ) this.consume(), n--;
return this.consume(), s;
}
}
}),
(e.prototype.markTagStart = function () {
this.delegate.tagOpen();
}),
(e.prototype.appendToTagName = function (t) {
(this.tagNameBuffer += t), this.delegate.appendToTagName(t);
}),
(e.prototype.isIgnoredEndTag = function () {
var t = this.tagNameBuffer;
return (
(t === 'title' &&
this.input.substring(this.index, this.index + 8) !== '</title>') ||
(t === 'style' &&
this.input.substring(this.index, this.index + 8) !== '</style>') ||
(t === 'script' &&
this.input.substring(this.index, this.index + 9) !== '<\/script>')
);
}),
e
);
})(),
eo = (function () {
function e(t, r) {
r === void 0 && (r = {}),
(this.options = r),
(this.token = null),
(this.startLine = 1),
(this.startColumn = 0),
(this.tokens = []),
(this.tokenizer = new cr(this, t, r.mode)),
(this._currentAttribute = void 0);
}
return (
(e.prototype.tokenize = function (t) {
return (this.tokens = []), this.tokenizer.tokenize(t), this.tokens;
}),
(e.prototype.tokenizePart = function (t) {
return (this.tokens = []), this.tokenizer.tokenizePart(t), this.tokens;
}),
(e.prototype.tokenizeEOF = function () {
return (this.tokens = []), this.tokenizer.tokenizeEOF(), this.tokens[0];
}),
(e.prototype.reset = function () {
(this.token = null), (this.startLine = 1), (this.startColumn = 0);
}),
(e.prototype.current = function () {
var t = this.token;
if (t === null) throw new Error('token was unexpectedly null');
if (arguments.length === 0) return t;
for (var r = 0; r < arguments.length; r++)
if (t.type === arguments[r]) return t;
throw new Error('token type was unexpectedly ' + t.type);
}),
(e.prototype.push = function (t) {
(this.token = t), this.tokens.push(t);
}),
(e.prototype.currentAttribute = function () {
return this._currentAttribute;
}),
(e.prototype.addLocInfo = function () {
this.options.loc &&
(this.current().loc = {
start: { line: this.startLine, column: this.startColumn },
end: { line: this.tokenizer.line, column: this.tokenizer.column },
}),
(this.startLine = this.tokenizer.line),
(this.startColumn = this.tokenizer.column);
}),
(e.prototype.beginDoctype = function () {
this.push({ type: 'Doctype', name: '' });
}),
(e.prototype.appendToDoctypeName = function (t) {
this.current('Doctype').name += t;
}),
(e.prototype.appendToDoctypePublicIdentifier = function (t) {
var r = this.current('Doctype');
r.publicIdentifier === void 0 ?
(r.publicIdentifier = t)
: (r.publicIdentifier += t);
}),
(e.prototype.appendToDoctypeSystemIdentifier = function (t) {
var r = this.current('Doctype');
r.systemIdentifier === void 0 ?
(r.systemIdentifier = t)
: (r.systemIdentifier += t);
}),
(e.prototype.endDoctype = function () {
this.addLocInfo();
}),
(e.prototype.beginData = function () {
this.push({ type: 'Chars', chars: '' });
}),
(e.prototype.appendToData = function (t) {
this.current('Chars').chars += t;
}),
(e.prototype.finishData = function () {
this.addLocInfo();
}),
(e.prototype.beginComment = function () {
this.push({ type: 'Comment', chars: '' });
}),
(e.prototype.appendToCommentData = function (t) {
this.current('Comment').chars += t;
}),
(e.prototype.finishComment = function () {
this.addLocInfo();
}),
(e.prototype.tagOpen = function () {}),
(e.prototype.beginStartTag = function () {
this.push({
type: 'StartTag',
tagName: '',
attributes: [],
selfClosing: !1,
});
}),
(e.prototype.beginEndTag = function () {
this.push({ type: 'EndTag', tagName: '' });
}),
(e.prototype.finishTag = function () {
this.addLocInfo();
}),
(e.prototype.markTagAsSelfClosing = function () {
this.current('StartTag').selfClosing = !0;
}),
(e.prototype.appendToTagName = function (t) {
this.current('StartTag', 'EndTag').tagName += t;
}),
(e.prototype.beginAttribute = function () {
this._currentAttribute = ['', '', !1];
}),
(e.prototype.appendToAttributeName = function (t) {
this.currentAttribute()[0] += t;
}),
(e.prototype.beginAttributeValue = function (t) {
this.currentAttribute()[2] = t;
}),
(e.prototype.appendToAttributeValue = function (t) {
this.currentAttribute()[1] += t;
}),
(e.prototype.finishAttributeValue = function () {
this.current('StartTag').attributes.push(this._currentAttribute);
}),
(e.prototype.reportSyntaxError = function (t) {
this.current().syntaxError = t;
}),
e
);
})();
var Ne = {
Append: 1,
TrustingAppend: 2,
Comment: 3,
Modifier: 4,
StrictModifier: 5,
Block: 6,
StrictBlock: 7,
Component: 8,
OpenElement: 10,
OpenElementWithSplat: 11,
FlushElement: 12,
CloseElement: 13,
StaticAttr: 14,
DynamicAttr: 15,
ComponentAttr: 16,
AttrSplat: 17,
Yield: 18,
DynamicArg: 20,
StaticArg: 21,
TrustingDynamicAttr: 22,
TrustingComponentAttr: 23,
StaticComponentAttr: 24,
Debugger: 26,
Undefined: 27,
Call: 28,
Concat: 29,
GetSymbol: 30,
GetLexicalSymbol: 32,
GetStrictKeyword: 31,
GetFreeAsComponentOrHelperHead: 35,
GetFreeAsHelperHead: 37,
GetFreeAsModifierHead: 38,
GetFreeAsComponentHead: 39,
InElement: 40,
If: 41,
Each: 42,
Let: 44,
WithDynamicVars: 45,
InvokeComponent: 46,
HasBlock: 48,
HasBlockParams: 49,
Curry: 50,
Not: 51,
IfInline: 52,
GetDynamicVar: 53,
Log: 54,
};
function ws(e) {
return function (t) {
return Array.isArray(t) && t[0] === e;
};
}
var so = ws(Ne.FlushElement);
var no = ws(Ne.GetSymbol);
var Ds = !1,
ri = /["\x26\xa0]/u,
fo = new RegExp(ri.source, 'gu'),
si = /[&<>\xa0]/u,
mo = new RegExp(si.source, 'gu');
var dr = new Set([
'area',
'base',
'br',
'col',
'command',
'embed',
'hr',
'img',
'input',
'keygen',
'link',
'meta',
'param',
'source',
'track',
'wbr',
]);
function ni(e) {
var t;
return (
dr.has(e.toLowerCase()) &&
((t = e[0]) == null ? void 0 : t.toLowerCase()) === e[0]
);
}
function ce(e) {
return !!e && e.length > 0;
}
function Nr(e) {
return e.length === 0 ? void 0 : e[e.length - 1];
}
function ii(e) {
return e.length === 0 ? void 0 : e[0];
}
var pt = Object.freeze({ line: 1, column: 0 }),
ai = Object.freeze({ source: '(synthetic)', start: pt, end: pt }),
gr = Object.freeze({ source: '(nonexistent)', start: pt, end: pt }),
ht = Object.freeze({ source: '(broken)', start: pt, end: pt }),
br = class {
constructor(t) {
this._whens = t;
}
first(t) {
for (let r of this._whens) {
let s = r.match(t);
if (ce(s)) return s[0];
}
return null;
}
},
Pe = class {
get(t, r) {
let s = this._map.get(t);
return s || ((s = r()), this._map.set(t, s), s);
}
add(t, r) {
this._map.set(t, r);
}
match(t) {
let r = (function (a) {
switch (a) {
case 'Broken':
case 'InternalsSynthetic':
case 'NonExistent':
return 'IS_INVISIBLE';
default:
return a;
}
})(t),
s = [],
n = this._map.get(r),
i = this._map.get('MATCH_ANY');
return n && s.push(n), i && s.push(i), s;
}
constructor() {
this._map = new Map();
}
};
function _s(e) {
return e(new yr()).validate();
}
var yr = class {
validate() {
return (t, r) => this.matchFor(t.kind, r.kind)(t, r);
}
matchFor(t, r) {
let s = this._whens.match(t);
return ce(), new br(s).first(r);
}
when(t, r, s) {
return this._whens.get(t, () => new Pe()).add(r, s), this;
}
constructor() {
this._whens = new Pe();
}
},
kr = class e {
static synthetic(t) {
let r = D.synthetic(t);
return new e({ loc: r, chars: t });
}
static load(t, r) {
return new e({ loc: D.load(t, r[1]), chars: r[0] });
}
constructor(t) {
(this.loc = t.loc), (this.chars = t.chars);
}
getString() {
return this.chars;
}
serialize() {
return [this.chars, this.loc.serialize()];
}
},
D = class e {
static get NON_EXISTENT() {
return new et('NonExistent', gr).wrap();
}
static load(t, r) {
return (
typeof r == 'number' ? e.forCharPositions(t, r, r)
: typeof r == 'string' ? e.synthetic(r)
: Array.isArray(r) ? e.forCharPositions(t, r[0], r[1])
: r === 'NonExistent' ? e.NON_EXISTENT
: r === 'Broken' ? e.broken(ht)
: void ds(r)
);
}
static forHbsLoc(t, r) {
let s = new mt(t, r.start),
n = new mt(t, r.end);
return new oe(t, { start: s, end: n }, r).wrap();
}
static forCharPositions(t, r, s) {
let n = new Tt(t, r),
i = new Tt(t, s);
return new ae(t, { start: n, end: i }).wrap();
}
static synthetic(t) {
return new et('InternalsSynthetic', gr, t).wrap();
}
static broken(t = ht) {
return new et('Broken', t).wrap();
}
constructor(t) {
var r;
(this.data = t),
(this.isInvisible =
(r = t.kind) !== 'CharPosition' && r !== 'HbsPosition');
}
getStart() {
return this.data.getStart().wrap();
}
getEnd() {
return this.data.getEnd().wrap();
}
get loc() {
let t = this.data.toHbsSpan();
return t === null ? ht : t.toHbsLoc();
}
get module() {
return this.data.getModule();
}
get startPosition() {
return this.loc.start;
}
get endPosition() {
return this.loc.end;
}
toJSON() {
return this.loc;
}
withStart(t) {
return J(t.data, this.data.getEnd());
}
withEnd(t) {
return J(this.data.getStart(), t.data);
}
asString() {
return this.data.asString();
}
toSlice(t) {
let r = this.data.asString();
return (
Ds &&
t !== void 0 &&
r !== t &&
console.warn(
`unexpectedly found ${JSON.stringify(r)} when slicing source, but expected ${JSON.stringify(t)}`
),
new kr({ loc: this, chars: t || r })
);
}
get start() {
return this.loc.start;
}
set start(t) {
this.data.locDidUpdate({ start: t });
}
get end() {
return this.loc.end;
}
set end(t) {
this.data.locDidUpdate({ end: t });
}
get source() {
return this.module;
}
collapse(t) {
switch (t) {
case 'start':
return this.getStart().collapsed();
case 'end':
return this.getEnd().collapsed();
}
}
extend(t) {
return J(this.data.getStart(), t.data.getEnd());
}
serialize() {
return this.data.serialize();
}
slice({ skipStart: t = 0, skipEnd: r = 0 }) {
return J(this.getStart().move(t).data, this.getEnd().move(-r).data);
}
sliceStartChars({ skipStart: t = 0, chars: r }) {
return J(this.getStart().move(t).data, this.getStart().move(t + r).data);
}
sliceEndChars({ skipEnd: t = 0, chars: r }) {
return J(this.getEnd().move(t - r).data, this.getStart().move(-t).data);
}
},
Ut,
ae = class {
constructor(t, r) {
Lt(this, Ut);
(this.source = t),
(this.charPositions = r),
(this.kind = 'CharPosition'),
Y(this, Ut, null);
}
wrap() {
return new D(this);
}
asString() {
return this.source.slice(
this.charPositions.start.charPos,
this.charPositions.end.charPos
);
}
getModule() {
return this.source.module;
}
getStart() {
return this.charPositions.start;
}
getEnd() {
return this.charPositions.end;
}
locDidUpdate() {}
toHbsSpan() {
let t = I(this, Ut);
if (t === null) {
let r = this.charPositions.start.toHbsPos(),
s = this.charPositions.end.toHbsPos();
t = Y(
this,
Ut,
r === null || s === null ?
ft
: new oe(this.source, { start: r, end: s })
);
}
return t === ft ? null : t;
}
serialize() {
let {
start: { charPos: t },
end: { charPos: r },
} = this.charPositions;
return t === r ? t : [t, r];
}
toCharPosSpan() {
return this;
}
};
Ut = new WeakMap();
var ut,
Et,
oe = class {
constructor(t, r, s = null) {
Lt(this, ut);
Lt(this, Et);
(this.source = t),
(this.hbsPositions = r),
(this.kind = 'HbsPosition'),
Y(this, ut, null),
Y(this, Et, s);
}
serialize() {
let t = this.toCharPosSpan();
return t === null ? 'Broken' : t.wrap().serialize();
}
wrap() {
return new D(this);
}
updateProvided(t, r) {
I(this, Et) && (I(this, Et)[r] = t),
Y(this, ut, null),
Y(this, Et, { start: t, end: t });
}
locDidUpdate({ start: t, end: r }) {
t !== void 0 &&
(this.updateProvided(t, 'start'),
(this.hbsPositions.start = new mt(this.source, t, null))),
r !== void 0 &&
(this.updateProvided(r, 'end'),
(this.hbsPositions.end = new mt(this.source, r, null)));
}
asString() {
let t = this.toCharPosSpan();
return t === null ? '' : t.asString();
}
getModule() {
return this.source.module;
}
getStart() {
return this.hbsPositions.start;
}
getEnd() {
return this.hbsPositions.end;
}
toHbsLoc() {
return {
start: this.hbsPositions.start.hbsPos,
end: this.hbsPositions.end.hbsPos,
};
}
toHbsSpan() {
return this;
}
toCharPosSpan() {
let t = I(this, ut);
if (t === null) {
let r = this.hbsPositions.start.toCharPos(),
s = this.hbsPositions.end.toCharPos();
if (!r || !s) return (t = Y(this, ut, ft)), null;
t = Y(this, ut, new ae(this.source, { start: r, end: s }));
}
return t === ft ? null : t;
}
};
(ut = new WeakMap()), (Et = new WeakMap());
var et = class {
constructor(t, r, s = null) {
(this.kind = t), (this.loc = r), (this.string = s);
}
serialize() {
switch (this.kind) {
case 'Broken':
case 'NonExistent':
return this.kind;
case 'InternalsSynthetic':
return this.string || '';
}
}
wrap() {
return new D(this);
}
asString() {
return this.string || '';
}
locDidUpdate({ start: t, end: r }) {
t !== void 0 && (this.loc.start = t), r !== void 0 && (this.loc.end = r);
}
getModule() {
return 'an unknown module';
}
getStart() {
return new le(this.kind, this.loc.start);
}
getEnd() {
return new le(this.kind, this.loc.end);
}
toCharPosSpan() {
return this;
}
toHbsSpan() {
return null;
}
toHbsLoc() {
return ht;
}
},
J = _s((e) =>
e
.when('HbsPosition', 'HbsPosition', (t, r) =>
new oe(t.source, { start: t, end: r }).wrap()
)
.when('CharPosition', 'CharPosition', (t, r) =>
new ae(t.source, { start: t, end: r }).wrap()
)
.when('CharPosition', 'HbsPosition', (t, r) => {
let s = r.toCharPos();
return s === null ? new et('Broken', ht).wrap() : J(t, s);
})
.when('HbsPosition', 'CharPosition', (t, r) => {
let s = t.toCharPos();
return s === null ? new et('Broken', ht).wrap() : J(s, r);
})
.when('IS_INVISIBLE', 'MATCH_ANY', (t) => new et(t.kind, ht).wrap())
.when('MATCH_ANY', 'IS_INVISIBLE', (t, r) => new et(r.kind, ht).wrap())
),
ft = 'BROKEN',
Mt = class e {
static forHbsPos(t, r) {
return new mt(t, r, null).wrap();
}
static broken(t = pt) {
return new le('Broken', t).wrap();
}
constructor(t) {
this.data = t;
}
get offset() {
let t = this.data.toCharPos();
return t === null ? null : t.offset;
}
eql(t) {
return oi(this.data, t.data);
}
until(t) {
return J(this.data, t.data);
}
move(t) {
let r = this.data.toCharPos();
if (r === null) return e.broken();
{
let s = r.offset + t;
return r.source.validate(s) ? new Tt(r.source, s).wrap() : e.broken();
}
}
collapsed() {
return J(this.data, this.data);
}
toJSON() {
return this.data.toJSON();
}
},
Tt = class {
constructor(t, r) {
(this.source = t),
(this.charPos = r),
(this.kind = 'CharPosition'),
(this._locPos = null);
}
toCharPos() {
return this;
}
toJSON() {
let t = this.toHbsPos();
return t === null ? pt : t.toJSON();
}
wrap() {
return new Mt(this);
}
get offset() {
return this.charPos;
}
toHbsPos() {
let t = this._locPos;
if (t === null) {
let r = this.source.hbsPosFor(this.charPos);
this._locPos = t =
r === null ? ft : new mt(this.source, r, this.charPos);
}
return t === ft ? null : t;
}
},
mt = class {
constructor(t, r, s = null) {
(this.source = t),
(this.hbsPos = r),
(this.kind = 'HbsPosition'),
(this._charPos = s === null ? null : new Tt(t, s));
}
toCharPos() {
let t = this._charPos;
if (t === null) {
let r = this.source.charPosFor(this.hbsPos);
this._charPos = t = r === null ? ft : new Tt(this.source, r);
}
return t === ft ? null : t;
}
toJSON() {
return this.hbsPos;
}
wrap() {
return new Mt(this);
}
toHbsPos() {
return this;
}
},
le = class {
constructor(t, r) {
(this.kind = t), (this.pos = r);
}
toCharPos() {
return null;
}
toJSON() {
return this.pos;
}
wrap() {
return new Mt(this);
}
get offset() {
return null;
}
},
oi = _s((e) =>
e
.when(
'HbsPosition',
'HbsPosition',
({ hbsPos: t }, { hbsPos: r }) =>
t.column === r.column && t.line === r.line
)
.when(
'CharPosition',
'CharPosition',
({ charPos: t }, { charPos: r }) => t === r
)
.when('CharPosition', 'HbsPosition', ({ offset: t }, r) => {
var s;
return t === ((s = r.toCharPos()) == null ? void 0 : s.offset);
})
.when('HbsPosition', 'CharPosition', (t, { offset: r }) => {
var s;
return ((s = t.toCharPos()) == null ? void 0 : s.offset) === r;
})
.when('MATCH_ANY', 'MATCH_ANY', () => !1)
),
wt = class e {
static from(t, r = {}) {
var s;
return new e(t, (s = r.meta) == null ? void 0 : s.moduleName);
}
constructor(t, r = 'an unknown module') {
(this.source = t), (this.module = r);
}
validate(t) {
return t >= 0 && t <= this.source.length;
}
slice(t, r) {
return this.source.slice(t, r);
}
offsetFor(t, r) {
return Mt.forHbsPos(this, { line: t, column: r });
}
spanFor({ start: t, end: r }) {
return D.forHbsLoc(this, {
start: { line: t.line, column: t.column },
end: { line: r.line, column: r.column },
});
}
hbsPosFor(t) {
let r = 0,
s = 0;
if (t > this.source.length) return null;
for (;;) {
let n = this.source.indexOf(
`
`,
s
);
if (t <= n || n === -1) return { line: r + 1, column: t - s };
(r += 1), (s = n + 1);
}
}
charPosFor(t) {
let { line: r, column: s } = t,
n = this.source.length,
i = 0,
a = 0;
for (; a < n; ) {
let o = this.source.indexOf(
`
`,
a
);
if ((o === -1 && (o = this.source.length), i === r - 1)) {
if (a + s > o) return o;
if (Ds) {
let c = this.hbsPosFor(a + s);
c.line, c.column;
}
return a + s;
}
if (o === -1) return 0;
(i += 1), (a = o + 1);
}
return n;
}
};
function v(e, t) {
let { module: r, loc: s } = t,
{ line: n, column: i } = s.start,
a = t.asString(),
o =
a ?
`
|
| ${a.split(`
`).join(`
| `)}
|
`
: '',
c = new Error(
`${e}: ${o}(error occurred in '${r}' @ line ${n} : column ${i})`
);
return (c.name = 'SyntaxError'), (c.location = t), (c.code = a), c;
}
var li = {
Template: ['body'],
Block: ['body'],
MustacheStatement: ['path', 'params', 'hash'],
BlockStatement: ['path', 'params', 'hash', 'program', 'inverse'],
ElementModifierStatement: ['path', 'params', 'hash'],
CommentStatement: [],
MustacheCommentStatement: [],
ElementNode: ['attributes', 'modifiers', 'children', 'comments'],
AttrNode: ['value'],
TextNode: [],
ConcatStatement: ['parts'],
SubExpression: ['path', 'params', 'hash'],
PathExpression: [],
StringLiteral: [],
BooleanLiteral: [],
NumberLiteral: [],
NullLiteral: [],
UndefinedLiteral: [],
Hash: ['pairs'],
HashPair: ['value'],
},
Cr = (function () {
function e(t, r, s, n) {
let i = Error.call(this, t);
(this.key = n),
(this.message = t),
(this.node = r),
(this.parent = s),
i.stack && (this.stack = i.stack);
}
return (
(e.prototype = Object.create(Error.prototype)),
(e.prototype.constructor = e),
e
);
})();
function Ts(e, t, r) {
return new Cr('Cannot remove a node unless it is part of an array', e, t, r);
}
function ci(e, t, r) {
return new Cr(
'Cannot replace a node with multiple nodes unless it is part of an array',
e,
t,
r
);
}
function Ns(e, t) {
return new Cr(
'Replacing and removing in key handlers is not yet supported.',
e,
null,
t
);
}
var zt = class {
constructor(t, r = null, s = null) {
(this.node = t), (this.parent = r), (this.parentKey = s);
}
get parentNode() {
return this.parent ? this.parent.node : null;
}
parents() {
return { [Symbol.iterator]: () => new Sr(this) };
}
},
Sr = class {
constructor(t) {
this.path = t;
}
next() {
return this.path.parent ?
((this.path = this.path.parent), { done: !1, value: this.path })
: { done: !0, value: null };
}
};
function Os(e) {
return typeof e == 'function' ? e : e.enter;
}
function Bs(e) {
return typeof e == 'function' ? void 0 : e.exit;
}
function Ae(e, t) {
let r,
s,
n,
{ node: i, parent: a, parentKey: o } = t,
c = (function (h, p) {
if (
h.Program &&
((p === 'Template' && !h.Template) || (p === 'Block' && !h.Block))
)
return h.Program;
let m = h[p];
return m !== void 0 ? m : h.All;
})(e, i.type);
if (
(c !== void 0 && ((r = Os(c)), (s = Bs(c))),
r !== void 0 && (n = r(i, t)),
n != null)
) {
if (JSON.stringify(i) !== JSON.stringify(n))
return Array.isArray(n) ?
(Is(e, n, a, o), n)
: Ae(e, new zt(n, a, o)) || n;
n = void 0;
}
if (n === void 0) {
let h = li[i.type];
for (let p = 0; p < h.length; p++) ui(e, c, t, h[p]);
s !== void 0 && (n = s(i, t));
}
return n;
}
function Cs(e, t, r) {
e[t] = r;
}
function ui(e, t, r, s) {
let n,
i,
{ node: a } = r,
o = (function (c, h) {
return c[h];
})(a, s);
if (o) {
if (t !== void 0) {
let c = (function (h, p) {
let m = typeof h != 'function' ? h.keys : void 0;
if (m === void 0) return;
let S = m[p];
return S !== void 0 ? S : m.All;
})(t, s);
c !== void 0 && ((n = Os(c)), (i = Bs(c)));
}
if (n !== void 0 && n(a, s) !== void 0) throw Ns(a, s);
if (Array.isArray(o)) Is(e, o, r, s);
else {
let c = Ae(e, new zt(o, r, s));
c !== void 0 &&
(function (h, p, m, S) {
if (S === null) throw Ts(m, h, p);
if (Array.isArray(S)) {
if (S.length !== 1)
throw S.length === 0 ? Ts(m, h, p) : ci(m, h, p);
Cs(h, p, S[0]);
} else Cs(h, p, S);
})(a, s, o, c);
}
if (i !== void 0 && i(a, s) !== void 0) throw Ns(a, s);
}
}
function Is(e, t, r, s) {
for (let n = 0; n < t.length; n++) {
let i = t[n],
a = Ae(e, new zt(i, r, s));
a !== void 0 && (n += hi(t, n, a) - 1);
}
}
function hi(e, t, r) {
return (
r === null ? (e.splice(t, 1), 0)
: Array.isArray(r) ? (e.splice(t, 1, ...r), r.length)
: (e.splice(t, 1, r), 1)
);
}
function pi(e, t) {
Ae(t, new zt(e));
}
function Ht(e, t) {
(function (r) {
switch (r.type) {
case 'Block':
case 'Template':
return r.body;
case 'ElementNode':
return r.children;
}
})(e).push(t);
}
function Rs(e) {
return (
e.type === 'StringLiteral' ||
e.type === 'BooleanLiteral' ||
e.type === 'NumberLiteral' ||
e.type === 'NullLiteral' ||
e.type === 'UndefinedLiteral'
);
}
var ur;
function hr() {
return ur || (ur = new wt('', '(synthetic)')), ur;
}
function xs(e, t) {
return f.var({ name: e, loc: T(t || null) });
}
function ct(e, t) {
let r = T(t || null);
if (typeof e != 'string') {
if ('type' in e) return e;
{
e.head.indexOf('.');
let { head: i, tail: a } = e;
return f.path({
head: f.head({
original: i,
loc: r.sliceStartChars({ chars: i.length }),
}),
tail: a,
loc: T(t || null),
});
}
}
let { head: s, tail: n } = (function (i, a) {
let [o, ...c] = i.split('.'),
h = f.head({ original: o, loc: T(a || null) });
return f.path({ head: h, tail: c, loc: T(a || null) });
})(e, r);
return f.path({ head: s, tail: n, loc: r });
}
function xe(e, t, r) {
return f.literal({ type: e, value: t, loc: T(r || null) });
}
function ie(e = [], t) {
return f.hash({ pairs: e, loc: T(t || null) });
}
function qs(e) {
return e.map((t) =>
typeof t == 'string' ? f.var({ name: t, loc: D.synthetic(t) }) : t
);
}
function Ps(e = [], t = [], r = !1, s) {
return f.blockItself({
body: e,
params: qs(t),
chained: r,
loc: T(s || null),
});
}
function As(e = [], t = [], r) {
return f.template({ body: e, blockParams: t, loc: T(r || null) });
}
function T(...e) {
if (e.length === 1) {
let t = e[0];
return t && typeof t == 'object' ?
D.forHbsLoc(hr(), t)
: D.forHbsLoc(hr(), ai);
}
{
let [t, r, s, n, i] = e,
a = i ? new wt('', i) : hr();
return D.forHbsLoc(a, {
start: { line: t, column: r },
end: { line: s || t, column: n || r },
});
}
}
var fi = {
mustache: function (e, t = [], r = ie([]), s = !1, n, i) {
return f.mustache({
path: ct(e),
params: t,
hash: r,
trusting: s,
strip: i,
loc: T(n || null),
});
},
block: function (e, t, r, s, n = null, i, a, o, c) {
let h,
p = null;
return (
(h =
s.type === 'Template' ?
f.blockItself({ params: qs(s.blockParams), body: s.body, loc: s.loc })
: s),
(n == null ? void 0 : n.type) === 'Template' ?
(n.blockParams.length,
(p = f.blockItself({ params: [], body: n.body, loc: n.loc })))
: (p = n),
f.block({
path: ct(e),
params: t || [],
hash: r || ie([]),
defaultBlock: h,
elseBlock: p,
loc: T(i || null),
openStrip: a,
inverseStrip: o,
closeStrip: c,
})
);
},
comment: function (e, t) {
return f.comment({ value: e, loc: T(t || null) });
},
mustacheComment: function (e, t) {
return f.mustacheComment({ value: e, loc: T(t || null) });
},
element: function (e, t = {}) {
let r,
s,
{
attrs: n,
blockParams: i,
modifiers: a,
comments: o,
children: c,
openTag: h,
closeTag: p,
loc: m,
} = t;
typeof e == 'string' ?
e.endsWith('/') ?
((r = ct(e.slice(0, -1))), (s = !0))
: (r = ct(e))
: 'type' in e ? (e.type, e.type, (r = e))
: 'path' in e ?
(e.path.type, e.path.type, (r = e.path), (s = e.selfClosing))
: ((r = ct(e.name)), (s = e.selfClosing));
let S =
i == null ? void 0 : i.map((E) => (typeof E == 'string' ? xs(E) : E)),
y = null;
return (
p ?
(y = T(p))
: p === void 0 && (y = s || ni(r.original) ? null : T(null)),
f.element({
path: r,
selfClosing: s || !1,
attributes: n || [],
params: S || [],
modifiers: a || [],
comments: o || [],
children: c || [],
openTag: T(h || null),
closeTag: y,
loc: T(m || null),
})
);
},
elementModifier: function (e, t, r, s) {
return f.elementModifier({
path: ct(e),
params: t || [],
hash: r || ie([]),
loc: T(s || null),
});
},
attr: function (e, t, r) {
return f.attr({ name: e, value: t, loc: T(r || null) });
},
text: function (e = '', t) {
return f.text({ chars: e, loc: T(t || null) });
},
sexpr: function (e, t = [], r = ie([]), s) {
return f.sexpr({ path: ct(e), params: t, hash: r, loc: T(s || null) });
},
concat: function (e, t) {
if (!ce(e)) throw new Error('b.concat requires at least one part');
return f.concat({ parts: e, loc: T(t || null) });
},
hash: ie,
pair: function (e, t, r) {
return f.pair({ key: e, value: t, loc: T(r || null) });
},
literal: xe,
program: function (e, t, r) {
return t && t.length ? Ps(e, t, !1, r) : As(e, [], r);
},
blockItself: Ps,
template: As,
loc: T,
pos: function (e, t) {
return f.pos({ line: e, column: t });
},
path: ct,
fullPath: function (e, t = [], r) {
return f.path({ head: e, tail: t, loc: T(r || null) });
},
head: function (e, t) {
return f.head({ original: e, loc: T(t || null) });
},
at: function (e, t) {
return f.atName({ name: e, loc: T(t || null) });
},
var: xs,
this: function (e) {
return f.this({ loc: T(e || null) });
},
string: pr('StringLiteral'),
boolean: pr('BooleanLiteral'),
number: pr('NumberLiteral'),
undefined: () => xe('UndefinedLiteral', void 0),
null: () => xe('NullLiteral', null),
};
function pr(e) {
return function (t, r) {
return xe(e, t, r);
};
}
var Ce = { close: !1, open: !1 },
f = new (class {
pos({ line: e, column: t }) {
return { line: e, column: t };
}
blockItself({ body: e, params: t, chained: r = !1, loc: s }) {
return {
type: 'Block',
body: e,
params: t,
get blockParams() {
return this.params.map((n) => n.name);
},
set blockParams(n) {
this.params = n.map((i) => f.var({ name: i, loc: D.synthetic(i) }));
},
chained: r,
loc: s,
};
}
template({ body: e, blockParams: t, loc: r }) {
return { type: 'Template', body: e, blockParams: t, loc: r };
}
mustache({
path: e,
params: t,
hash: r,
trusting: s,
loc: n,
strip: i = Ce,
}) {
return (function ({
path: a,
params: o,
hash: c,
trusting: h,
strip: p,
loc: m,
}) {
let S = {
type: 'MustacheStatement',
path: a,
params: o,
hash: c,
trusting: h,
strip: p,
loc: m,
};
return (
Object.defineProperty(S, 'escaped', {
enumerable: !1,
get() {
return !this.trusting;
},
set(y) {
this.trusting = !y;
},
}),
S
);
})({ path: e, params: t, hash: r, trusting: s, strip: i, loc: n });
}
block({
path: e,
params: t,
hash: r,
defaultBlock: s,
elseBlock: n = null,
loc: i,
openStrip: a = Ce,
inverseStrip: o = Ce,
closeStrip: c = Ce,
}) {
return {
type: 'BlockStatement',
path: e,
params: t,
hash: r,
program: s,
inverse: n,
loc: i,
openStrip: a,
inverseStrip: o,
closeStrip: c,
};
}
comment({ value: e, loc: t }) {
return { type: 'CommentStatement', value: e, loc: t };
}
mustacheComment({ value: e, loc: t }) {
return { type: 'MustacheCommentStatement', value: e, loc: t };
}
concat({ parts: e, loc: t }) {
return { type: 'ConcatStatement', parts: e, loc: t };
}
element({
path: e,
selfClosing: t,
attributes: r,
modifiers: s,
params: n,
comments: i,
children: a,
openTag: o,
closeTag: c,
loc: h,
}) {
let p = t;
return {
type: 'ElementNode',
path: e,
attributes: r,
modifiers: s,
params: n,
comments: i,
children: a,
openTag: o,
closeTag: c,
loc: h,
get tag() {
return this.path.original;
},
set tag(m) {
this.path.original = m;
},
get blockParams() {
return this.params.map((m) => m.name);
},
set blockParams(m) {
this.params = m.map((S) => f.var({ name: S, loc: D.synthetic(S) }));
},
get selfClosing() {
return p;
},
set selfClosing(m) {
(p = m), (this.closeTag = m ? null : D.synthetic(`</${this.tag}>`));
},
};
}
elementModifier({ path: e, params: t, hash: r, loc: s }) {
return {
type: 'ElementModifierStatement',
path: e,
params: t,
hash: r,
loc: s,
};
}
attr({ name: e, value: t, loc: r }) {
return { type: 'AttrNode', name: e, value: t, loc: r };
}
text({ chars: e, loc: t }) {
return { type: 'TextNode', chars: e, loc: t };
}
sexpr({ path: e, params: t, hash: r, loc: s }) {
return { type: 'SubExpression', path: e, params: t, hash: r, loc: s };
}
path({ head: e, tail: t, loc: r }) {
return (function ({ head: s, tail: n, loc: i }) {
let a = {
type: 'PathExpression',
head: s,
tail: n,
get original() {
return [this.head.original, ...this.tail].join('.');
},
set original(o) {
let [c, ...h] = o.split('.');
(this.head = fi.head(c, this.head.loc)), (this.tail = h);
},
loc: i,
};
return (
Object.defineProperty(a, 'parts', {
enumerable: !1,
get() {
let o = this.original.split('.');
return (
o[0] === 'this' ?
o.shift()
: o[0].startsWith('@') && (o[0] = o[0].slice(1)),
Object.freeze(o)
);
},
set(o) {
var h;
let c = [...o];
c[0] === 'this' ||
((h = c[0]) != null && h.startsWith('@')) ||
(this.head.type === 'ThisHead' ?
c.unshift('this')
: this.head.type === 'AtHead' && (c[0] = `@${c[0]}`)),
(this.original = c.join('.'));
},
}),
Object.defineProperty(a, 'this', {
enumerable: !1,
get() {
return this.head.type === 'ThisHead';
},
}),
Object.defineProperty(a, 'data', {
enumerable: !1,
get() {
return this.head.type === 'AtHead';
},
}),
a
);
})({ head: e, tail: t, loc: r });
}
head({ original: e, loc: t }) {
return (
e === 'this' ? this.this({ loc: t })
: e[0] === '@' ? this.atName({ name: e, loc: t })
: this.var({ name: e, loc: t })
);
}
this({ loc: e }) {
return {
type: 'ThisHead',
get original() {
return 'this';
},
loc: e,
};
}
atName({ name: e, loc: t }) {
let r = '',
s = {
type: 'AtHead',
get name() {
return r;
},
set name(n) {
n[0], n.indexOf('.'), (r = n);
},
get original() {
return this.name;
},
set original(n) {
this.name = n;
},
loc: t,
};
return (s.name = e), s;
}
var({ name: e, loc: t }) {
let r = '',
s = {
type: 'VarHead',
get name() {
return r;
},
set name(n) {
n[0], n.indexOf('.'), (r = n);
},
get original() {
return this.name;
},
set original(n) {
this.name = n;
},
loc: t,
};
return (s.name = e), s;
}
hash({ pairs: e, loc: t }) {
return { type: 'Hash', pairs: e, loc: t };
}
pair({ key: e, value: t, loc: r }) {
return { type: 'HashPair', key: e, value: t, loc: r };
}
literal({ type: e, value: t, loc: r }) {
return (function ({ type: s, value: n, loc: i }) {
let a = { type: s, value: n, loc: i };
return (
Object.defineProperty(a, 'original', {
enumerable: !1,
get() {
return this.value;
},
set(o) {
this.value = o;
},
}),
a
);
})({ type: e, value: t, loc: r });
}
})(),
vr = class {
constructor(t, r = new lr(Es), s = 'precompile') {
(this.elementStack = []),
(this.currentAttribute = null),
(this.currentNode = null),
(this.source = t),
(this.lines = t.source.split(/\r\n?|\n/u)),
(this.tokenizer = new cr(this, r, s));
}
offset() {
let { line: t, column: r } = this.tokenizer;
return this.source.offsetFor(t, r);
}
pos({ line: t, column: r }) {
return this.source.offsetFor(t, r);
}
finish(t) {
return tr({}, t, { loc: t.start.until(this.offset()) });
}
get currentAttr() {
return this.currentAttribute;
}
get currentTag() {
let t = this.currentNode;
return t && (t.type === 'StartTag' || t.type), t;
}
get currentStartTag() {
let t = this.currentNode;
return t && t.type, t;
}
get currentEndTag() {
let t = this.currentNode;
return t && t.type, t;
}
get currentComment() {
let t = this.currentNode;
return t && t.type, t;
}
get currentData() {
let t = this.currentNode;
return t && t.type, t;
}
acceptNode(t) {
return this[t.type](t);
}
currentElement() {
return Nr(this.elementStack);
}
sourceForNode(t, r) {
let s,
n,
i,
a = t.loc.start.line - 1,
o = a - 1,
c = t.loc.start.column,
h = [];
for (
r ?
((n = r.loc.end.line - 1), (i = r.loc.end.column))
: ((n = t.loc.end.line - 1), (i = t.loc.end.column));
o < n;
)
o++,
(s = this.lines[o]),
o === a ?
a === n ?
h.push(s.slice(c, i))
: h.push(s.slice(c))
: o === n ? h.push(s.slice(0, i))
: h.push(s);
return h.join(`
`);
}
},
Er = class extends vr {
parse(t, r) {
var i;
t.loc;
let s = f.template({
body: [],
blockParams: r,
loc: this.source.spanFor(t.loc),
}),
n = this.parseProgram(s, t);
return (i = this.pendingError) == null || i.eof(n.loc.getEnd()), n;
}
Program(t, r) {
t.loc;
let s = f.blockItself({
body: [],
params: r,
chained: t.chained,
loc: this.source.spanFor(t.loc),
});
return this.parseProgram(s, t);
}
parseProgram(t, r) {
if (r.body.length === 0) return t;
let s;
try {
this.elementStack.push(t);
for (let n of r.body) this.acceptNode(n);
} finally {
s = this.elementStack.pop();
}
if (t !== s) {
if ((s == null ? void 0 : s.type) === 'ElementNode')
throw v(`Unclosed element \`${s.tag}\``, s.loc);
t.type;
}
return t;
}
BlockStatement(t) {
var m;
if (this.tokenizer.state === 'comment')
return t.loc, void this.appendToCommentData(this.sourceForNode(t));
if (
this.tokenizer.state !== 'data' &&
this.tokenizer.state !== 'beforeData'
)
throw v(
'A block may only be used inside an HTML element or another block.',
this.source.spanFor(t.loc)
);
let { path: r, params: s, hash: n } = fr(this, t),
i = this.source.spanFor(t.loc),
a,
o = [];
if ((m = t.program.blockParams) != null && m.length) {
let S = n.loc.collapse('end');
(S =
t.program.loc ?
S.withEnd(this.source.spanFor(t.program.loc).getStart())
: t.program.body[0] ?
S.withEnd(this.source.spanFor(t.program.body[0].loc).getStart())
: S.withEnd(i.getEnd())),
(a = Ls(this.source, t, S));
let y = S.asString(),
E = y.indexOf('|') + 1,
C = y.indexOf('|', E);
for (let x of t.program.blockParams) {
let w, U;
(w = E >= C ? -1 : y.indexOf(x, E)),
w === -1 || w + x.length > C ?
((E = C), (U = this.source.spanFor(gr)))
: ((E = w),
(U = S.sliceStartChars({ skipStart: E, chars: x.length })),
(E += x.length)),
o.push(f.var({ name: x, loc: U }));
}
} else a = Ls(this.source, t, i);
let c = this.Program(a.program, o),
h = a.inverse ? this.Program(a.inverse, []) : null,
p = f.block({
path: r,
params: s,
hash: n,
defaultBlock: c,
elseBlock: h,
loc: this.source.spanFor(t.loc),
openStrip: t.openStrip,
inverseStrip: t.inverseStrip,
closeStrip: t.closeStrip,
});
Ht(this.currentElement(), p);
}
MustacheStatement(t) {
var o;
(o = this.pendingError) == null || o.mustache(this.source.spanFor(t.loc));
let { tokenizer: r } = this;
if (r.state === 'comment')
return void this.appendToCommentData(this.sourceForNode(t));
let s,
{ escaped: n, loc: i, strip: a } = t;
if ('original' in t.path && t.path.original === '...attributes')
throw v('Illegal use of ...attributes', this.source.spanFor(t.loc));
if (Rs(t.path))
s = f.mustache({
path: this.acceptNode(t.path),
params: [],
hash: f.hash({
pairs: [],
loc: this.source.spanFor(t.path.loc).collapse('end'),
}),
trusting: !n,
loc: this.source.spanFor(i),
strip: a,
});
else {
let { path: c, params: h, hash: p } = fr(this, t);
s = f.mustache({
path: c,
params: h,
hash: p,
trusting: !n,
loc: this.source.spanFor(i),
strip: a,
});
}
switch (r.state) {
case 'tagOpen':
case 'tagName':
throw v('Cannot use mustaches in an elements tagname', s.loc);
case 'beforeAttributeName':
mr(this.currentStartTag, s);
break;
case 'attributeName':
case 'afterAttributeName':
this.beginAttributeValue(!1),
this.finishAttributeValue(),
mr(this.currentStartTag, s),
r.transitionTo('beforeAttributeName');
break;
case 'afterAttributeValueQuoted':
mr(this.currentStartTag, s), r.transitionTo('beforeAttributeName');
break;
case 'beforeAttributeValue':
this.beginAttributeValue(!1),
this.appendDynamicAttributeValuePart(s),
r.transitionTo('attributeValueUnquoted');
break;
case 'attributeValueDoubleQuoted':
case 'attributeValueSingleQuoted':
case 'attributeValueUnquoted':
this.appendDynamicAttributeValuePart(s);
break;
default:
Ht(this.currentElement(), s);
}
return s;
}
appendDynamicAttributeValuePart(t) {
this.finalizeTextPart();
let r = this.currentAttr;
(r.isDynamic = !0), r.parts.push(t);
}
finalizeTextPart() {
let t = this.currentAttr.currentPart;
t !== null && (this.currentAttr.parts.push(t), this.startTextPart());
}
startTextPart() {
this.currentAttr.currentPart = null;
}
ContentStatement(t) {
(function (r, s) {
let n = s.loc.start.line,
i = s.loc.start.column,
a = (function (o, c) {
if (c === '')
return {
lines:
o.split(`
`).length - 1,
columns: 0,
};
let [h] = o.split(c),
p = h.split(/\n/u),
m = p.length - 1;
return { lines: m, columns: p[m].length };
})(s.original, s.value);
(n += a.lines),
a.lines ? (i = a.columns) : (i += a.columns),
(r.line = n),
(r.column = i);
})(this.tokenizer, t),
this.tokenizer.tokenizePart(t.value),
this.tokenizer.flushData();
}
CommentStatement(t) {
let { tokenizer: r } = this;
if (r.state === 'comment')
return this.appendToCommentData(this.sourceForNode(t)), null;
let { value: s, loc: n } = t,
i = f.mustacheComment({ value: s, loc: this.source.spanFor(n) });
switch (r.state) {
case 'beforeAttributeName':
case 'afterAttributeName':
this.currentStartTag.comments.push(i);
break;
case 'beforeData':
case 'data':
Ht(this.currentElement(), i);
break;
default:
throw v(
`Using a Handlebars comment when in the \`${r.state}\` state is not supported`,
this.source.spanFor(t.loc)
);
}
return i;
}
PartialStatement(t) {
throw v(
'Handlebars partials are not supported',
this.source.spanFor(t.loc)
);
}
PartialBlockStatement(t) {
throw v(
'Handlebars partial blocks are not supported',
this.source.spanFor(t.loc)
);
}
Decorator(t) {
throw v(
'Handlebars decorators are not supported',
this.source.spanFor(t.loc)
);
}
DecoratorBlock(t) {
throw v(
'Handlebars decorator blocks are not supported',
this.source.spanFor(t.loc)
);
}
SubExpression(t) {
let { path: r, params: s, hash: n } = fr(this, t);
return f.sexpr({
path: r,
params: s,
hash: n,
loc: this.source.spanFor(t.loc),
});
}
PathExpression(t) {
let { original: r } = t,
s;
if (r.indexOf('/') !== -1) {
if (r.slice(0, 2) === './')
throw v(
'Using "./" is not supported in Glimmer and unnecessary',
this.source.spanFor(t.loc)
);
if (r.slice(0, 3) === '../')
throw v(
'Changing context using "../" is not supported in Glimmer',
this.source.spanFor(t.loc)
);
if (r.indexOf('.') !== -1)
throw v(
"Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths",
this.source.spanFor(t.loc)
);
s = [t.parts.join('/')];
} else {
if (r === '.')
throw v(
"'.' is not a supported path in Glimmer; check for a path with a trailing '.'",
this.source.spanFor(t.loc)
);
s = t.parts;
}
let n,
i = !1;
if ((/^this(?:\..+)?$/u.test(r) && (i = !0), i))
n = f.this({
loc: this.source.spanFor({
start: t.loc.start,
end: { line: t.loc.start.line, column: t.loc.start.column + 4 },
}),
});
else if (t.data) {
let a = s.shift();
if (a === void 0)
throw v(
'Attempted to parse a path expression, but it was not valid. Paths beginning with @ must start with a-z.',
this.source.spanFor(t.loc)
);
n = f.atName({
name: `@${a}`,
loc: this.source.spanFor({
start: t.loc.start,
end: {
line: t.loc.start.line,
column: t.loc.start.column + a.length + 1,
},
}),
});
} else {
let a = s.shift();
if (a === void 0)
throw v(
'Attempted to parse a path expression, but it was not valid. Paths must start with a-z or A-Z.',
this.source.spanFor(t.loc)
);
n = f.var({
name: a,
loc: this.source.spanFor({
start: t.loc.start,
end: {
line: t.loc.start.line,
column: t.loc.start.column + a.length,
},
}),
});
}
return f.path({ head: n, tail: s, loc: this.source.spanFor(t.loc) });
}
Hash(t) {
let r = t.pairs.map((s) =>
f.pair({
key: s.key,
value: this.acceptNode(s.value),
loc: this.source.spanFor(s.loc),
})
);
return f.hash({ pairs: r, loc: this.source.spanFor(t.loc) });
}
StringLiteral(t) {
return f.literal({
type: 'StringLiteral',
value: t.value,
loc: this.source.spanFor(t.loc),
});
}
BooleanLiteral(t) {
return f.literal({
type: 'BooleanLiteral',
value: t.value,
loc: this.source.spanFor(t.loc),
});
}
NumberLiteral(t) {
return f.literal({
type: 'NumberLiteral',
value: t.value,
loc: this.source.spanFor(t.loc),
});
}
UndefinedLiteral(t) {
return f.literal({
type: 'UndefinedLiteral',
value: void 0,
loc: this.source.spanFor(t.loc),
});
}
NullLiteral(t) {
return f.literal({
type: 'NullLiteral',
value: null,
loc: this.source.spanFor(t.loc),
});
}
constructor(...t) {
super(...t), (this.pendingError = null);
}
};
function fr(e, t) {
let r;
switch (t.path.type) {
case 'PathExpression':
r = e.PathExpression(t.path);
break;
case 'SubExpression':
r = e.SubExpression(t.path);
break;
case 'StringLiteral':
case 'UndefinedLiteral':
case 'NullLiteral':
case 'NumberLiteral':
case 'BooleanLiteral': {
let i;
throw (
((i =
t.path.type === 'BooleanLiteral' ? t.path.original.toString()
: t.path.type === 'StringLiteral' ? `"${t.path.original}"`
: t.path.type === 'NullLiteral' ? 'null'
: t.path.type === 'NumberLiteral' ? t.path.value.toString()
: 'undefined'),
v(
`${t.path.type} "${t.path.type === 'StringLiteral' ? t.path.original : i}" cannot be called as a sub-expression, replace (${i}) with ${i}`,
e.source.spanFor(t.path.loc)
))
);
}
}
let s = t.params.map((i) => e.acceptNode(i)),
n = ce(s) ? Nr(s).loc : r.loc;
return {
path: r,
params: s,
hash:
t.hash ?
e.Hash(t.hash)
: f.hash({ pairs: [], loc: e.source.spanFor(n).collapse('end') }),
};
}
function mr(e, t) {
let { path: r, params: s, hash: n, loc: i } = t;
if (Rs(r)) {
let o = `{{${(function (c) {
return c.type === 'UndefinedLiteral' ?
'undefined'
: JSON.stringify(c.value);
})(r)}}}`;
throw v(`In <${e.name} ... ${o} ..., ${o} is not a valid modifier`, t.loc);
}
let a = f.elementModifier({ path: r, params: s, hash: n, loc: i });
e.modifiers.push(a);
}
function Ls(e, t, r) {
if (!t.program.loc) {
let n = G(!1, t.program.body, 0),
i = G(!1, t.program.body, -1);
if (n && i) t.program.loc = { ...n.loc, end: i.loc.end };
else {
let a = e.spanFor(t.loc);
t.program.loc = r.withEnd(a.getEnd());
}
}
let s = e.spanFor(t.program.loc).getEnd();
return t.inverse && !t.inverse.loc && (t.inverse.loc = s.collapsed()), t;
}
function Ft(e) {
return /[\t\n\f ]/u.test(e);
}
var wr = class extends Er {
reset() {
this.currentNode = null;
}
beginComment() {
this.currentNode = {
type: 'CommentStatement',
value: '',
start: this.source.offsetFor(this.tagOpenLine, this.tagOpenColumn),
};
}
appendToCommentData(t) {
this.currentComment.value += t;
}
finishComment() {
Ht(this.currentElement(), f.comment(this.finish(this.currentComment)));
}
beginData() {
this.currentNode = { type: 'TextNode', chars: '', start: this.offset() };
}
appendToData(t) {
this.currentData.chars += t;
}
finishData() {
Ht(this.currentElement(), f.text(this.finish(this.currentData)));
}
tagOpen() {
(this.tagOpenLine = this.tokenizer.line),
(this.tagOpenColumn = this.tokenizer.column);
}
beginStartTag() {
this.currentNode = {
type: 'StartTag',
name: '',
nameStart: null,
nameEnd: null,
attributes: [],
modifiers: [],
comments: [],
params: [],
selfClosing: !1,
start: this.source.offsetFor(this.tagOpenLine, this.tagOpenColumn),
};
}
beginEndTag() {
this.currentNode = {
type: 'EndTag',
name: '',
start: this.source.offsetFor(this.tagOpenLine, this.tagOpenColumn),
};
}
finishTag() {
let t = this.finish(this.currentTag);
if (t.type === 'StartTag') {
if ((this.finishStartTag(), t.name === ':'))
throw v(
'Invalid named block named detected, you may have created a named block without a name, or you may have began your name with a number. Named blocks must have names that are at least one character long, and begin with a lower case letter',
this.source.spanFor({
start: this.currentTag.start.toJSON(),
end: this.offset().toJSON(),
})
);
(dr.has(t.name) || t.selfClosing) && this.finishEndTag(!0);
} else t.type, t.type, this.finishEndTag(!1);
}
finishStartTag() {
let { name: t, nameStart: r, nameEnd: s } = this.currentStartTag,
n = r.until(s),
[i, ...a] = t.split('.'),
o = f.path({
head: f.head({
original: i,
loc: n.sliceStartChars({ chars: i.length }),
}),
tail: a,
loc: n,
}),
{
attributes: c,
modifiers: h,
comments: p,
params: m,
selfClosing: S,
loc: y,
} = this.finish(this.currentStartTag),
E = f.element({
path: o,
selfClosing: S,
attributes: c,
modifiers: h,
comments: p,
params: m,
children: [],
openTag: y,
closeTag: S ? null : D.broken(),
loc: y,
});
this.elementStack.push(E);
}
finishEndTag(t) {
let { start: r } = this.currentTag,
s = this.finish(this.currentTag),
n = this.elementStack.pop();
this.validateEndTag(s, n, t);
let i = this.currentElement();
t ? (n.closeTag = null)
: n.selfClosing ? n.closeTag
: (n.closeTag = r.until(this.offset())),
(n.loc = n.loc.withEnd(this.offset())),
Ht(i, f.element(n));
}
markTagAsSelfClosing() {
let t = this.currentTag;
if (t.type !== 'StartTag')
throw v(
'Invalid end tag: closing tag must not be self-closing',
this.source.spanFor({
start: t.start.toJSON(),
end: this.offset().toJSON(),
})
);
t.selfClosing = !0;
}
appendToTagName(t) {
let r = this.currentTag;
if (((r.name += t), r.type === 'StartTag')) {
let s = this.offset();
r.nameStart === null && (r.nameEnd, (r.nameStart = s.move(-1))),
(r.nameEnd = s);
}
}
beginAttribute() {
let t = this.offset();
this.currentAttribute = {
name: '',
parts: [],
currentPart: null,
isQuoted: !1,
isDynamic: !1,
start: t,
valueSpan: t.collapsed(),
};
}
appendToAttributeName(t) {
(this.currentAttr.name += t),
this.currentAttr.name === 'as' && this.parsePossibleBlockParams();
}
beginAttributeValue(t) {
(this.currentAttr.isQuoted = t),
this.startTextPart(),
(this.currentAttr.valueSpan = this.offset().collapsed());
}
appendToAttributeValue(t) {
let r = this.currentAttr.parts,
s = r[r.length - 1],
n = this.currentAttr.currentPart;
if (n) (n.chars += t), (n.loc = n.loc.withEnd(this.offset()));
else {
let i = this.offset();
(i =
(
t ===
`
`
) ?
s ? s.loc.getEnd()
: this.currentAttr.valueSpan.getStart()
: i.move(-1)),
(this.currentAttr.currentPart = f.text({
chars: t,
loc: i.collapsed(),
}));
}
}
finishAttributeValue() {
this.finalizeTextPart();
let t = this.currentTag,
r = this.offset();
if (t.type === 'EndTag')
throw v(
'Invalid end tag: closing tag must not have attributes',
this.source.spanFor({ start: t.start.toJSON(), end: r.toJSON() })
);
let {
name: s,
parts: n,
start: i,
isQuoted: a,
isDynamic: o,
valueSpan: c,
} = this.currentAttr;
if (s.startsWith('|') && n.length === 0 && !a && !o)
throw v(
'Invalid block parameters syntax: block parameters must be preceded by the `as` keyword',
i.until(i.move(s.length))
);
let h = this.assembleAttributeValue(n, a, o, i.until(r));
h.loc = c.withEnd(r);
let p = f.attr({ name: s, value: h, loc: i.until(r) });
this.currentStartTag.attributes.push(p);
}
parsePossibleBlockParams() {
let t = /[!"#%&'()*+./;<=>@[\\\]^`{|}~]/u;
this.tokenizer.state;
let r = this.currentStartTag,
s = this.currentAttr,
n = { state: 'PossibleAs' },
i = {
PossibleAs: (o) => {
if ((n.state, Ft(o)))
(n = { state: 'BeforeStartPipe' }),
this.tokenizer.transitionTo('afterAttributeName'),
this.tokenizer.consume();
else {
if (o === '|')
throw v(
'Invalid block parameters syntax: expecting at least one space character between "as" and "|"',
s.start.until(this.offset().move(1))
);
n = { state: 'Done' };
}
},
BeforeStartPipe: (o) => {
n.state,
Ft(o) ? this.tokenizer.consume()
: o === '|' ?
((n = { state: 'BeforeBlockParamName' }),
this.tokenizer.transitionTo('beforeAttributeName'),
this.tokenizer.consume())
: (n = { state: 'Done' });
},
BeforeBlockParamName: (o) => {
if ((n.state, Ft(o))) this.tokenizer.consume();
else if (o === '')
(n = { state: 'Done' }),
(this.pendingError = {
mustache(c) {
throw v(
'Invalid block parameters syntax: mustaches cannot be used inside parameters list',
c
);
},
eof(c) {
throw v(
'Invalid block parameters syntax: expecting the tag to be closed with ">" or "/>" after parameters list',
s.start.until(c)
);
},
});
else if (o === '|') {
if (r.params.length === 0)
throw v(
'Invalid block parameters syntax: empty parameters list, expecting at least one identifier',
s.start.until(this.offset().move(1))
);
(n = { state: 'AfterEndPipe' }), this.tokenizer.consume();
} else {
if (o === '>' || o === '/')
throw v(
'Invalid block parameters syntax: incomplete parameters list, expecting "|" but the tag was closed prematurely',
s.start.until(this.offset().move(1))
);
(n = { state: 'BlockParamName', name: o, start: this.offset() }),
this.tokenizer.consume();
}
},
BlockParamName: (o) => {
if ((n.state, o === ''))
(n = { state: 'Done' }),
(this.pendingError = {
mustache(c) {
throw v(
'Invalid block parameters syntax: mustaches cannot be used inside parameters list',
c
);
},
eof(c) {
throw v(
'Invalid block parameters syntax: expecting the tag to be closed with ">" or "/>" after parameters list',
s.start.until(c)
);
},
});
else if (o === '|' || Ft(o)) {
let c = n.start.until(this.offset());
if (n.name === 'this' || t.test(n.name))
throw v(
`Invalid block parameters syntax: invalid identifier name \`${n.name}\``,
c
);
r.params.push(f.var({ name: n.name, loc: c })),
(n =
o === '|' ?
{ state: 'AfterEndPipe' }
: { state: 'BeforeBlockParamName' }),
this.tokenizer.consume();
} else {
if (o === '>' || o === '/')
throw v(
'Invalid block parameters syntax: expecting "|" but the tag was closed prematurely',
s.start.until(this.offset().move(1))
);
(n.name += o), this.tokenizer.consume();
}
},
AfterEndPipe: (o) => {
n.state,
Ft(o) ? this.tokenizer.consume()
: o === '' ?
((n = { state: 'Done' }),
(this.pendingError = {
mustache(c) {
throw v(
'Invalid block parameters syntax: modifiers cannot follow parameters list',
c
);
},
eof(c) {
throw v(
'Invalid block parameters syntax: expecting the tag to be closed with ">" or "/>" after parameters list',
s.start.until(c)
);
},
}))
: o === '>' || o === '/' ? (n = { state: 'Done' })
: ((n = {
state: 'Error',
message:
'Invalid block parameters syntax: expecting the tag to be closed with ">" or "/>" after parameters list',
start: this.offset(),
}),
this.tokenizer.consume());
},
Error: (o) => {
if ((n.state, o === '' || o === '/' || o === '>' || Ft(o)))
throw v(n.message, n.start.until(this.offset()));
this.tokenizer.consume();
},
Done: () => {},
},
a;
do (a = this.tokenizer.peek()), i[n.state](a);
while (n.state !== 'Done' && a !== '');
n.state;
}
reportSyntaxError(t) {
throw v(t, this.offset().collapsed());
}
assembleConcatenatedValue(t) {
let r = ii(t),
s = Nr(t);
return f.concat({
parts: t,
loc: this.source.spanFor(r.loc).extend(this.source.spanFor(s.loc)),
});
}
validateEndTag(t, r, s) {
if (dr.has(t.name) && !s)
throw v(
`<${t.name}> elements do not need end tags. You should remove it`,
t.loc
);
if (r.type !== 'ElementNode')
throw v(`Closing tag </${t.name}> without an open tag`, t.loc);
if (r.tag !== t.name)
throw v(
`Closing tag </${t.name}> did not match last open tag <${r.tag}> (on line ${r.loc.startPosition.line})`,
t.loc
);
}
assembleAttributeValue(t, r, s, n) {
if (s) {
if (r) return this.assembleConcatenatedValue(t);
{
let [i, a] = t;
if (a === void 0 || (a.type === 'TextNode' && a.chars === '/'))
return i;
throw v(
"An unquoted attribute value must be a string or a mustache, preceded by whitespace or a '=' character, and followed by whitespace, a '>' character, or '/>'",
n
);
}
}
return ce(t) ? t[0] : f.text({ chars: '', loc: n });
}
constructor(...t) {
super(...t), (this.tagOpenLine = 0), (this.tagOpenColumn = 0);
}
},
mi = {},
Tr = class extends lr {
constructor() {
super({});
}
parse() {}
};
function Vs(e, t = {}) {
var c, h, p;
let r,
s,
n,
i = t.mode || 'precompile';
typeof e == 'string' ?
((r = new wt(e, (c = t.meta) == null ? void 0 : c.moduleName)),
(s = i === 'codemod' ? Te(e, t.parseOptions) : or(e, t.parseOptions)))
: e instanceof wt ?
((r = e),
(s =
i === 'codemod' ?
Te(e.source, t.parseOptions)
: or(e.source, t.parseOptions)))
: ((r = new wt('', (h = t.meta) == null ? void 0 : h.moduleName)), (s = e)),
i === 'codemod' && (n = new Tr());
let a = D.forCharPositions(r, 0, r.source.length);
s.loc = { source: '(program)', start: a.startPosition, end: a.endPosition };
let o = new wr(r, n, i).parse(s, t.locals ?? []);
if ((p = t.plugins) != null && p.ast)
for (let m of t.plugins.ast)
pi(o, m(tr({}, t, { syntax: mi }, { plugins: void 0 })).visitor);
return o;
}
var di = {
resolution: () => Ne.GetStrictKeyword,
serialize: () => 'Strict',
isAngleBracket: !1,
},
go = { ...di, isAngleBracket: !0 };
var Le = `
`,
Fs = '\r',
Hs = (function () {
function e(t) {
this.length = t.length;
for (var r = [0], s = 0; s < t.length; )
switch (t[s]) {
case Le:
(s += Le.length), r.push(s);
break;
case Fs:
(s += Fs.length), t[s] === Le && (s += Le.length), r.push(s);
break;
default:
s++;
break;
}
this.offsets = r;
}
return (
(e.prototype.locationForIndex = function (t) {
if (t < 0 || t > this.length) return null;
for (var r = 0, s = this.offsets; s[r + 1] <= t; ) r++;
var n = t - s[r];
return { line: r, column: n };
}),
(e.prototype.indexForLocation = function (t) {
var r = t.line,
s = t.column;
return (
r < 0 ||
r >= this.offsets.length ||
s < 0 ||
s > this.lengthOfLine(r)
) ?
null
: this.offsets[r] + s;
}),
(e.prototype.lengthOfLine = function (t) {
var r = this.offsets[t],
s = t === this.offsets.length - 1 ? this.length : this.offsets[t + 1];
return s - r;
}),
e
);
})();
function gi(e, t) {
let r = new SyntaxError(
e + ' (' + t.loc.start.line + ':' + t.loc.start.column + ')'
);
return Object.assign(r, t);
}
var Us = gi;
function bi(e) {
let t = e.children ?? e.body;
if (t)
for (let r = 0; r < t.length - 1; r++)
t[r].type === 'TextNode' &&
t[r + 1].type === 'MustacheStatement' &&
(t[r].chars = t[r].chars.replace(/\\$/u, '\\\\'));
}
function yi(e) {
let t = new Hs(e),
r = ({ line: n, column: i }) =>
t.indexForLocation({ line: n - 1, column: i }),
s = (n) => {
let { start: i, end: a } = n.loc;
(i.offset = r(i)), (a.offset = r(a));
};
return () => ({
name: 'prettierParsePlugin',
visitor: {
All(n) {
s(n), bi(n);
},
},
});
}
function ki(e) {
let t;
try {
t = Vs(e, { mode: 'codemod', plugins: { ast: [yi(e)] } });
} catch (r) {
let s = vi(r);
if (s) {
let n = Si(r);
throw Us(n, { loc: s, cause: r });
}
throw r;
}
return t;
}
function Si(e) {
let { message: t } = e,
r = t.split(`
`);
return (
(
r.length >= 4 &&
/^Parse error on line \d+:$/u.test(r[0]) &&
/^-*\^$/u.test(G(!1, r, -2))
) ?
G(!1, r, -1)
: (
r.length >= 4 &&
/:\s?$/u.test(r[0]) &&
/^\(error occurred in '.*?' @ line \d+ : column \d+\)$/u.test(
G(!1, r, -1)
) &&
r[1] === '' &&
G(!1, r, -2) === '' &&
r.slice(2, -2).every((s) => s.startsWith('|'))
) ?
r[0].trim().slice(0, -1)
: t
);
}
function vi(e) {
let { location: t, hash: r } = e;
if (t) {
let { start: s, end: n } = t;
return typeof n.line != 'number' ? { start: s } : t;
}
if (r) {
let {
loc: { last_line: s, last_column: n },
} = r;
return { start: { line: s, column: n + 1 } };
}
}
var Ei = { parse: ki, astFormat: 'glimmer', locStart: St, locEnd: re };
var wi = { glimmer: hs };
var Do = Pr;
export { Do as default, ps as languages, xr as parsers, wi as printers };