Formatted version to save your eyes:
function o(n) {
function t() {
return {
name: 'Ember.JS, Glimmer',
aliases:
['glimmer', 'hbs', 'html.hbs', 'html.handlebars', 'htmlbars'],
case_insensitive: !0, keywords: E, disableAutodetect: !0, contains: [
n.COMMENT(/\{\{!--/, /--\}\}/), n.COMMENT(/\{\{!/, /\}\}/),
n.COMMENT(/<!--/, /-->/), d, ...l, g, u, S, ...H
]
}
}
let E = {
$pattern: /\b[\w][\w-]+\b/,
keyword: ''.concat('outlet yield', ' ')
.concat('action on', ' ')
.concat('log debugger'),
built_in: 'let each each-in if else unless',
function:
''.concat('not-eq xor is-array is-object is-equal', ' ')
.concat(
'has-block concat fn component helper modifier get hash query-params',
' ')
.concat('eq neq', ' ')
.concat('gt gte le lte', ' ')
.concat('and or not'),
literal: 'true false undefined null'
},
f = e.either(
e.concat(/[a-zA-Z_]/, e.optional(/[A-Z0-9:_.-]*:/), /[A-Z0-9_.-]*/),
/[a-z]/),
_ = /[A-Z][A-Za-z0-9]+/,
I = e.either(
_, /[a-zA-Z0-9]*\.[a-zA-Z0-9-]*/, e.concat(_, /::/, /-?/, _),
/[a-z]/),
P = /[a-z-][a-z\d-_]+\b/, C = /[@A-Za-z0-9._:-]+/,
d = {className: 'symbol', begin: /&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/},
G = {
className: 'punctuation',
match: e.either(
/\./, /\{\{\{?#?\/?/, /\}\}\}?/, /\(/, /\)/, /::/, /\|/, /~/)
},
L = {
begin: /as\s+\|/,
keywords: {keyword: 'as'},
end: /\|/,
contains: [{className: 'template-variable', begin: C}]
},
g = {className: 'operator', match: /=/}, u = {
className: {1: 'punctuation', 2: 'params'},
match: [/@/, /[\w\d-_]+/]
},
N = {
className: {1: 'attribute', 2: 'operator'},
match: [/[A-Za-z0-9-_]+/, /=/]
},
R = {
className: {1: 'class', 2: 'punctuation', 3: 'property'},
match: [/this/, /\./, /[^\s}]+/]
},
A = {className: 'title', match: I},
U = {className: 'title', match: P, keywords: E},
x = {className: 'number', match: /[\d]+((\.[\d]+))?/}, S = {
className: 'comment',
begin: /\{\{!--/,
contains: [
{className: 'comment', match: /.+/}, {begin: /--\}\}/, endsParent: !0}
]
},
m = {
className: 'string',
variants: [
{begin: /"/, end: /"/, contains: [d]},
{begin: /'/, end: /'/, contains: [d]}
]
},
p = [G, g, u, x, L, R, N, U, m], O = {
keywords: E,
begin: e.concat(/\(/, e.lookahead(e.concat(/\)/))),
end: /\)/,
contains: [...p, 'self', {begin: /\)/, endsParent: !0}]
};
p.push(O);
let l = [{
className: 'punctuation mustache',
keywords: E,
begin: e.concat(/\{\{\{?#?/),
end: /\}\}\}?/,
contains: [{begin: /\}\}\}?/, endsParent: !0}, ...p, O]
}];
m.variants.forEach(v => v.contains.push(...l));
let H = [
{
className: 'tag',
begin: e.concat(
/<:?/, e.lookahead(e.concat('style', e.either(/\/>/, />/, /\s/)))),
end: /\/?>/,
contains: [g, u, S, L, R, ...l, N, m, A],
starts: {
className: 'tag',
end: /<\/style>/,
returnEnd: !0,
excludeEnd: !1,
subLanguage: ['css', 'glimmer']
}
},
{
className: 'tag',
begin:
e.concat(/<:?/, e.lookahead(e.concat(f, e.either(/\/>/, />/, /\s/)))),
end: /\/?>/,
contains: [g, u, S, L, R, ...l, N, m, A]
},
{
className: 'tag',
begin: e.concat(/<\/:?/, e.lookahead(e.concat(f, />/))),
end: />/,
contains: [A]
}
];
return t()
}
function y(n) {
return T('(?=', n, ')')
}
function w(n) {
return T('(', n, ')?')
}
function T(...n) {
return n.map(a => M(a)).join('')
}
function j(...n) {
return '(' + n.map(a => M(a)).join('|') + ')'
}
function M(n) {
return n ? typeof n == 'string' ? n : n.source : null
}
var e = {lookahead: y, either: j, optional: w, concat: T};
var k = ['css`', '.?css`'];
function B(n, t) {
let s = t.rawDefinition(n).contains.find(
c => k.includes(c == null ? void 0 : c.begin)),
i = n.inherit(s, {begin: /hbs`/});
return i.starts.subLanguage = 'glimmer', i
}
var r = {
begin: /<template>/,
end: /<\/template>/,
isTrulyOpeningTag: (n, t) => {
let a = n[0].length + n.index, s = n.input[a];
if (s === '<' || s === ',') {
t.ignoreMatch();
return
}
let i;
if ((i = n.input.substring(a).match(/^\s+extends\s+/)) && i.index === 0) {
t.ignoreMatch();
return
}
}
},
z = {
variants: [{begin: r.begin, 'on:begin': r.isTrulyOpeningTag, end: r.end}],
subLanguage: 'glimmer',
contains: [{begin: r.begin, end: r.end, skip: !0, contains: ['self']}]
};
function b(n, t = 'javascript') {
let a = n.getLanguage(t);
if (!a) {
console.warn(
'JavaScript grammar not loaded. Cannot initialize glimmerJavascript.');
return
}
return {
name: 'glimmer-javascript', aliases: ['glimmer-js', 'gjs'], subLanguage: t,
contains: [z, B(n, a)]
}
}
var tn = o, J = b;
function an(n) {
Z(n), h(n)
}
function sn(n) {
let t = o(n);
return h(n), t
}
function Z(n) {
return n.registerLanguage('glimmer', o)
}
function h(n) {
$(n)
}
function $(n) {
let t = '_js-in-gjs', a = n.getLanguage('javascript');
n.registerLanguage(t, s => a.rawDefinition(s)),
n.unregisterLanguage('javascript'),
n.registerLanguage('glimmer-javascript', s => {
let i = J(s, t);
return i.aliases.push('javascript', 'js', 'mjs', 'cjs', 'mjs'), i
})
}
export {
sn as externalSetup,
tn as glimmer,
J as glimmerJavascript,
h as registerInjections,
Z as registerLanguage,
an as setup
};
