@salesforcedevs/dx-components 1.18.5 → 1.18.8-layoutfix-alpha
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +4 -4
- package/src/modules/dx/codeBlock/codeBlock.css +16 -10
- package/src/modules/dx/codeBlock/codeBlock.ts +81 -71
- package/src/modules/dx/mainContentHeader/mainContentHeader.html +2 -0
- package/src/modules/dx/mainContentHeader/mainContentHeader.ts +1 -1
- package/src/modules/dx/toc/toc.css +1 -1
- package/src/modules/dxHelpers/code/code.css +19 -87
- package/src/modules/dxUtils/shiki/__mocks__/shiki.ts +110 -0
- package/src/modules/dxUtils/shiki/__mocks__/shikijs.ts +23 -0
- package/src/modules/dxUtils/shiki/customLanguages/afscript.tmLanguage.json +855 -0
- package/src/modules/dxUtils/shiki/customLanguages/ampscript.tmLanguage.json +176 -0
- package/src/modules/dxUtils/shiki/customLanguages/dataweave.tmLanguage.json +1130 -0
- package/src/modules/dxUtils/shiki/shiki.html +3 -0
- package/src/modules/dxUtils/shiki/shiki.ts +210 -0
- package/LICENSE +0 -12
- package/src/modules/dx/codeBlock/customLanguages.js +0 -48
- package/src/modules/dx/codeBlock/darkAndLightThemes.css +0 -177
- package/src/modules/dxUtils/prismjs/prismjs.html +0 -3
- package/src/modules/dxUtils/prismjs/prismjs.ts +0 -4183
|
@@ -1,4183 +0,0 @@
|
|
|
1
|
-
/* eslint-disable */
|
|
2
|
-
/* prettier-ignore */
|
|
3
|
-
// @ts-nocheck
|
|
4
|
-
var commonjsGlobal =
|
|
5
|
-
typeof globalThis !== "undefined"
|
|
6
|
-
? globalThis
|
|
7
|
-
: typeof window !== "undefined"
|
|
8
|
-
? window
|
|
9
|
-
: typeof global !== "undefined"
|
|
10
|
-
? global
|
|
11
|
-
: typeof self !== "undefined"
|
|
12
|
-
? self
|
|
13
|
-
: {};
|
|
14
|
-
|
|
15
|
-
function createCommonjsModule(fn, basedir, module) {
|
|
16
|
-
return (
|
|
17
|
-
(module = {
|
|
18
|
-
path: basedir,
|
|
19
|
-
exports: {},
|
|
20
|
-
require: function (path, base) {
|
|
21
|
-
return commonjsRequire(
|
|
22
|
-
path,
|
|
23
|
-
base === undefined || base === null ? module.path : base
|
|
24
|
-
);
|
|
25
|
-
}
|
|
26
|
-
}),
|
|
27
|
-
fn(module, module.exports),
|
|
28
|
-
module.exports
|
|
29
|
-
);
|
|
30
|
-
}
|
|
31
|
-
|
|
32
|
-
function commonjsRequire() {
|
|
33
|
-
throw new Error(
|
|
34
|
-
"Dynamic requires are not currently supported by @rollup/plugin-commonjs"
|
|
35
|
-
);
|
|
36
|
-
}
|
|
37
|
-
//Start autogenerated code
|
|
38
|
-
var prism = createCommonjsModule(function (module) {
|
|
39
|
-
/* PrismJS 1.29.0
|
|
40
|
-
https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+apex+aspnet+bash+basic+c+csharp+cpp+css-extras+dataweave+graphql+handlebars+hcl+java+javadoc+javadoclike+jsdoc+js-extras+json+json5+jsonp+jsstacktrace+kotlin+markdown+markup-templating+objectivec+php+phpdoc+php-extras+plsql+python+jsx+regex+sql+swift+typescript+typoscript+uri+vbnet+yaml&plugins=unescaped-markup+match-braces */
|
|
41
|
-
var _self =
|
|
42
|
-
"undefined" != typeof window
|
|
43
|
-
? window
|
|
44
|
-
: "undefined" != typeof WorkerGlobalScope &&
|
|
45
|
-
self instanceof WorkerGlobalScope
|
|
46
|
-
? self
|
|
47
|
-
: {},
|
|
48
|
-
Prism = (function (e) {
|
|
49
|
-
var n = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i,
|
|
50
|
-
t = 0,
|
|
51
|
-
r = {},
|
|
52
|
-
a = {
|
|
53
|
-
manual: e.Prism && e.Prism.manual,
|
|
54
|
-
disableWorkerMessageHandler:
|
|
55
|
-
e.Prism && e.Prism.disableWorkerMessageHandler,
|
|
56
|
-
util: {
|
|
57
|
-
encode: function e(n) {
|
|
58
|
-
return n instanceof i
|
|
59
|
-
? new i(n.type, e(n.content), n.alias)
|
|
60
|
-
: Array.isArray(n)
|
|
61
|
-
? n.map(e)
|
|
62
|
-
: n
|
|
63
|
-
.replace(/&/g, "&")
|
|
64
|
-
.replace(/</g, "<")
|
|
65
|
-
.replace(/\u00a0/g, " ");
|
|
66
|
-
},
|
|
67
|
-
type: function (e) {
|
|
68
|
-
return Object.prototype.toString
|
|
69
|
-
.call(e)
|
|
70
|
-
.slice(8, -1);
|
|
71
|
-
},
|
|
72
|
-
objId: function (e) {
|
|
73
|
-
return (
|
|
74
|
-
e.__id ||
|
|
75
|
-
Object.defineProperty(e, "__id", {
|
|
76
|
-
value: ++t
|
|
77
|
-
}),
|
|
78
|
-
e.__id
|
|
79
|
-
);
|
|
80
|
-
},
|
|
81
|
-
clone: function e(n, t) {
|
|
82
|
-
var r, i;
|
|
83
|
-
switch (((t = t || {}), a.util.type(n))) {
|
|
84
|
-
case "Object":
|
|
85
|
-
if (((i = a.util.objId(n)), t[i]))
|
|
86
|
-
return t[i];
|
|
87
|
-
for (var l in ((r = {}), (t[i] = r), n))
|
|
88
|
-
n.hasOwnProperty(l) &&
|
|
89
|
-
(r[l] = e(n[l], t));
|
|
90
|
-
return r;
|
|
91
|
-
case "Array":
|
|
92
|
-
return (
|
|
93
|
-
(i = a.util.objId(n)),
|
|
94
|
-
t[i]
|
|
95
|
-
? t[i]
|
|
96
|
-
: ((r = []),
|
|
97
|
-
(t[i] = r),
|
|
98
|
-
n.forEach(function (n, a) {
|
|
99
|
-
r[a] = e(n, t);
|
|
100
|
-
}),
|
|
101
|
-
r)
|
|
102
|
-
);
|
|
103
|
-
default:
|
|
104
|
-
return n;
|
|
105
|
-
}
|
|
106
|
-
},
|
|
107
|
-
getLanguage: function (e) {
|
|
108
|
-
for (; e; ) {
|
|
109
|
-
var t = n.exec(e.className);
|
|
110
|
-
if (t) return t[1].toLowerCase();
|
|
111
|
-
e = e.parentElement;
|
|
112
|
-
}
|
|
113
|
-
return "none";
|
|
114
|
-
},
|
|
115
|
-
setLanguage: function (e, t) {
|
|
116
|
-
(e.className = e.className.replace(
|
|
117
|
-
RegExp(n, "gi"),
|
|
118
|
-
""
|
|
119
|
-
)),
|
|
120
|
-
e.classList.add("language-" + t);
|
|
121
|
-
},
|
|
122
|
-
currentScript: function () {
|
|
123
|
-
if ("undefined" == typeof document) return null;
|
|
124
|
-
if ("currentScript" in document)
|
|
125
|
-
return document.currentScript;
|
|
126
|
-
try {
|
|
127
|
-
throw new Error();
|
|
128
|
-
} catch (r) {
|
|
129
|
-
var e =
|
|
130
|
-
(/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(
|
|
131
|
-
r.stack
|
|
132
|
-
) || [])[1];
|
|
133
|
-
if (e) {
|
|
134
|
-
var n =
|
|
135
|
-
document.getElementsByTagName("script");
|
|
136
|
-
for (var t in n)
|
|
137
|
-
if (n[t].src == e) return n[t];
|
|
138
|
-
}
|
|
139
|
-
return null;
|
|
140
|
-
}
|
|
141
|
-
},
|
|
142
|
-
isActive: function (e, n, t) {
|
|
143
|
-
for (var r = "no-" + n; e; ) {
|
|
144
|
-
var a = e.classList;
|
|
145
|
-
if (a.contains(n)) return !0;
|
|
146
|
-
if (a.contains(r)) return !1;
|
|
147
|
-
e = e.parentElement;
|
|
148
|
-
}
|
|
149
|
-
return !!t;
|
|
150
|
-
}
|
|
151
|
-
},
|
|
152
|
-
languages: {
|
|
153
|
-
plain: r,
|
|
154
|
-
plaintext: r,
|
|
155
|
-
text: r,
|
|
156
|
-
txt: r,
|
|
157
|
-
extend: function (e, n) {
|
|
158
|
-
var t = a.util.clone(a.languages[e]);
|
|
159
|
-
for (var r in n) t[r] = n[r];
|
|
160
|
-
return t;
|
|
161
|
-
},
|
|
162
|
-
insertBefore: function (e, n, t, r) {
|
|
163
|
-
var i = (r = r || a.languages)[e],
|
|
164
|
-
l = {};
|
|
165
|
-
for (var o in i)
|
|
166
|
-
if (i.hasOwnProperty(o)) {
|
|
167
|
-
if (o == n)
|
|
168
|
-
for (var s in t)
|
|
169
|
-
t.hasOwnProperty(s) &&
|
|
170
|
-
(l[s] = t[s]);
|
|
171
|
-
t.hasOwnProperty(o) || (l[o] = i[o]);
|
|
172
|
-
}
|
|
173
|
-
var u = r[e];
|
|
174
|
-
return (
|
|
175
|
-
(r[e] = l),
|
|
176
|
-
a.languages.DFS(a.languages, function (n, t) {
|
|
177
|
-
t === u && n != e && (this[n] = l);
|
|
178
|
-
}),
|
|
179
|
-
l
|
|
180
|
-
);
|
|
181
|
-
},
|
|
182
|
-
DFS: function e(n, t, r, i) {
|
|
183
|
-
i = i || {};
|
|
184
|
-
var l = a.util.objId;
|
|
185
|
-
for (var o in n)
|
|
186
|
-
if (n.hasOwnProperty(o)) {
|
|
187
|
-
t.call(n, o, n[o], r || o);
|
|
188
|
-
var s = n[o],
|
|
189
|
-
u = a.util.type(s);
|
|
190
|
-
"Object" !== u || i[l(s)]
|
|
191
|
-
? "Array" !== u ||
|
|
192
|
-
i[l(s)] ||
|
|
193
|
-
((i[l(s)] = !0), e(s, t, o, i))
|
|
194
|
-
: ((i[l(s)] = !0), e(s, t, null, i));
|
|
195
|
-
}
|
|
196
|
-
}
|
|
197
|
-
},
|
|
198
|
-
plugins: {},
|
|
199
|
-
highlightAll: function (e, n) {
|
|
200
|
-
a.highlightAllUnder(document, e, n);
|
|
201
|
-
},
|
|
202
|
-
highlightAllUnder: function (e, n, t) {
|
|
203
|
-
var r = {
|
|
204
|
-
callback: t,
|
|
205
|
-
container: e,
|
|
206
|
-
selector:
|
|
207
|
-
'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
|
|
208
|
-
};
|
|
209
|
-
a.hooks.run("before-highlightall", r),
|
|
210
|
-
(r.elements = Array.prototype.slice.apply(
|
|
211
|
-
r.container.querySelectorAll(r.selector)
|
|
212
|
-
)),
|
|
213
|
-
a.hooks.run("before-all-elements-highlight", r);
|
|
214
|
-
for (var i, l = 0; (i = r.elements[l++]); )
|
|
215
|
-
a.highlightElement(i, !0 === n, r.callback);
|
|
216
|
-
},
|
|
217
|
-
highlightElement: function (n, t, r) {
|
|
218
|
-
var i = a.util.getLanguage(n),
|
|
219
|
-
l = a.languages[i];
|
|
220
|
-
a.util.setLanguage(n, i);
|
|
221
|
-
var o = n.parentElement;
|
|
222
|
-
o &&
|
|
223
|
-
"pre" === o.nodeName.toLowerCase() &&
|
|
224
|
-
a.util.setLanguage(o, i);
|
|
225
|
-
var s = {
|
|
226
|
-
element: n,
|
|
227
|
-
language: i,
|
|
228
|
-
grammar: l,
|
|
229
|
-
code: n.textContent
|
|
230
|
-
};
|
|
231
|
-
function u(e) {
|
|
232
|
-
(s.highlightedCode = e),
|
|
233
|
-
a.hooks.run("before-insert", s),
|
|
234
|
-
(s.element.innerHTML = s.highlightedCode),
|
|
235
|
-
a.hooks.run("after-highlight", s),
|
|
236
|
-
a.hooks.run("complete", s),
|
|
237
|
-
r && r.call(s.element);
|
|
238
|
-
}
|
|
239
|
-
if (
|
|
240
|
-
(a.hooks.run("before-sanity-check", s),
|
|
241
|
-
(o = s.element.parentElement) &&
|
|
242
|
-
"pre" === o.nodeName.toLowerCase() &&
|
|
243
|
-
!o.hasAttribute("tabindex") &&
|
|
244
|
-
o.setAttribute("tabindex", "0"),
|
|
245
|
-
!s.code)
|
|
246
|
-
)
|
|
247
|
-
return (
|
|
248
|
-
a.hooks.run("complete", s),
|
|
249
|
-
void (r && r.call(s.element))
|
|
250
|
-
);
|
|
251
|
-
if ((a.hooks.run("before-highlight", s), s.grammar))
|
|
252
|
-
if (t && e.Worker) {
|
|
253
|
-
var c = new Worker(a.filename);
|
|
254
|
-
(c.onmessage = function (e) {
|
|
255
|
-
u(e.data);
|
|
256
|
-
}),
|
|
257
|
-
c.postMessage(
|
|
258
|
-
JSON.stringify({
|
|
259
|
-
language: s.language,
|
|
260
|
-
code: s.code,
|
|
261
|
-
immediateClose: !0
|
|
262
|
-
})
|
|
263
|
-
);
|
|
264
|
-
} else
|
|
265
|
-
u(a.highlight(s.code, s.grammar, s.language));
|
|
266
|
-
else u(a.util.encode(s.code));
|
|
267
|
-
},
|
|
268
|
-
highlight: function (e, n, t) {
|
|
269
|
-
var r = { code: e, grammar: n, language: t };
|
|
270
|
-
if ((a.hooks.run("before-tokenize", r), !r.grammar))
|
|
271
|
-
throw new Error(
|
|
272
|
-
'The language "' +
|
|
273
|
-
r.language +
|
|
274
|
-
'" has no grammar.'
|
|
275
|
-
);
|
|
276
|
-
return (
|
|
277
|
-
(r.tokens = a.tokenize(r.code, r.grammar)),
|
|
278
|
-
a.hooks.run("after-tokenize", r),
|
|
279
|
-
i.stringify(a.util.encode(r.tokens), r.language)
|
|
280
|
-
);
|
|
281
|
-
},
|
|
282
|
-
tokenize: function (e, n) {
|
|
283
|
-
var t = n.rest;
|
|
284
|
-
if (t) {
|
|
285
|
-
for (var r in t) n[r] = t[r];
|
|
286
|
-
delete n.rest;
|
|
287
|
-
}
|
|
288
|
-
var a = new s();
|
|
289
|
-
return (
|
|
290
|
-
u(a, a.head, e),
|
|
291
|
-
o(e, a, n, a.head, 0),
|
|
292
|
-
(function (e) {
|
|
293
|
-
for (
|
|
294
|
-
var n = [], t = e.head.next;
|
|
295
|
-
t !== e.tail;
|
|
296
|
-
|
|
297
|
-
)
|
|
298
|
-
n.push(t.value), (t = t.next);
|
|
299
|
-
return n;
|
|
300
|
-
})(a)
|
|
301
|
-
);
|
|
302
|
-
},
|
|
303
|
-
hooks: {
|
|
304
|
-
all: {},
|
|
305
|
-
add: function (e, n) {
|
|
306
|
-
var t = a.hooks.all;
|
|
307
|
-
(t[e] = t[e] || []), t[e].push(n);
|
|
308
|
-
},
|
|
309
|
-
run: function (e, n) {
|
|
310
|
-
var t = a.hooks.all[e];
|
|
311
|
-
if (t && t.length)
|
|
312
|
-
for (var r, i = 0; (r = t[i++]); ) r(n);
|
|
313
|
-
}
|
|
314
|
-
},
|
|
315
|
-
Token: i
|
|
316
|
-
};
|
|
317
|
-
function i(e, n, t, r) {
|
|
318
|
-
(this.type = e),
|
|
319
|
-
(this.content = n),
|
|
320
|
-
(this.alias = t),
|
|
321
|
-
(this.length = 0 | (r || "").length);
|
|
322
|
-
}
|
|
323
|
-
function l(e, n, t, r) {
|
|
324
|
-
e.lastIndex = n;
|
|
325
|
-
var a = e.exec(t);
|
|
326
|
-
if (a && r && a[1]) {
|
|
327
|
-
var i = a[1].length;
|
|
328
|
-
(a.index += i), (a[0] = a[0].slice(i));
|
|
329
|
-
}
|
|
330
|
-
return a;
|
|
331
|
-
}
|
|
332
|
-
function o(e, n, t, r, s, g) {
|
|
333
|
-
for (var f in t)
|
|
334
|
-
if (t.hasOwnProperty(f) && t[f]) {
|
|
335
|
-
var h = t[f];
|
|
336
|
-
h = Array.isArray(h) ? h : [h];
|
|
337
|
-
for (var d = 0; d < h.length; ++d) {
|
|
338
|
-
if (g && g.cause == f + "," + d) return;
|
|
339
|
-
var v = h[d],
|
|
340
|
-
p = v.inside,
|
|
341
|
-
m = !!v.lookbehind,
|
|
342
|
-
y = !!v.greedy,
|
|
343
|
-
k = v.alias;
|
|
344
|
-
if (y && !v.pattern.global) {
|
|
345
|
-
var x = v.pattern
|
|
346
|
-
.toString()
|
|
347
|
-
.match(/[imsuy]*$/)[0];
|
|
348
|
-
v.pattern = RegExp(v.pattern.source, x + "g");
|
|
349
|
-
}
|
|
350
|
-
for (
|
|
351
|
-
var b = v.pattern || v, w = r.next, A = s;
|
|
352
|
-
w !== n.tail && !(g && A >= g.reach);
|
|
353
|
-
A += w.value.length, w = w.next
|
|
354
|
-
) {
|
|
355
|
-
var E = w.value;
|
|
356
|
-
if (n.length > e.length) return;
|
|
357
|
-
if (!(E instanceof i)) {
|
|
358
|
-
var P,
|
|
359
|
-
L = 1;
|
|
360
|
-
if (y) {
|
|
361
|
-
if (
|
|
362
|
-
!(P = l(b, A, e, m)) ||
|
|
363
|
-
P.index >= e.length
|
|
364
|
-
)
|
|
365
|
-
break;
|
|
366
|
-
var S = P.index,
|
|
367
|
-
O = P.index + P[0].length,
|
|
368
|
-
j = A;
|
|
369
|
-
for (j += w.value.length; S >= j; )
|
|
370
|
-
j += (w = w.next).value.length;
|
|
371
|
-
if (
|
|
372
|
-
((A = j -= w.value.length),
|
|
373
|
-
w.value instanceof i)
|
|
374
|
-
)
|
|
375
|
-
continue;
|
|
376
|
-
for (
|
|
377
|
-
var C = w;
|
|
378
|
-
C !== n.tail &&
|
|
379
|
-
(j < O ||
|
|
380
|
-
"string" == typeof C.value);
|
|
381
|
-
C = C.next
|
|
382
|
-
)
|
|
383
|
-
L++, (j += C.value.length);
|
|
384
|
-
L--,
|
|
385
|
-
(E = e.slice(A, j)),
|
|
386
|
-
(P.index -= A);
|
|
387
|
-
} else if (!(P = l(b, 0, E, m))) continue;
|
|
388
|
-
S = P.index;
|
|
389
|
-
var N = P[0],
|
|
390
|
-
_ = E.slice(0, S),
|
|
391
|
-
M = E.slice(S + N.length),
|
|
392
|
-
W = A + E.length;
|
|
393
|
-
g && W > g.reach && (g.reach = W);
|
|
394
|
-
var z = w.prev;
|
|
395
|
-
if (
|
|
396
|
-
(_ &&
|
|
397
|
-
((z = u(n, z, _)), (A += _.length)),
|
|
398
|
-
c(n, z, L),
|
|
399
|
-
(w = u(
|
|
400
|
-
n,
|
|
401
|
-
z,
|
|
402
|
-
new i(
|
|
403
|
-
f,
|
|
404
|
-
p ? a.tokenize(N, p) : N,
|
|
405
|
-
k,
|
|
406
|
-
N
|
|
407
|
-
)
|
|
408
|
-
)),
|
|
409
|
-
M && u(n, w, M),
|
|
410
|
-
L > 1)
|
|
411
|
-
) {
|
|
412
|
-
var I = {
|
|
413
|
-
cause: f + "," + d,
|
|
414
|
-
reach: W
|
|
415
|
-
};
|
|
416
|
-
o(e, n, t, w.prev, A, I),
|
|
417
|
-
g &&
|
|
418
|
-
I.reach > g.reach &&
|
|
419
|
-
(g.reach = I.reach);
|
|
420
|
-
}
|
|
421
|
-
}
|
|
422
|
-
}
|
|
423
|
-
}
|
|
424
|
-
}
|
|
425
|
-
}
|
|
426
|
-
function s() {
|
|
427
|
-
var e = { value: null, prev: null, next: null },
|
|
428
|
-
n = { value: null, prev: e, next: null };
|
|
429
|
-
(e.next = n),
|
|
430
|
-
(this.head = e),
|
|
431
|
-
(this.tail = n),
|
|
432
|
-
(this.length = 0);
|
|
433
|
-
}
|
|
434
|
-
function u(e, n, t) {
|
|
435
|
-
var r = n.next,
|
|
436
|
-
a = { value: t, prev: n, next: r };
|
|
437
|
-
return (n.next = a), (r.prev = a), e.length++, a;
|
|
438
|
-
}
|
|
439
|
-
function c(e, n, t) {
|
|
440
|
-
for (var r = n.next, a = 0; a < t && r !== e.tail; a++)
|
|
441
|
-
r = r.next;
|
|
442
|
-
(n.next = r), (r.prev = n), (e.length -= a);
|
|
443
|
-
}
|
|
444
|
-
if (
|
|
445
|
-
((e.Prism = a),
|
|
446
|
-
(i.stringify = function e(n, t) {
|
|
447
|
-
if ("string" == typeof n) return n;
|
|
448
|
-
if (Array.isArray(n)) {
|
|
449
|
-
var r = "";
|
|
450
|
-
return (
|
|
451
|
-
n.forEach(function (n) {
|
|
452
|
-
r += e(n, t);
|
|
453
|
-
}),
|
|
454
|
-
r
|
|
455
|
-
);
|
|
456
|
-
}
|
|
457
|
-
var i = {
|
|
458
|
-
type: n.type,
|
|
459
|
-
content: e(n.content, t),
|
|
460
|
-
tag: "span",
|
|
461
|
-
classes: ["token", n.type],
|
|
462
|
-
attributes: {},
|
|
463
|
-
language: t
|
|
464
|
-
},
|
|
465
|
-
l = n.alias;
|
|
466
|
-
l &&
|
|
467
|
-
(Array.isArray(l)
|
|
468
|
-
? Array.prototype.push.apply(i.classes, l)
|
|
469
|
-
: i.classes.push(l)),
|
|
470
|
-
a.hooks.run("wrap", i);
|
|
471
|
-
var o = "";
|
|
472
|
-
for (var s in i.attributes)
|
|
473
|
-
o +=
|
|
474
|
-
" " +
|
|
475
|
-
s +
|
|
476
|
-
'="' +
|
|
477
|
-
(i.attributes[s] || "").replace(/"/g, """) +
|
|
478
|
-
'"';
|
|
479
|
-
return (
|
|
480
|
-
"<" +
|
|
481
|
-
i.tag +
|
|
482
|
-
' class="' +
|
|
483
|
-
i.classes.join(" ") +
|
|
484
|
-
'"' +
|
|
485
|
-
o +
|
|
486
|
-
">" +
|
|
487
|
-
i.content +
|
|
488
|
-
"</" +
|
|
489
|
-
i.tag +
|
|
490
|
-
">"
|
|
491
|
-
);
|
|
492
|
-
}),
|
|
493
|
-
!e.document)
|
|
494
|
-
)
|
|
495
|
-
return e.addEventListener
|
|
496
|
-
? (a.disableWorkerMessageHandler ||
|
|
497
|
-
e.addEventListener(
|
|
498
|
-
"message",
|
|
499
|
-
function (n) {
|
|
500
|
-
var t = JSON.parse(n.data),
|
|
501
|
-
r = t.language,
|
|
502
|
-
i = t.code,
|
|
503
|
-
l = t.immediateClose;
|
|
504
|
-
e.postMessage(
|
|
505
|
-
a.highlight(i, a.languages[r], r)
|
|
506
|
-
),
|
|
507
|
-
l && e.close();
|
|
508
|
-
},
|
|
509
|
-
!1
|
|
510
|
-
),
|
|
511
|
-
a)
|
|
512
|
-
: a;
|
|
513
|
-
var g = a.util.currentScript();
|
|
514
|
-
function f() {
|
|
515
|
-
a.manual || a.highlightAll();
|
|
516
|
-
}
|
|
517
|
-
if (
|
|
518
|
-
(g &&
|
|
519
|
-
((a.filename = g.src),
|
|
520
|
-
g.hasAttribute("data-manual") && (a.manual = !0)),
|
|
521
|
-
!a.manual)
|
|
522
|
-
) {
|
|
523
|
-
var h = document.readyState;
|
|
524
|
-
"loading" === h || ("interactive" === h && g && g.defer)
|
|
525
|
-
? document.addEventListener("DOMContentLoaded", f)
|
|
526
|
-
: window.requestAnimationFrame
|
|
527
|
-
? window.requestAnimationFrame(f)
|
|
528
|
-
: window.setTimeout(f, 16);
|
|
529
|
-
}
|
|
530
|
-
return a;
|
|
531
|
-
})(_self);
|
|
532
|
-
"undefined" != typeof module && module.exports && (module.exports = Prism),
|
|
533
|
-
"undefined" != typeof global && (global.Prism = Prism);
|
|
534
|
-
(Prism.languages.markup = {
|
|
535
|
-
comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy: !0 },
|
|
536
|
-
prolog: { pattern: /<\?[\s\S]+?\?>/, greedy: !0 },
|
|
537
|
-
doctype: {
|
|
538
|
-
pattern:
|
|
539
|
-
/<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
|
|
540
|
-
greedy: !0,
|
|
541
|
-
inside: {
|
|
542
|
-
"internal-subset": {
|
|
543
|
-
pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
|
|
544
|
-
lookbehind: !0,
|
|
545
|
-
greedy: !0,
|
|
546
|
-
inside: null
|
|
547
|
-
},
|
|
548
|
-
string: { pattern: /"[^"]*"|'[^']*'/, greedy: !0 },
|
|
549
|
-
punctuation: /^<!|>$|[[\]]/,
|
|
550
|
-
"doctype-tag": /^DOCTYPE/i,
|
|
551
|
-
name: /[^\s<>'"]+/
|
|
552
|
-
}
|
|
553
|
-
},
|
|
554
|
-
cdata: { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, greedy: !0 },
|
|
555
|
-
tag: {
|
|
556
|
-
pattern:
|
|
557
|
-
/<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
|
|
558
|
-
greedy: !0,
|
|
559
|
-
inside: {
|
|
560
|
-
tag: {
|
|
561
|
-
pattern: /^<\/?[^\s>\/]+/,
|
|
562
|
-
inside: { punctuation: /^<\/?/, namespace: /^[^\s>\/:]+:/ }
|
|
563
|
-
},
|
|
564
|
-
"special-attr": [],
|
|
565
|
-
"attr-value": {
|
|
566
|
-
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
|
|
567
|
-
inside: {
|
|
568
|
-
punctuation: [
|
|
569
|
-
{ pattern: /^=/, alias: "attr-equals" },
|
|
570
|
-
{ pattern: /^(\s*)["']|["']$/, lookbehind: !0 }
|
|
571
|
-
]
|
|
572
|
-
}
|
|
573
|
-
},
|
|
574
|
-
punctuation: /\/?>/,
|
|
575
|
-
"attr-name": {
|
|
576
|
-
pattern: /[^\s>\/]+/,
|
|
577
|
-
inside: { namespace: /^[^\s>\/:]+:/ }
|
|
578
|
-
}
|
|
579
|
-
}
|
|
580
|
-
},
|
|
581
|
-
entity: [
|
|
582
|
-
{ pattern: /&[\da-z]{1,8};/i, alias: "named-entity" },
|
|
583
|
-
/&#x?[\da-f]{1,8};/i
|
|
584
|
-
]
|
|
585
|
-
}),
|
|
586
|
-
(Prism.languages.markup.tag.inside["attr-value"].inside.entity =
|
|
587
|
-
Prism.languages.markup.entity),
|
|
588
|
-
(Prism.languages.markup.doctype.inside["internal-subset"].inside =
|
|
589
|
-
Prism.languages.markup),
|
|
590
|
-
Prism.hooks.add("wrap", function (a) {
|
|
591
|
-
"entity" === a.type &&
|
|
592
|
-
(a.attributes.title = a.content.replace(/&/, "&"));
|
|
593
|
-
}),
|
|
594
|
-
Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
|
|
595
|
-
value: function (a, e) {
|
|
596
|
-
var s = {};
|
|
597
|
-
(s["language-" + e] = {
|
|
598
|
-
pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
|
|
599
|
-
lookbehind: !0,
|
|
600
|
-
inside: Prism.languages[e]
|
|
601
|
-
}),
|
|
602
|
-
(s.cdata = /^<!\[CDATA\[|\]\]>$/i);
|
|
603
|
-
var t = {
|
|
604
|
-
"included-cdata": {
|
|
605
|
-
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
|
606
|
-
inside: s
|
|
607
|
-
}
|
|
608
|
-
};
|
|
609
|
-
t["language-" + e] = {
|
|
610
|
-
pattern: /[\s\S]+/,
|
|
611
|
-
inside: Prism.languages[e]
|
|
612
|
-
};
|
|
613
|
-
var n = {};
|
|
614
|
-
(n[a] = {
|
|
615
|
-
pattern: RegExp(
|
|
616
|
-
"(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[^])*?(?=</__>)".replace(
|
|
617
|
-
/__/g,
|
|
618
|
-
function () {
|
|
619
|
-
return a;
|
|
620
|
-
}
|
|
621
|
-
),
|
|
622
|
-
"i"
|
|
623
|
-
),
|
|
624
|
-
lookbehind: !0,
|
|
625
|
-
greedy: !0,
|
|
626
|
-
inside: t
|
|
627
|
-
}),
|
|
628
|
-
Prism.languages.insertBefore("markup", "cdata", n);
|
|
629
|
-
}
|
|
630
|
-
}),
|
|
631
|
-
Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
|
|
632
|
-
value: function (a, e) {
|
|
633
|
-
Prism.languages.markup.tag.inside["special-attr"].push({
|
|
634
|
-
pattern: RegExp(
|
|
635
|
-
"(^|[\"'\\s])(?:" +
|
|
636
|
-
a +
|
|
637
|
-
")\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))",
|
|
638
|
-
"i"
|
|
639
|
-
),
|
|
640
|
-
lookbehind: !0,
|
|
641
|
-
inside: {
|
|
642
|
-
"attr-name": /^[^\s=]+/,
|
|
643
|
-
"attr-value": {
|
|
644
|
-
pattern: /=[\s\S]+/,
|
|
645
|
-
inside: {
|
|
646
|
-
value: {
|
|
647
|
-
pattern:
|
|
648
|
-
/(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
|
|
649
|
-
lookbehind: !0,
|
|
650
|
-
alias: [e, "language-" + e],
|
|
651
|
-
inside: Prism.languages[e]
|
|
652
|
-
},
|
|
653
|
-
punctuation: [
|
|
654
|
-
{ pattern: /^=/, alias: "attr-equals" },
|
|
655
|
-
/"|'/
|
|
656
|
-
]
|
|
657
|
-
}
|
|
658
|
-
}
|
|
659
|
-
}
|
|
660
|
-
});
|
|
661
|
-
}
|
|
662
|
-
}),
|
|
663
|
-
(Prism.languages.html = Prism.languages.markup),
|
|
664
|
-
(Prism.languages.mathml = Prism.languages.markup),
|
|
665
|
-
(Prism.languages.svg = Prism.languages.markup),
|
|
666
|
-
(Prism.languages.xml = Prism.languages.extend("markup", {})),
|
|
667
|
-
(Prism.languages.ssml = Prism.languages.xml),
|
|
668
|
-
(Prism.languages.atom = Prism.languages.xml),
|
|
669
|
-
(Prism.languages.rss = Prism.languages.xml);
|
|
670
|
-
!(function (s) {
|
|
671
|
-
var e =
|
|
672
|
-
/(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
|
|
673
|
-
(s.languages.css = {
|
|
674
|
-
comment: /\/\*[\s\S]*?\*\//,
|
|
675
|
-
atrule: {
|
|
676
|
-
pattern: RegExp(
|
|
677
|
-
"@[\\w-](?:[^;{\\s\"']|\\s+(?!\\s)|" +
|
|
678
|
-
e.source +
|
|
679
|
-
")*?(?:;|(?=\\s*\\{))"
|
|
680
|
-
),
|
|
681
|
-
inside: {
|
|
682
|
-
rule: /^@[\w-]+/,
|
|
683
|
-
"selector-function-argument": {
|
|
684
|
-
pattern:
|
|
685
|
-
/(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
|
|
686
|
-
lookbehind: !0,
|
|
687
|
-
alias: "selector"
|
|
688
|
-
},
|
|
689
|
-
keyword: {
|
|
690
|
-
pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
|
|
691
|
-
lookbehind: !0
|
|
692
|
-
}
|
|
693
|
-
}
|
|
694
|
-
},
|
|
695
|
-
url: {
|
|
696
|
-
pattern: RegExp(
|
|
697
|
-
"\\burl\\((?:" +
|
|
698
|
-
e.source +
|
|
699
|
-
"|(?:[^\\\\\r\n()\"']|\\\\[^])*)\\)",
|
|
700
|
-
"i"
|
|
701
|
-
),
|
|
702
|
-
greedy: !0,
|
|
703
|
-
inside: {
|
|
704
|
-
function: /^url/i,
|
|
705
|
-
punctuation: /^\(|\)$/,
|
|
706
|
-
string: {
|
|
707
|
-
pattern: RegExp("^" + e.source + "$"),
|
|
708
|
-
alias: "url"
|
|
709
|
-
}
|
|
710
|
-
}
|
|
711
|
-
},
|
|
712
|
-
selector: {
|
|
713
|
-
pattern: RegExp(
|
|
714
|
-
"(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" +
|
|
715
|
-
e.source +
|
|
716
|
-
")*(?=\\s*\\{)"
|
|
717
|
-
),
|
|
718
|
-
lookbehind: !0
|
|
719
|
-
},
|
|
720
|
-
string: { pattern: e, greedy: !0 },
|
|
721
|
-
property: {
|
|
722
|
-
pattern:
|
|
723
|
-
/(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
|
|
724
|
-
lookbehind: !0
|
|
725
|
-
},
|
|
726
|
-
important: /!important\b/i,
|
|
727
|
-
function: {
|
|
728
|
-
pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
|
|
729
|
-
lookbehind: !0
|
|
730
|
-
},
|
|
731
|
-
punctuation: /[(){};:,]/
|
|
732
|
-
}),
|
|
733
|
-
(s.languages.css.atrule.inside.rest = s.languages.css);
|
|
734
|
-
var t = s.languages.markup;
|
|
735
|
-
t &&
|
|
736
|
-
(t.tag.addInlined("style", "css"),
|
|
737
|
-
t.tag.addAttribute("style", "css"));
|
|
738
|
-
})(Prism);
|
|
739
|
-
Prism.languages.clike = {
|
|
740
|
-
comment: [
|
|
741
|
-
{
|
|
742
|
-
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
|
743
|
-
lookbehind: !0,
|
|
744
|
-
greedy: !0
|
|
745
|
-
},
|
|
746
|
-
{ pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }
|
|
747
|
-
],
|
|
748
|
-
string: {
|
|
749
|
-
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
|
|
750
|
-
greedy: !0
|
|
751
|
-
},
|
|
752
|
-
"class-name": {
|
|
753
|
-
pattern:
|
|
754
|
-
/(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
|
|
755
|
-
lookbehind: !0,
|
|
756
|
-
inside: { punctuation: /[.\\]/ }
|
|
757
|
-
},
|
|
758
|
-
keyword:
|
|
759
|
-
/\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
|
|
760
|
-
boolean: /\b(?:false|true)\b/,
|
|
761
|
-
function: /\b\w+(?=\()/,
|
|
762
|
-
number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
|
|
763
|
-
operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
|
|
764
|
-
punctuation: /[{}[\];(),.:]/
|
|
765
|
-
};
|
|
766
|
-
(Prism.languages.javascript = Prism.languages.extend("clike", {
|
|
767
|
-
"class-name": [
|
|
768
|
-
Prism.languages.clike["class-name"],
|
|
769
|
-
{
|
|
770
|
-
pattern:
|
|
771
|
-
/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
|
|
772
|
-
lookbehind: !0
|
|
773
|
-
}
|
|
774
|
-
],
|
|
775
|
-
keyword: [
|
|
776
|
-
{ pattern: /((?:^|\})\s*)catch\b/, lookbehind: !0 },
|
|
777
|
-
{
|
|
778
|
-
pattern:
|
|
779
|
-
/(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
|
|
780
|
-
lookbehind: !0
|
|
781
|
-
}
|
|
782
|
-
],
|
|
783
|
-
function:
|
|
784
|
-
/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
|
|
785
|
-
number: {
|
|
786
|
-
pattern: RegExp(
|
|
787
|
-
"(^|[^\\w$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"
|
|
788
|
-
),
|
|
789
|
-
lookbehind: !0
|
|
790
|
-
},
|
|
791
|
-
operator:
|
|
792
|
-
/--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
|
|
793
|
-
})),
|
|
794
|
-
(Prism.languages.javascript["class-name"][0].pattern =
|
|
795
|
-
/(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/),
|
|
796
|
-
Prism.languages.insertBefore("javascript", "keyword", {
|
|
797
|
-
regex: {
|
|
798
|
-
pattern: RegExp(
|
|
799
|
-
"((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)/(?:(?:\\[(?:[^\\]\\\\\r\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|/\\*(?:[^*]|\\*(?!/))*\\*/)*(?:$|[\r\n,.;:})\\]]|//))"
|
|
800
|
-
),
|
|
801
|
-
lookbehind: !0,
|
|
802
|
-
greedy: !0,
|
|
803
|
-
inside: {
|
|
804
|
-
"regex-source": {
|
|
805
|
-
pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
|
|
806
|
-
lookbehind: !0,
|
|
807
|
-
alias: "language-regex",
|
|
808
|
-
inside: Prism.languages.regex
|
|
809
|
-
},
|
|
810
|
-
"regex-delimiter": /^\/|\/$/,
|
|
811
|
-
"regex-flags": /^[a-z]+$/
|
|
812
|
-
}
|
|
813
|
-
},
|
|
814
|
-
"function-variable": {
|
|
815
|
-
pattern:
|
|
816
|
-
/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
|
|
817
|
-
alias: "function"
|
|
818
|
-
},
|
|
819
|
-
parameter: [
|
|
820
|
-
{
|
|
821
|
-
pattern:
|
|
822
|
-
/(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
|
|
823
|
-
lookbehind: !0,
|
|
824
|
-
inside: Prism.languages.javascript
|
|
825
|
-
},
|
|
826
|
-
{
|
|
827
|
-
pattern:
|
|
828
|
-
/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
|
|
829
|
-
lookbehind: !0,
|
|
830
|
-
inside: Prism.languages.javascript
|
|
831
|
-
},
|
|
832
|
-
{
|
|
833
|
-
pattern:
|
|
834
|
-
/(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
|
|
835
|
-
lookbehind: !0,
|
|
836
|
-
inside: Prism.languages.javascript
|
|
837
|
-
},
|
|
838
|
-
{
|
|
839
|
-
pattern:
|
|
840
|
-
/((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
|
|
841
|
-
lookbehind: !0,
|
|
842
|
-
inside: Prism.languages.javascript
|
|
843
|
-
}
|
|
844
|
-
],
|
|
845
|
-
constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
|
|
846
|
-
}),
|
|
847
|
-
Prism.languages.insertBefore("javascript", "string", {
|
|
848
|
-
hashbang: { pattern: /^#!.*/, greedy: !0, alias: "comment" },
|
|
849
|
-
"template-string": {
|
|
850
|
-
pattern:
|
|
851
|
-
/`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
|
|
852
|
-
greedy: !0,
|
|
853
|
-
inside: {
|
|
854
|
-
"template-punctuation": {
|
|
855
|
-
pattern: /^`|`$/,
|
|
856
|
-
alias: "string"
|
|
857
|
-
},
|
|
858
|
-
interpolation: {
|
|
859
|
-
pattern:
|
|
860
|
-
/((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
|
|
861
|
-
lookbehind: !0,
|
|
862
|
-
inside: {
|
|
863
|
-
"interpolation-punctuation": {
|
|
864
|
-
pattern: /^\$\{|\}$/,
|
|
865
|
-
alias: "punctuation"
|
|
866
|
-
},
|
|
867
|
-
rest: Prism.languages.javascript
|
|
868
|
-
}
|
|
869
|
-
},
|
|
870
|
-
string: /[\s\S]+/
|
|
871
|
-
}
|
|
872
|
-
},
|
|
873
|
-
"string-property": {
|
|
874
|
-
pattern:
|
|
875
|
-
/((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
|
|
876
|
-
lookbehind: !0,
|
|
877
|
-
greedy: !0,
|
|
878
|
-
alias: "property"
|
|
879
|
-
}
|
|
880
|
-
}),
|
|
881
|
-
Prism.languages.insertBefore("javascript", "operator", {
|
|
882
|
-
"literal-property": {
|
|
883
|
-
pattern:
|
|
884
|
-
/((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
|
|
885
|
-
lookbehind: !0,
|
|
886
|
-
alias: "property"
|
|
887
|
-
}
|
|
888
|
-
}),
|
|
889
|
-
Prism.languages.markup &&
|
|
890
|
-
(Prism.languages.markup.tag.addInlined("script", "javascript"),
|
|
891
|
-
Prism.languages.markup.tag.addAttribute(
|
|
892
|
-
"on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)",
|
|
893
|
-
"javascript"
|
|
894
|
-
)),
|
|
895
|
-
(Prism.languages.js = Prism.languages.javascript);
|
|
896
|
-
Prism.languages.sql = {
|
|
897
|
-
comment: {
|
|
898
|
-
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
|
|
899
|
-
lookbehind: !0
|
|
900
|
-
},
|
|
901
|
-
variable: [
|
|
902
|
-
{ pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/, greedy: !0 },
|
|
903
|
-
/@[\w.$]+/
|
|
904
|
-
],
|
|
905
|
-
string: {
|
|
906
|
-
pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/,
|
|
907
|
-
greedy: !0,
|
|
908
|
-
lookbehind: !0
|
|
909
|
-
},
|
|
910
|
-
identifier: {
|
|
911
|
-
pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/,
|
|
912
|
-
greedy: !0,
|
|
913
|
-
lookbehind: !0,
|
|
914
|
-
inside: { punctuation: /^`|`$/ }
|
|
915
|
-
},
|
|
916
|
-
function:
|
|
917
|
-
/\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i,
|
|
918
|
-
keyword:
|
|
919
|
-
/\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i,
|
|
920
|
-
boolean: /\b(?:FALSE|NULL|TRUE)\b/i,
|
|
921
|
-
number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
|
|
922
|
-
operator:
|
|
923
|
-
/[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i,
|
|
924
|
-
punctuation: /[;[\]()`,.]/
|
|
925
|
-
};
|
|
926
|
-
!(function (e) {
|
|
927
|
-
var t =
|
|
928
|
-
/\b(?:(?:after|before)(?=\s+[a-z])|abstract|activate|and|any|array|as|asc|autonomous|begin|bigdecimal|blob|boolean|break|bulk|by|byte|case|cast|catch|char|class|collect|commit|const|continue|currency|date|datetime|decimal|default|delete|desc|do|double|else|end|enum|exception|exit|export|extends|final|finally|float|for|from|get(?=\s*[{};])|global|goto|group|having|hint|if|implements|import|in|inner|insert|instanceof|int|integer|interface|into|join|like|limit|list|long|loop|map|merge|new|not|null|nulls|number|object|of|on|or|outer|override|package|parallel|pragma|private|protected|public|retrieve|return|rollback|select|set|short|sObject|sort|static|string|super|switch|synchronized|system|testmethod|then|this|throw|time|transaction|transient|trigger|try|undelete|update|upsert|using|virtual|void|webservice|when|where|while|(?:inherited|with|without)\s+sharing)\b/i,
|
|
929
|
-
n =
|
|
930
|
-
"\\b(?:(?=[a-z_]\\w*\\s*[<\\[])|(?!<keyword>))[A-Z_]\\w*(?:\\s*\\.\\s*[A-Z_]\\w*)*\\b(?:\\s*(?:\\[\\s*\\]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>))*".replace(
|
|
931
|
-
/<keyword>/g,
|
|
932
|
-
function () {
|
|
933
|
-
return t.source;
|
|
934
|
-
}
|
|
935
|
-
);
|
|
936
|
-
function i(e) {
|
|
937
|
-
return RegExp(
|
|
938
|
-
e.replace(/<CLASS-NAME>/g, function () {
|
|
939
|
-
return n;
|
|
940
|
-
}),
|
|
941
|
-
"i"
|
|
942
|
-
);
|
|
943
|
-
}
|
|
944
|
-
var a = { keyword: t, punctuation: /[()\[\]{};,:.<>]/ };
|
|
945
|
-
e.languages.apex = {
|
|
946
|
-
comment: e.languages.clike.comment,
|
|
947
|
-
string: e.languages.clike.string,
|
|
948
|
-
sql: {
|
|
949
|
-
pattern: /((?:[=,({:]|\breturn)\s*)\[[^\[\]]*\]/i,
|
|
950
|
-
lookbehind: !0,
|
|
951
|
-
greedy: !0,
|
|
952
|
-
alias: "language-sql",
|
|
953
|
-
inside: e.languages.sql
|
|
954
|
-
},
|
|
955
|
-
annotation: { pattern: /@\w+\b/, alias: "punctuation" },
|
|
956
|
-
"class-name": [
|
|
957
|
-
{
|
|
958
|
-
pattern: i(
|
|
959
|
-
"(\\b(?:class|enum|extends|implements|instanceof|interface|new|trigger\\s+\\w+\\s+on)\\s+)<CLASS-NAME>"
|
|
960
|
-
),
|
|
961
|
-
lookbehind: !0,
|
|
962
|
-
inside: a
|
|
963
|
-
},
|
|
964
|
-
{
|
|
965
|
-
pattern: i("(\\(\\s*)<CLASS-NAME>(?=\\s*\\)\\s*[\\w(])"),
|
|
966
|
-
lookbehind: !0,
|
|
967
|
-
inside: a
|
|
968
|
-
},
|
|
969
|
-
{
|
|
970
|
-
pattern: i("<CLASS-NAME>(?=\\s*\\w+\\s*[;=,(){:])"),
|
|
971
|
-
inside: a
|
|
972
|
-
}
|
|
973
|
-
],
|
|
974
|
-
trigger: {
|
|
975
|
-
pattern: /(\btrigger\s+)\w+\b/i,
|
|
976
|
-
lookbehind: !0,
|
|
977
|
-
alias: "class-name"
|
|
978
|
-
},
|
|
979
|
-
keyword: t,
|
|
980
|
-
function: /\b[a-z_]\w*(?=\s*\()/i,
|
|
981
|
-
boolean: /\b(?:false|true)\b/i,
|
|
982
|
-
number: /(?:\B\.\d+|\b\d+(?:\.\d+|L)?)\b/i,
|
|
983
|
-
operator:
|
|
984
|
-
/[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
|
|
985
|
-
punctuation: /[()\[\]{};,.]/
|
|
986
|
-
};
|
|
987
|
-
})(Prism);
|
|
988
|
-
!(function (e) {
|
|
989
|
-
function n(e, n) {
|
|
990
|
-
return e.replace(/<<(\d+)>>/g, function (e, s) {
|
|
991
|
-
return "(?:" + n[+s] + ")";
|
|
992
|
-
});
|
|
993
|
-
}
|
|
994
|
-
function s(e, s, a) {
|
|
995
|
-
return RegExp(n(e, s), a || "");
|
|
996
|
-
}
|
|
997
|
-
function a(e, n) {
|
|
998
|
-
for (var s = 0; s < n; s++)
|
|
999
|
-
e = e.replace(/<<self>>/g, function () {
|
|
1000
|
-
return "(?:" + e + ")";
|
|
1001
|
-
});
|
|
1002
|
-
return e.replace(/<<self>>/g, "[^\\s\\S]");
|
|
1003
|
-
}
|
|
1004
|
-
var t =
|
|
1005
|
-
"bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void",
|
|
1006
|
-
r = "class enum interface record struct",
|
|
1007
|
-
i =
|
|
1008
|
-
"add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)",
|
|
1009
|
-
o =
|
|
1010
|
-
"abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield";
|
|
1011
|
-
function l(e) {
|
|
1012
|
-
return "\\b(?:" + e.trim().replace(/ /g, "|") + ")\\b";
|
|
1013
|
-
}
|
|
1014
|
-
var d = l(r),
|
|
1015
|
-
p = RegExp(l(t + " " + r + " " + i + " " + o)),
|
|
1016
|
-
c = l(r + " " + i + " " + o),
|
|
1017
|
-
u = l(t + " " + r + " " + o),
|
|
1018
|
-
g = a("<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>", 2),
|
|
1019
|
-
b = a("\\((?:[^()]|<<self>>)*\\)", 2),
|
|
1020
|
-
h = "@?\\b[A-Za-z_]\\w*\\b",
|
|
1021
|
-
f = n("<<0>>(?:\\s*<<1>>)?", [h, g]),
|
|
1022
|
-
m = n("(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*", [c, f]),
|
|
1023
|
-
k = "\\[\\s*(?:,\\s*)*\\]",
|
|
1024
|
-
y = n("<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?", [m, k]),
|
|
1025
|
-
w = n("[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>", [g, b, k]),
|
|
1026
|
-
v = n("\\(<<0>>+(?:,<<0>>+)+\\)", [w]),
|
|
1027
|
-
x = n("(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?", [
|
|
1028
|
-
v,
|
|
1029
|
-
m,
|
|
1030
|
-
k
|
|
1031
|
-
]),
|
|
1032
|
-
$ = { keyword: p, punctuation: /[<>()?,.:[\]]/ },
|
|
1033
|
-
_ = "'(?:[^\r\n'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'",
|
|
1034
|
-
B = '"(?:\\\\.|[^\\\\"\r\n])*"';
|
|
1035
|
-
(e.languages.csharp = e.languages.extend("clike", {
|
|
1036
|
-
string: [
|
|
1037
|
-
{
|
|
1038
|
-
pattern: s("(^|[^$\\\\])<<0>>", [
|
|
1039
|
-
'@"(?:""|\\\\[^]|[^\\\\"])*"(?!")'
|
|
1040
|
-
]),
|
|
1041
|
-
lookbehind: !0,
|
|
1042
|
-
greedy: !0
|
|
1043
|
-
},
|
|
1044
|
-
{
|
|
1045
|
-
pattern: s("(^|[^@$\\\\])<<0>>", [B]),
|
|
1046
|
-
lookbehind: !0,
|
|
1047
|
-
greedy: !0
|
|
1048
|
-
}
|
|
1049
|
-
],
|
|
1050
|
-
"class-name": [
|
|
1051
|
-
{
|
|
1052
|
-
pattern: s("(\\busing\\s+static\\s+)<<0>>(?=\\s*;)", [m]),
|
|
1053
|
-
lookbehind: !0,
|
|
1054
|
-
inside: $
|
|
1055
|
-
},
|
|
1056
|
-
{
|
|
1057
|
-
pattern: s("(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)", [
|
|
1058
|
-
h,
|
|
1059
|
-
x
|
|
1060
|
-
]),
|
|
1061
|
-
lookbehind: !0,
|
|
1062
|
-
inside: $
|
|
1063
|
-
},
|
|
1064
|
-
{
|
|
1065
|
-
pattern: s("(\\busing\\s+)<<0>>(?=\\s*=)", [h]),
|
|
1066
|
-
lookbehind: !0
|
|
1067
|
-
},
|
|
1068
|
-
{
|
|
1069
|
-
pattern: s("(\\b<<0>>\\s+)<<1>>", [d, f]),
|
|
1070
|
-
lookbehind: !0,
|
|
1071
|
-
inside: $
|
|
1072
|
-
},
|
|
1073
|
-
{
|
|
1074
|
-
pattern: s("(\\bcatch\\s*\\(\\s*)<<0>>", [m]),
|
|
1075
|
-
lookbehind: !0,
|
|
1076
|
-
inside: $
|
|
1077
|
-
},
|
|
1078
|
-
{ pattern: s("(\\bwhere\\s+)<<0>>", [h]), lookbehind: !0 },
|
|
1079
|
-
{
|
|
1080
|
-
pattern: s("(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>", [y]),
|
|
1081
|
-
lookbehind: !0,
|
|
1082
|
-
inside: $
|
|
1083
|
-
},
|
|
1084
|
-
{
|
|
1085
|
-
pattern: s(
|
|
1086
|
-
"\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))",
|
|
1087
|
-
[x, u, h]
|
|
1088
|
-
),
|
|
1089
|
-
inside: $
|
|
1090
|
-
}
|
|
1091
|
-
],
|
|
1092
|
-
keyword: p,
|
|
1093
|
-
number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
|
|
1094
|
-
operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
|
|
1095
|
-
punctuation: /\?\.?|::|[{}[\];(),.:]/
|
|
1096
|
-
})),
|
|
1097
|
-
e.languages.insertBefore("csharp", "number", {
|
|
1098
|
-
range: { pattern: /\.\./, alias: "operator" }
|
|
1099
|
-
}),
|
|
1100
|
-
e.languages.insertBefore("csharp", "punctuation", {
|
|
1101
|
-
"named-parameter": {
|
|
1102
|
-
pattern: s("([(,]\\s*)<<0>>(?=\\s*:)", [h]),
|
|
1103
|
-
lookbehind: !0,
|
|
1104
|
-
alias: "punctuation"
|
|
1105
|
-
}
|
|
1106
|
-
}),
|
|
1107
|
-
e.languages.insertBefore("csharp", "class-name", {
|
|
1108
|
-
namespace: {
|
|
1109
|
-
pattern: s(
|
|
1110
|
-
"(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])",
|
|
1111
|
-
[h]
|
|
1112
|
-
),
|
|
1113
|
-
lookbehind: !0,
|
|
1114
|
-
inside: { punctuation: /\./ }
|
|
1115
|
-
},
|
|
1116
|
-
"type-expression": {
|
|
1117
|
-
pattern: s(
|
|
1118
|
-
"(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))",
|
|
1119
|
-
[b]
|
|
1120
|
-
),
|
|
1121
|
-
lookbehind: !0,
|
|
1122
|
-
alias: "class-name",
|
|
1123
|
-
inside: $
|
|
1124
|
-
},
|
|
1125
|
-
"return-type": {
|
|
1126
|
-
pattern: s(
|
|
1127
|
-
"<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))",
|
|
1128
|
-
[x, m]
|
|
1129
|
-
),
|
|
1130
|
-
inside: $,
|
|
1131
|
-
alias: "class-name"
|
|
1132
|
-
},
|
|
1133
|
-
"constructor-invocation": {
|
|
1134
|
-
pattern: s("(\\bnew\\s+)<<0>>(?=\\s*[[({])", [x]),
|
|
1135
|
-
lookbehind: !0,
|
|
1136
|
-
inside: $,
|
|
1137
|
-
alias: "class-name"
|
|
1138
|
-
},
|
|
1139
|
-
"generic-method": {
|
|
1140
|
-
pattern: s("<<0>>\\s*<<1>>(?=\\s*\\()", [h, g]),
|
|
1141
|
-
inside: {
|
|
1142
|
-
function: s("^<<0>>", [h]),
|
|
1143
|
-
generic: {
|
|
1144
|
-
pattern: RegExp(g),
|
|
1145
|
-
alias: "class-name",
|
|
1146
|
-
inside: $
|
|
1147
|
-
}
|
|
1148
|
-
}
|
|
1149
|
-
},
|
|
1150
|
-
"type-list": {
|
|
1151
|
-
pattern: s(
|
|
1152
|
-
"\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))",
|
|
1153
|
-
[d, f, h, x, p.source, b, "\\bnew\\s*\\(\\s*\\)"]
|
|
1154
|
-
),
|
|
1155
|
-
lookbehind: !0,
|
|
1156
|
-
inside: {
|
|
1157
|
-
"record-arguments": {
|
|
1158
|
-
pattern: s("(^(?!new\\s*\\()<<0>>\\s*)<<1>>", [
|
|
1159
|
-
f,
|
|
1160
|
-
b
|
|
1161
|
-
]),
|
|
1162
|
-
lookbehind: !0,
|
|
1163
|
-
greedy: !0,
|
|
1164
|
-
inside: e.languages.csharp
|
|
1165
|
-
},
|
|
1166
|
-
keyword: p,
|
|
1167
|
-
"class-name": {
|
|
1168
|
-
pattern: RegExp(x),
|
|
1169
|
-
greedy: !0,
|
|
1170
|
-
inside: $
|
|
1171
|
-
},
|
|
1172
|
-
punctuation: /[,()]/
|
|
1173
|
-
}
|
|
1174
|
-
},
|
|
1175
|
-
preprocessor: {
|
|
1176
|
-
pattern: /(^[\t ]*)#.*/m,
|
|
1177
|
-
lookbehind: !0,
|
|
1178
|
-
alias: "property",
|
|
1179
|
-
inside: {
|
|
1180
|
-
directive: {
|
|
1181
|
-
pattern:
|
|
1182
|
-
/(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
|
|
1183
|
-
lookbehind: !0,
|
|
1184
|
-
alias: "keyword"
|
|
1185
|
-
}
|
|
1186
|
-
}
|
|
1187
|
-
}
|
|
1188
|
-
});
|
|
1189
|
-
var E = B + "|" + _,
|
|
1190
|
-
R = n(
|
|
1191
|
-
"/(?![*/])|//[^\r\n]*[\r\n]|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>",
|
|
1192
|
-
[E]
|
|
1193
|
-
),
|
|
1194
|
-
z = a(n("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [R]), 2),
|
|
1195
|
-
S =
|
|
1196
|
-
"\\b(?:assembly|event|field|method|module|param|property|return|type)\\b",
|
|
1197
|
-
j = n("<<0>>(?:\\s*\\(<<1>>*\\))?", [m, z]);
|
|
1198
|
-
e.languages.insertBefore("csharp", "class-name", {
|
|
1199
|
-
attribute: {
|
|
1200
|
-
pattern: s(
|
|
1201
|
-
"((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])",
|
|
1202
|
-
[S, j]
|
|
1203
|
-
),
|
|
1204
|
-
lookbehind: !0,
|
|
1205
|
-
greedy: !0,
|
|
1206
|
-
inside: {
|
|
1207
|
-
target: {
|
|
1208
|
-
pattern: s("^<<0>>(?=\\s*:)", [S]),
|
|
1209
|
-
alias: "keyword"
|
|
1210
|
-
},
|
|
1211
|
-
"attribute-arguments": {
|
|
1212
|
-
pattern: s("\\(<<0>>*\\)", [z]),
|
|
1213
|
-
inside: e.languages.csharp
|
|
1214
|
-
},
|
|
1215
|
-
"class-name": {
|
|
1216
|
-
pattern: RegExp(m),
|
|
1217
|
-
inside: { punctuation: /\./ }
|
|
1218
|
-
},
|
|
1219
|
-
punctuation: /[:,]/
|
|
1220
|
-
}
|
|
1221
|
-
}
|
|
1222
|
-
});
|
|
1223
|
-
var A = ":[^}\r\n]+",
|
|
1224
|
-
F = a(n("[^\"'/()]|<<0>>|\\(<<self>>*\\)", [R]), 2),
|
|
1225
|
-
P = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [F, A]),
|
|
1226
|
-
U = a(
|
|
1227
|
-
n(
|
|
1228
|
-
"[^\"'/()]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>|\\(<<self>>*\\)",
|
|
1229
|
-
[E]
|
|
1230
|
-
),
|
|
1231
|
-
2
|
|
1232
|
-
),
|
|
1233
|
-
Z = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [U, A]);
|
|
1234
|
-
function q(n, a) {
|
|
1235
|
-
return {
|
|
1236
|
-
interpolation: {
|
|
1237
|
-
pattern: s("((?:^|[^{])(?:\\{\\{)*)<<0>>", [n]),
|
|
1238
|
-
lookbehind: !0,
|
|
1239
|
-
inside: {
|
|
1240
|
-
"format-string": {
|
|
1241
|
-
pattern: s(
|
|
1242
|
-
"(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)",
|
|
1243
|
-
[a, A]
|
|
1244
|
-
),
|
|
1245
|
-
lookbehind: !0,
|
|
1246
|
-
inside: { punctuation: /^:/ }
|
|
1247
|
-
},
|
|
1248
|
-
punctuation: /^\{|\}$/,
|
|
1249
|
-
expression: {
|
|
1250
|
-
pattern: /[\s\S]+/,
|
|
1251
|
-
alias: "language-csharp",
|
|
1252
|
-
inside: e.languages.csharp
|
|
1253
|
-
}
|
|
1254
|
-
}
|
|
1255
|
-
},
|
|
1256
|
-
string: /[\s\S]+/
|
|
1257
|
-
};
|
|
1258
|
-
}
|
|
1259
|
-
e.languages.insertBefore("csharp", "string", {
|
|
1260
|
-
"interpolation-string": [
|
|
1261
|
-
{
|
|
1262
|
-
pattern: s(
|
|
1263
|
-
'(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[^]|\\{\\{|<<0>>|[^\\\\{"])*"',
|
|
1264
|
-
[P]
|
|
1265
|
-
),
|
|
1266
|
-
lookbehind: !0,
|
|
1267
|
-
greedy: !0,
|
|
1268
|
-
inside: q(P, F)
|
|
1269
|
-
},
|
|
1270
|
-
{
|
|
1271
|
-
pattern: s(
|
|
1272
|
-
'(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<<0>>|[^\\\\"{])*"',
|
|
1273
|
-
[Z]
|
|
1274
|
-
),
|
|
1275
|
-
lookbehind: !0,
|
|
1276
|
-
greedy: !0,
|
|
1277
|
-
inside: q(Z, U)
|
|
1278
|
-
}
|
|
1279
|
-
],
|
|
1280
|
-
char: { pattern: RegExp(_), greedy: !0 }
|
|
1281
|
-
}),
|
|
1282
|
-
(e.languages.dotnet = e.languages.cs = e.languages.csharp);
|
|
1283
|
-
})(Prism);
|
|
1284
|
-
(Prism.languages.aspnet = Prism.languages.extend("markup", {
|
|
1285
|
-
"page-directive": {
|
|
1286
|
-
pattern: /<%\s*@.*%>/,
|
|
1287
|
-
alias: "tag",
|
|
1288
|
-
inside: {
|
|
1289
|
-
"page-directive": {
|
|
1290
|
-
pattern:
|
|
1291
|
-
/<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
|
|
1292
|
-
alias: "tag"
|
|
1293
|
-
},
|
|
1294
|
-
rest: Prism.languages.markup.tag.inside
|
|
1295
|
-
}
|
|
1296
|
-
},
|
|
1297
|
-
directive: {
|
|
1298
|
-
pattern: /<%.*%>/,
|
|
1299
|
-
alias: "tag",
|
|
1300
|
-
inside: {
|
|
1301
|
-
directive: { pattern: /<%\s*?[$=%#:]{0,2}|%>/, alias: "tag" },
|
|
1302
|
-
rest: Prism.languages.csharp
|
|
1303
|
-
}
|
|
1304
|
-
}
|
|
1305
|
-
})),
|
|
1306
|
-
(Prism.languages.aspnet.tag.pattern =
|
|
1307
|
-
/<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/),
|
|
1308
|
-
Prism.languages.insertBefore(
|
|
1309
|
-
"inside",
|
|
1310
|
-
"punctuation",
|
|
1311
|
-
{ directive: Prism.languages.aspnet.directive },
|
|
1312
|
-
Prism.languages.aspnet.tag.inside["attr-value"]
|
|
1313
|
-
),
|
|
1314
|
-
Prism.languages.insertBefore("aspnet", "comment", {
|
|
1315
|
-
"asp-comment": {
|
|
1316
|
-
pattern: /<%--[\s\S]*?--%>/,
|
|
1317
|
-
alias: ["asp", "comment"]
|
|
1318
|
-
}
|
|
1319
|
-
}),
|
|
1320
|
-
Prism.languages.insertBefore(
|
|
1321
|
-
"aspnet",
|
|
1322
|
-
Prism.languages.javascript ? "script" : "tag",
|
|
1323
|
-
{
|
|
1324
|
-
"asp-script": {
|
|
1325
|
-
pattern:
|
|
1326
|
-
/(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
|
|
1327
|
-
lookbehind: !0,
|
|
1328
|
-
alias: ["asp", "script"],
|
|
1329
|
-
inside: Prism.languages.csharp || {}
|
|
1330
|
-
}
|
|
1331
|
-
}
|
|
1332
|
-
);
|
|
1333
|
-
!(function (e) {
|
|
1334
|
-
var t =
|
|
1335
|
-
"\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b",
|
|
1336
|
-
a = {
|
|
1337
|
-
pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
|
|
1338
|
-
lookbehind: !0,
|
|
1339
|
-
alias: "punctuation",
|
|
1340
|
-
inside: null
|
|
1341
|
-
},
|
|
1342
|
-
n = {
|
|
1343
|
-
bash: a,
|
|
1344
|
-
environment: { pattern: RegExp("\\$" + t), alias: "constant" },
|
|
1345
|
-
variable: [
|
|
1346
|
-
{
|
|
1347
|
-
pattern: /\$?\(\([\s\S]+?\)\)/,
|
|
1348
|
-
greedy: !0,
|
|
1349
|
-
inside: {
|
|
1350
|
-
variable: [
|
|
1351
|
-
{
|
|
1352
|
-
pattern: /(^\$\(\([\s\S]+)\)\)/,
|
|
1353
|
-
lookbehind: !0
|
|
1354
|
-
},
|
|
1355
|
-
/^\$\(\(/
|
|
1356
|
-
],
|
|
1357
|
-
number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
|
|
1358
|
-
operator:
|
|
1359
|
-
/--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
|
|
1360
|
-
punctuation: /\(\(?|\)\)?|,|;/
|
|
1361
|
-
}
|
|
1362
|
-
},
|
|
1363
|
-
{
|
|
1364
|
-
pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
|
|
1365
|
-
greedy: !0,
|
|
1366
|
-
inside: { variable: /^\$\(|^`|\)$|`$/ }
|
|
1367
|
-
},
|
|
1368
|
-
{
|
|
1369
|
-
pattern: /\$\{[^}]+\}/,
|
|
1370
|
-
greedy: !0,
|
|
1371
|
-
inside: {
|
|
1372
|
-
operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
|
|
1373
|
-
punctuation: /[\[\]]/,
|
|
1374
|
-
environment: {
|
|
1375
|
-
pattern: RegExp("(\\{)" + t),
|
|
1376
|
-
lookbehind: !0,
|
|
1377
|
-
alias: "constant"
|
|
1378
|
-
}
|
|
1379
|
-
}
|
|
1380
|
-
},
|
|
1381
|
-
/\$(?:\w+|[#?*!@$])/
|
|
1382
|
-
],
|
|
1383
|
-
entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
|
|
1384
|
-
};
|
|
1385
|
-
(e.languages.bash = {
|
|
1386
|
-
shebang: { pattern: /^#!\s*\/.*/, alias: "important" },
|
|
1387
|
-
comment: { pattern: /(^|[^"{\\$])#.*/, lookbehind: !0 },
|
|
1388
|
-
"function-name": [
|
|
1389
|
-
{
|
|
1390
|
-
pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
|
|
1391
|
-
lookbehind: !0,
|
|
1392
|
-
alias: "function"
|
|
1393
|
-
},
|
|
1394
|
-
{ pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/, alias: "function" }
|
|
1395
|
-
],
|
|
1396
|
-
"for-or-select": {
|
|
1397
|
-
pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
|
|
1398
|
-
alias: "variable",
|
|
1399
|
-
lookbehind: !0
|
|
1400
|
-
},
|
|
1401
|
-
"assign-left": {
|
|
1402
|
-
pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
|
|
1403
|
-
inside: {
|
|
1404
|
-
environment: {
|
|
1405
|
-
pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + t),
|
|
1406
|
-
lookbehind: !0,
|
|
1407
|
-
alias: "constant"
|
|
1408
|
-
}
|
|
1409
|
-
},
|
|
1410
|
-
alias: "variable",
|
|
1411
|
-
lookbehind: !0
|
|
1412
|
-
},
|
|
1413
|
-
parameter: {
|
|
1414
|
-
pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
|
|
1415
|
-
alias: "variable",
|
|
1416
|
-
lookbehind: !0
|
|
1417
|
-
},
|
|
1418
|
-
string: [
|
|
1419
|
-
{
|
|
1420
|
-
pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
|
|
1421
|
-
lookbehind: !0,
|
|
1422
|
-
greedy: !0,
|
|
1423
|
-
inside: n
|
|
1424
|
-
},
|
|
1425
|
-
{
|
|
1426
|
-
pattern:
|
|
1427
|
-
/((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
|
|
1428
|
-
lookbehind: !0,
|
|
1429
|
-
greedy: !0,
|
|
1430
|
-
inside: { bash: a }
|
|
1431
|
-
},
|
|
1432
|
-
{
|
|
1433
|
-
pattern:
|
|
1434
|
-
/(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
|
|
1435
|
-
lookbehind: !0,
|
|
1436
|
-
greedy: !0,
|
|
1437
|
-
inside: n
|
|
1438
|
-
},
|
|
1439
|
-
{ pattern: /(^|[^$\\])'[^']*'/, lookbehind: !0, greedy: !0 },
|
|
1440
|
-
{
|
|
1441
|
-
pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
|
|
1442
|
-
greedy: !0,
|
|
1443
|
-
inside: { entity: n.entity }
|
|
1444
|
-
}
|
|
1445
|
-
],
|
|
1446
|
-
environment: { pattern: RegExp("\\$?" + t), alias: "constant" },
|
|
1447
|
-
variable: n.variable,
|
|
1448
|
-
function: {
|
|
1449
|
-
pattern:
|
|
1450
|
-
/(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
|
|
1451
|
-
lookbehind: !0
|
|
1452
|
-
},
|
|
1453
|
-
keyword: {
|
|
1454
|
-
pattern:
|
|
1455
|
-
/(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
|
|
1456
|
-
lookbehind: !0
|
|
1457
|
-
},
|
|
1458
|
-
builtin: {
|
|
1459
|
-
pattern:
|
|
1460
|
-
/(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
|
|
1461
|
-
lookbehind: !0,
|
|
1462
|
-
alias: "class-name"
|
|
1463
|
-
},
|
|
1464
|
-
boolean: {
|
|
1465
|
-
pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
|
|
1466
|
-
lookbehind: !0
|
|
1467
|
-
},
|
|
1468
|
-
"file-descriptor": { pattern: /\B&\d\b/, alias: "important" },
|
|
1469
|
-
operator: {
|
|
1470
|
-
pattern:
|
|
1471
|
-
/\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
|
|
1472
|
-
inside: {
|
|
1473
|
-
"file-descriptor": { pattern: /^\d/, alias: "important" }
|
|
1474
|
-
}
|
|
1475
|
-
},
|
|
1476
|
-
punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
|
|
1477
|
-
number: {
|
|
1478
|
-
pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
|
|
1479
|
-
lookbehind: !0
|
|
1480
|
-
}
|
|
1481
|
-
}),
|
|
1482
|
-
(a.inside = e.languages.bash);
|
|
1483
|
-
for (
|
|
1484
|
-
var s = [
|
|
1485
|
-
"comment",
|
|
1486
|
-
"function-name",
|
|
1487
|
-
"for-or-select",
|
|
1488
|
-
"assign-left",
|
|
1489
|
-
"parameter",
|
|
1490
|
-
"string",
|
|
1491
|
-
"environment",
|
|
1492
|
-
"function",
|
|
1493
|
-
"keyword",
|
|
1494
|
-
"builtin",
|
|
1495
|
-
"boolean",
|
|
1496
|
-
"file-descriptor",
|
|
1497
|
-
"operator",
|
|
1498
|
-
"punctuation",
|
|
1499
|
-
"number"
|
|
1500
|
-
],
|
|
1501
|
-
o = n.variable[1].inside,
|
|
1502
|
-
i = 0;
|
|
1503
|
-
i < s.length;
|
|
1504
|
-
i++
|
|
1505
|
-
)
|
|
1506
|
-
o[s[i]] = e.languages.bash[s[i]];
|
|
1507
|
-
(e.languages.sh = e.languages.bash),
|
|
1508
|
-
(e.languages.shell = e.languages.bash);
|
|
1509
|
-
})(Prism);
|
|
1510
|
-
Prism.languages.basic = {
|
|
1511
|
-
comment: { pattern: /(?:!|REM\b).+/i, inside: { keyword: /^REM/i } },
|
|
1512
|
-
string: {
|
|
1513
|
-
pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
|
|
1514
|
-
greedy: !0
|
|
1515
|
-
},
|
|
1516
|
-
number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
|
|
1517
|
-
keyword:
|
|
1518
|
-
/\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
|
|
1519
|
-
function:
|
|
1520
|
-
/\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
|
|
1521
|
-
operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
|
|
1522
|
-
punctuation: /[,;:()]/
|
|
1523
|
-
};
|
|
1524
|
-
(Prism.languages.c = Prism.languages.extend("clike", {
|
|
1525
|
-
comment: {
|
|
1526
|
-
pattern:
|
|
1527
|
-
/\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
1528
|
-
greedy: !0
|
|
1529
|
-
},
|
|
1530
|
-
string: { pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: !0 },
|
|
1531
|
-
"class-name": {
|
|
1532
|
-
pattern:
|
|
1533
|
-
/(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
|
|
1534
|
-
lookbehind: !0
|
|
1535
|
-
},
|
|
1536
|
-
keyword:
|
|
1537
|
-
/\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
|
|
1538
|
-
function: /\b[a-z_]\w*(?=\s*\()/i,
|
|
1539
|
-
number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
|
|
1540
|
-
operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
|
|
1541
|
-
})),
|
|
1542
|
-
Prism.languages.insertBefore("c", "string", {
|
|
1543
|
-
char: {
|
|
1544
|
-
pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
|
|
1545
|
-
greedy: !0
|
|
1546
|
-
}
|
|
1547
|
-
}),
|
|
1548
|
-
Prism.languages.insertBefore("c", "string", {
|
|
1549
|
-
macro: {
|
|
1550
|
-
pattern:
|
|
1551
|
-
/(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
|
|
1552
|
-
lookbehind: !0,
|
|
1553
|
-
greedy: !0,
|
|
1554
|
-
alias: "property",
|
|
1555
|
-
inside: {
|
|
1556
|
-
string: [
|
|
1557
|
-
{ pattern: /^(#\s*include\s*)<[^>]+>/, lookbehind: !0 },
|
|
1558
|
-
Prism.languages.c.string
|
|
1559
|
-
],
|
|
1560
|
-
char: Prism.languages.c.char,
|
|
1561
|
-
comment: Prism.languages.c.comment,
|
|
1562
|
-
"macro-name": [
|
|
1563
|
-
{
|
|
1564
|
-
pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
|
|
1565
|
-
lookbehind: !0
|
|
1566
|
-
},
|
|
1567
|
-
{
|
|
1568
|
-
pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
|
|
1569
|
-
lookbehind: !0,
|
|
1570
|
-
alias: "function"
|
|
1571
|
-
}
|
|
1572
|
-
],
|
|
1573
|
-
directive: {
|
|
1574
|
-
pattern: /^(#\s*)[a-z]+/,
|
|
1575
|
-
lookbehind: !0,
|
|
1576
|
-
alias: "keyword"
|
|
1577
|
-
},
|
|
1578
|
-
"directive-hash": /^#/,
|
|
1579
|
-
punctuation: /##|\\(?=[\r\n])/,
|
|
1580
|
-
expression: {
|
|
1581
|
-
pattern: /\S[\s\S]*/,
|
|
1582
|
-
inside: Prism.languages.c
|
|
1583
|
-
}
|
|
1584
|
-
}
|
|
1585
|
-
}
|
|
1586
|
-
}),
|
|
1587
|
-
Prism.languages.insertBefore("c", "function", {
|
|
1588
|
-
constant:
|
|
1589
|
-
/\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
|
|
1590
|
-
}),
|
|
1591
|
-
delete Prism.languages.c.boolean;
|
|
1592
|
-
!(function (e) {
|
|
1593
|
-
var t =
|
|
1594
|
-
/\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/,
|
|
1595
|
-
n = "\\b(?!<keyword>)\\w+(?:\\s*\\.\\s*\\w+)*\\b".replace(
|
|
1596
|
-
/<keyword>/g,
|
|
1597
|
-
function () {
|
|
1598
|
-
return t.source;
|
|
1599
|
-
}
|
|
1600
|
-
);
|
|
1601
|
-
(e.languages.cpp = e.languages.extend("c", {
|
|
1602
|
-
"class-name": [
|
|
1603
|
-
{
|
|
1604
|
-
pattern: RegExp(
|
|
1605
|
-
"(\\b(?:class|concept|enum|struct|typename)\\s+)(?!<keyword>)\\w+".replace(
|
|
1606
|
-
/<keyword>/g,
|
|
1607
|
-
function () {
|
|
1608
|
-
return t.source;
|
|
1609
|
-
}
|
|
1610
|
-
)
|
|
1611
|
-
),
|
|
1612
|
-
lookbehind: !0
|
|
1613
|
-
},
|
|
1614
|
-
/\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
|
|
1615
|
-
/\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
|
|
1616
|
-
/\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
|
|
1617
|
-
],
|
|
1618
|
-
keyword: t,
|
|
1619
|
-
number: {
|
|
1620
|
-
pattern:
|
|
1621
|
-
/(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
|
|
1622
|
-
greedy: !0
|
|
1623
|
-
},
|
|
1624
|
-
operator:
|
|
1625
|
-
/>>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
|
|
1626
|
-
boolean: /\b(?:false|true)\b/
|
|
1627
|
-
})),
|
|
1628
|
-
e.languages.insertBefore("cpp", "string", {
|
|
1629
|
-
module: {
|
|
1630
|
-
pattern: RegExp(
|
|
1631
|
-
'(\\b(?:import|module)\\s+)(?:"(?:\\\\(?:\r\n|[^])|[^"\\\\\r\n])*"|<[^<>\r\n]*>|' +
|
|
1632
|
-
"<mod-name>(?:\\s*:\\s*<mod-name>)?|:\\s*<mod-name>".replace(
|
|
1633
|
-
/<mod-name>/g,
|
|
1634
|
-
function () {
|
|
1635
|
-
return n;
|
|
1636
|
-
}
|
|
1637
|
-
) +
|
|
1638
|
-
")"
|
|
1639
|
-
),
|
|
1640
|
-
lookbehind: !0,
|
|
1641
|
-
greedy: !0,
|
|
1642
|
-
inside: {
|
|
1643
|
-
string: /^[<"][\s\S]+/,
|
|
1644
|
-
operator: /:/,
|
|
1645
|
-
punctuation: /\./
|
|
1646
|
-
}
|
|
1647
|
-
},
|
|
1648
|
-
"raw-string": {
|
|
1649
|
-
pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
|
|
1650
|
-
alias: "string",
|
|
1651
|
-
greedy: !0
|
|
1652
|
-
}
|
|
1653
|
-
}),
|
|
1654
|
-
e.languages.insertBefore("cpp", "keyword", {
|
|
1655
|
-
"generic-function": {
|
|
1656
|
-
pattern:
|
|
1657
|
-
/\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
|
|
1658
|
-
inside: {
|
|
1659
|
-
function: /^\w+/,
|
|
1660
|
-
generic: {
|
|
1661
|
-
pattern: /<[\s\S]+/,
|
|
1662
|
-
alias: "class-name",
|
|
1663
|
-
inside: e.languages.cpp
|
|
1664
|
-
}
|
|
1665
|
-
}
|
|
1666
|
-
}
|
|
1667
|
-
}),
|
|
1668
|
-
e.languages.insertBefore("cpp", "operator", {
|
|
1669
|
-
"double-colon": { pattern: /::/, alias: "punctuation" }
|
|
1670
|
-
}),
|
|
1671
|
-
e.languages.insertBefore("cpp", "class-name", {
|
|
1672
|
-
"base-clause": {
|
|
1673
|
-
pattern:
|
|
1674
|
-
/(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
|
|
1675
|
-
lookbehind: !0,
|
|
1676
|
-
greedy: !0,
|
|
1677
|
-
inside: e.languages.extend("cpp", {})
|
|
1678
|
-
}
|
|
1679
|
-
}),
|
|
1680
|
-
e.languages.insertBefore(
|
|
1681
|
-
"inside",
|
|
1682
|
-
"double-colon",
|
|
1683
|
-
{ "class-name": /\b[a-z_]\w*\b(?!\s*::)/i },
|
|
1684
|
-
e.languages.cpp["base-clause"]
|
|
1685
|
-
);
|
|
1686
|
-
})(Prism);
|
|
1687
|
-
!(function (e) {
|
|
1688
|
-
var a,
|
|
1689
|
-
n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
|
|
1690
|
-
(e.languages.css.selector = {
|
|
1691
|
-
pattern: e.languages.css.selector.pattern,
|
|
1692
|
-
lookbehind: !0,
|
|
1693
|
-
inside: (a = {
|
|
1694
|
-
"pseudo-element":
|
|
1695
|
-
/:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
|
|
1696
|
-
"pseudo-class": /:[-\w]+/,
|
|
1697
|
-
class: /\.[-\w]+/,
|
|
1698
|
-
id: /#[-\w]+/,
|
|
1699
|
-
attribute: {
|
|
1700
|
-
pattern: RegExp("\\[(?:[^[\\]\"']|" + n.source + ")*\\]"),
|
|
1701
|
-
greedy: !0,
|
|
1702
|
-
inside: {
|
|
1703
|
-
punctuation: /^\[|\]$/,
|
|
1704
|
-
"case-sensitivity": {
|
|
1705
|
-
pattern: /(\s)[si]$/i,
|
|
1706
|
-
lookbehind: !0,
|
|
1707
|
-
alias: "keyword"
|
|
1708
|
-
},
|
|
1709
|
-
namespace: {
|
|
1710
|
-
pattern:
|
|
1711
|
-
/^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
|
|
1712
|
-
lookbehind: !0,
|
|
1713
|
-
inside: { punctuation: /\|$/ }
|
|
1714
|
-
},
|
|
1715
|
-
"attr-name": {
|
|
1716
|
-
pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
|
|
1717
|
-
lookbehind: !0
|
|
1718
|
-
},
|
|
1719
|
-
"attr-value": [
|
|
1720
|
-
n,
|
|
1721
|
-
{
|
|
1722
|
-
pattern:
|
|
1723
|
-
/(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
|
|
1724
|
-
lookbehind: !0
|
|
1725
|
-
}
|
|
1726
|
-
],
|
|
1727
|
-
operator: /[|~*^$]?=/
|
|
1728
|
-
}
|
|
1729
|
-
},
|
|
1730
|
-
"n-th": [
|
|
1731
|
-
{
|
|
1732
|
-
pattern:
|
|
1733
|
-
/(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
|
|
1734
|
-
lookbehind: !0,
|
|
1735
|
-
inside: { number: /[\dn]+/, operator: /[+-]/ }
|
|
1736
|
-
},
|
|
1737
|
-
{ pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i, lookbehind: !0 }
|
|
1738
|
-
],
|
|
1739
|
-
combinator: />|\+|~|\|\|/,
|
|
1740
|
-
punctuation: /[(),]/
|
|
1741
|
-
})
|
|
1742
|
-
}),
|
|
1743
|
-
(e.languages.css.atrule.inside[
|
|
1744
|
-
"selector-function-argument"
|
|
1745
|
-
].inside = a),
|
|
1746
|
-
e.languages.insertBefore("css", "property", {
|
|
1747
|
-
variable: {
|
|
1748
|
-
pattern:
|
|
1749
|
-
/(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
|
|
1750
|
-
lookbehind: !0
|
|
1751
|
-
}
|
|
1752
|
-
});
|
|
1753
|
-
var r = { pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/, lookbehind: !0 },
|
|
1754
|
-
i = {
|
|
1755
|
-
pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
|
|
1756
|
-
lookbehind: !0
|
|
1757
|
-
};
|
|
1758
|
-
e.languages.insertBefore("css", "function", {
|
|
1759
|
-
operator: { pattern: /(\s)[+\-*\/](?=\s)/, lookbehind: !0 },
|
|
1760
|
-
hexcode: { pattern: /\B#[\da-f]{3,8}\b/i, alias: "color" },
|
|
1761
|
-
color: [
|
|
1762
|
-
{
|
|
1763
|
-
pattern:
|
|
1764
|
-
/(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|RebeccaPurple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
|
|
1765
|
-
lookbehind: !0
|
|
1766
|
-
},
|
|
1767
|
-
{
|
|
1768
|
-
pattern:
|
|
1769
|
-
/\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
|
|
1770
|
-
inside: {
|
|
1771
|
-
unit: r,
|
|
1772
|
-
number: i,
|
|
1773
|
-
function: /[\w-]+(?=\()/,
|
|
1774
|
-
punctuation: /[(),]/
|
|
1775
|
-
}
|
|
1776
|
-
}
|
|
1777
|
-
],
|
|
1778
|
-
entity: /\\[\da-f]{1,8}/i,
|
|
1779
|
-
unit: r,
|
|
1780
|
-
number: i
|
|
1781
|
-
});
|
|
1782
|
-
})(Prism);
|
|
1783
|
-
!(function (e) {
|
|
1784
|
-
e.languages.dataweave = {
|
|
1785
|
-
url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
|
|
1786
|
-
property: {
|
|
1787
|
-
pattern:
|
|
1788
|
-
/(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
|
|
1789
|
-
greedy: !0
|
|
1790
|
-
},
|
|
1791
|
-
string: {
|
|
1792
|
-
pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
|
|
1793
|
-
greedy: !0
|
|
1794
|
-
},
|
|
1795
|
-
"mime-type":
|
|
1796
|
-
/\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
|
|
1797
|
-
date: { pattern: /\|[\w:+-]+\|/, greedy: !0 },
|
|
1798
|
-
comment: [
|
|
1799
|
-
{
|
|
1800
|
-
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
|
1801
|
-
lookbehind: !0,
|
|
1802
|
-
greedy: !0
|
|
1803
|
-
},
|
|
1804
|
-
{ pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }
|
|
1805
|
-
],
|
|
1806
|
-
regex: { pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//, greedy: !0 },
|
|
1807
|
-
keyword:
|
|
1808
|
-
/\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
|
|
1809
|
-
function: /\b[A-Z_]\w*(?=\s*\()/i,
|
|
1810
|
-
number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
|
|
1811
|
-
punctuation: /[{}[\];(),.:@]/,
|
|
1812
|
-
operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
|
|
1813
|
-
boolean: /\b(?:false|true)\b/
|
|
1814
|
-
};
|
|
1815
|
-
})(Prism);
|
|
1816
|
-
(Prism.languages.graphql = {
|
|
1817
|
-
comment: /#.*/,
|
|
1818
|
-
description: {
|
|
1819
|
-
pattern:
|
|
1820
|
-
/(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
|
|
1821
|
-
greedy: !0,
|
|
1822
|
-
alias: "string",
|
|
1823
|
-
inside: {
|
|
1824
|
-
"language-markdown": {
|
|
1825
|
-
pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
|
|
1826
|
-
lookbehind: !0,
|
|
1827
|
-
inside: Prism.languages.markdown
|
|
1828
|
-
}
|
|
1829
|
-
}
|
|
1830
|
-
},
|
|
1831
|
-
string: {
|
|
1832
|
-
pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
|
|
1833
|
-
greedy: !0
|
|
1834
|
-
},
|
|
1835
|
-
number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
|
|
1836
|
-
boolean: /\b(?:false|true)\b/,
|
|
1837
|
-
variable: /\$[a-z_]\w*/i,
|
|
1838
|
-
directive: { pattern: /@[a-z_]\w*/i, alias: "function" },
|
|
1839
|
-
"attr-name": {
|
|
1840
|
-
pattern:
|
|
1841
|
-
/\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
|
|
1842
|
-
greedy: !0
|
|
1843
|
-
},
|
|
1844
|
-
"atom-input": { pattern: /\b[A-Z]\w*Input\b/, alias: "class-name" },
|
|
1845
|
-
scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
|
|
1846
|
-
constant: /\b[A-Z][A-Z_\d]*\b/,
|
|
1847
|
-
"class-name": {
|
|
1848
|
-
pattern:
|
|
1849
|
-
/(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
|
|
1850
|
-
lookbehind: !0
|
|
1851
|
-
},
|
|
1852
|
-
fragment: {
|
|
1853
|
-
pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
|
|
1854
|
-
lookbehind: !0,
|
|
1855
|
-
alias: "function"
|
|
1856
|
-
},
|
|
1857
|
-
"definition-mutation": {
|
|
1858
|
-
pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
|
|
1859
|
-
lookbehind: !0,
|
|
1860
|
-
alias: "function"
|
|
1861
|
-
},
|
|
1862
|
-
"definition-query": {
|
|
1863
|
-
pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
|
|
1864
|
-
lookbehind: !0,
|
|
1865
|
-
alias: "function"
|
|
1866
|
-
},
|
|
1867
|
-
keyword:
|
|
1868
|
-
/\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
|
|
1869
|
-
operator: /[!=|&]|\.{3}/,
|
|
1870
|
-
"property-query": /\w+(?=\s*\()/,
|
|
1871
|
-
object: /\w+(?=\s*\{)/,
|
|
1872
|
-
punctuation: /[!(){}\[\]:=,]/,
|
|
1873
|
-
property: /\w+/
|
|
1874
|
-
}),
|
|
1875
|
-
Prism.hooks.add("after-tokenize", function (n) {
|
|
1876
|
-
if ("graphql" === n.language)
|
|
1877
|
-
for (
|
|
1878
|
-
var t = n.tokens.filter(function (n) {
|
|
1879
|
-
return (
|
|
1880
|
-
"string" != typeof n &&
|
|
1881
|
-
"comment" !== n.type &&
|
|
1882
|
-
"scalar" !== n.type
|
|
1883
|
-
);
|
|
1884
|
-
}),
|
|
1885
|
-
e = 0;
|
|
1886
|
-
e < t.length;
|
|
1887
|
-
|
|
1888
|
-
) {
|
|
1889
|
-
var a = t[e++];
|
|
1890
|
-
if ("keyword" === a.type && "mutation" === a.content) {
|
|
1891
|
-
var r = [];
|
|
1892
|
-
if (
|
|
1893
|
-
c(["definition-mutation", "punctuation"]) &&
|
|
1894
|
-
"(" === l(1).content
|
|
1895
|
-
) {
|
|
1896
|
-
e += 2;
|
|
1897
|
-
var i = f(/^\($/, /^\)$/);
|
|
1898
|
-
if (-1 === i) continue;
|
|
1899
|
-
for (; e < i; e++) {
|
|
1900
|
-
var o = l(0);
|
|
1901
|
-
"variable" === o.type &&
|
|
1902
|
-
(b(o, "variable-input"), r.push(o.content));
|
|
1903
|
-
}
|
|
1904
|
-
e = i + 1;
|
|
1905
|
-
}
|
|
1906
|
-
if (
|
|
1907
|
-
c(["punctuation", "property-query"]) &&
|
|
1908
|
-
"{" === l(0).content &&
|
|
1909
|
-
(e++, b(l(0), "property-mutation"), r.length > 0)
|
|
1910
|
-
) {
|
|
1911
|
-
var s = f(/^\{$/, /^\}$/);
|
|
1912
|
-
if (-1 === s) continue;
|
|
1913
|
-
for (var u = e; u < s; u++) {
|
|
1914
|
-
var p = t[u];
|
|
1915
|
-
"variable" === p.type &&
|
|
1916
|
-
r.indexOf(p.content) >= 0 &&
|
|
1917
|
-
b(p, "variable-input");
|
|
1918
|
-
}
|
|
1919
|
-
}
|
|
1920
|
-
}
|
|
1921
|
-
}
|
|
1922
|
-
function l(n) {
|
|
1923
|
-
return t[e + n];
|
|
1924
|
-
}
|
|
1925
|
-
function c(n, t) {
|
|
1926
|
-
t = t || 0;
|
|
1927
|
-
for (var e = 0; e < n.length; e++) {
|
|
1928
|
-
var a = l(e + t);
|
|
1929
|
-
if (!a || a.type !== n[e]) return !1;
|
|
1930
|
-
}
|
|
1931
|
-
return !0;
|
|
1932
|
-
}
|
|
1933
|
-
function f(n, a) {
|
|
1934
|
-
for (var r = 1, i = e; i < t.length; i++) {
|
|
1935
|
-
var o = t[i],
|
|
1936
|
-
s = o.content;
|
|
1937
|
-
if ("punctuation" === o.type && "string" == typeof s)
|
|
1938
|
-
if (n.test(s)) r++;
|
|
1939
|
-
else if (a.test(s) && 0 == --r) return i;
|
|
1940
|
-
}
|
|
1941
|
-
return -1;
|
|
1942
|
-
}
|
|
1943
|
-
function b(n, t) {
|
|
1944
|
-
var e = n.alias;
|
|
1945
|
-
e
|
|
1946
|
-
? Array.isArray(e) || (n.alias = e = [e])
|
|
1947
|
-
: (n.alias = e = []),
|
|
1948
|
-
e.push(t);
|
|
1949
|
-
}
|
|
1950
|
-
});
|
|
1951
|
-
!(function (e) {
|
|
1952
|
-
function n(e, n) {
|
|
1953
|
-
return "___" + e.toUpperCase() + n + "___";
|
|
1954
|
-
}
|
|
1955
|
-
Object.defineProperties((e.languages["markup-templating"] = {}), {
|
|
1956
|
-
buildPlaceholders: {
|
|
1957
|
-
value: function (t, a, r, o) {
|
|
1958
|
-
if (t.language === a) {
|
|
1959
|
-
var c = (t.tokenStack = []);
|
|
1960
|
-
(t.code = t.code.replace(r, function (e) {
|
|
1961
|
-
if ("function" == typeof o && !o(e)) return e;
|
|
1962
|
-
for (
|
|
1963
|
-
var r, i = c.length;
|
|
1964
|
-
-1 !== t.code.indexOf((r = n(a, i)));
|
|
1965
|
-
|
|
1966
|
-
)
|
|
1967
|
-
++i;
|
|
1968
|
-
return (c[i] = e), r;
|
|
1969
|
-
})),
|
|
1970
|
-
(t.grammar = e.languages.markup);
|
|
1971
|
-
}
|
|
1972
|
-
}
|
|
1973
|
-
},
|
|
1974
|
-
tokenizePlaceholders: {
|
|
1975
|
-
value: function (t, a) {
|
|
1976
|
-
if (t.language === a && t.tokenStack) {
|
|
1977
|
-
t.grammar = e.languages[a];
|
|
1978
|
-
var r = 0,
|
|
1979
|
-
o = Object.keys(t.tokenStack);
|
|
1980
|
-
!(function c(i) {
|
|
1981
|
-
for (
|
|
1982
|
-
var u = 0;
|
|
1983
|
-
u < i.length && !(r >= o.length);
|
|
1984
|
-
u++
|
|
1985
|
-
) {
|
|
1986
|
-
var g = i[u];
|
|
1987
|
-
if (
|
|
1988
|
-
"string" == typeof g ||
|
|
1989
|
-
(g.content && "string" == typeof g.content)
|
|
1990
|
-
) {
|
|
1991
|
-
var l = o[r],
|
|
1992
|
-
s = t.tokenStack[l],
|
|
1993
|
-
f =
|
|
1994
|
-
"string" == typeof g
|
|
1995
|
-
? g
|
|
1996
|
-
: g.content,
|
|
1997
|
-
p = n(a, l),
|
|
1998
|
-
k = f.indexOf(p);
|
|
1999
|
-
if (k > -1) {
|
|
2000
|
-
++r;
|
|
2001
|
-
var m = f.substring(0, k),
|
|
2002
|
-
d = new e.Token(
|
|
2003
|
-
a,
|
|
2004
|
-
e.tokenize(s, t.grammar),
|
|
2005
|
-
"language-" + a,
|
|
2006
|
-
s
|
|
2007
|
-
),
|
|
2008
|
-
h = f.substring(k + p.length),
|
|
2009
|
-
v = [];
|
|
2010
|
-
m && v.push.apply(v, c([m])),
|
|
2011
|
-
v.push(d),
|
|
2012
|
-
h && v.push.apply(v, c([h])),
|
|
2013
|
-
"string" == typeof g
|
|
2014
|
-
? i.splice.apply(
|
|
2015
|
-
i,
|
|
2016
|
-
[u, 1].concat(v)
|
|
2017
|
-
)
|
|
2018
|
-
: (g.content = v);
|
|
2019
|
-
}
|
|
2020
|
-
} else g.content && c(g.content);
|
|
2021
|
-
}
|
|
2022
|
-
return i;
|
|
2023
|
-
})(t.tokens);
|
|
2024
|
-
}
|
|
2025
|
-
}
|
|
2026
|
-
}
|
|
2027
|
-
});
|
|
2028
|
-
})(Prism);
|
|
2029
|
-
!(function (a) {
|
|
2030
|
-
(a.languages.handlebars = {
|
|
2031
|
-
comment: /\{\{![\s\S]*?\}\}/,
|
|
2032
|
-
delimiter: { pattern: /^\{\{\{?|\}\}\}?$/, alias: "punctuation" },
|
|
2033
|
-
string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
|
|
2034
|
-
number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
|
|
2035
|
-
boolean: /\b(?:false|true)\b/,
|
|
2036
|
-
block: {
|
|
2037
|
-
pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
|
|
2038
|
-
lookbehind: !0,
|
|
2039
|
-
alias: "keyword"
|
|
2040
|
-
},
|
|
2041
|
-
brackets: {
|
|
2042
|
-
pattern: /\[[^\]]+\]/,
|
|
2043
|
-
inside: { punctuation: /\[|\]/, variable: /[\s\S]+/ }
|
|
2044
|
-
},
|
|
2045
|
-
punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
|
|
2046
|
-
variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
|
|
2047
|
-
}),
|
|
2048
|
-
a.hooks.add("before-tokenize", function (e) {
|
|
2049
|
-
a.languages["markup-templating"].buildPlaceholders(
|
|
2050
|
-
e,
|
|
2051
|
-
"handlebars",
|
|
2052
|
-
/\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g
|
|
2053
|
-
);
|
|
2054
|
-
}),
|
|
2055
|
-
a.hooks.add("after-tokenize", function (e) {
|
|
2056
|
-
a.languages["markup-templating"].tokenizePlaceholders(
|
|
2057
|
-
e,
|
|
2058
|
-
"handlebars"
|
|
2059
|
-
);
|
|
2060
|
-
}),
|
|
2061
|
-
(a.languages.hbs = a.languages.handlebars),
|
|
2062
|
-
(a.languages.mustache = a.languages.handlebars);
|
|
2063
|
-
})(Prism);
|
|
2064
|
-
Prism.languages.hcl = {
|
|
2065
|
-
comment: /(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
2066
|
-
heredoc: {
|
|
2067
|
-
pattern: /<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,
|
|
2068
|
-
greedy: !0,
|
|
2069
|
-
alias: "string"
|
|
2070
|
-
},
|
|
2071
|
-
keyword: [
|
|
2072
|
-
{
|
|
2073
|
-
pattern:
|
|
2074
|
-
/(?:data|resource)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+\{)/i,
|
|
2075
|
-
inside: {
|
|
2076
|
-
type: {
|
|
2077
|
-
pattern:
|
|
2078
|
-
/(resource|data|\s+)(?:"(?:\\[\s\S]|[^\\"])*")/i,
|
|
2079
|
-
lookbehind: !0,
|
|
2080
|
-
alias: "variable"
|
|
2081
|
-
}
|
|
2082
|
-
}
|
|
2083
|
-
},
|
|
2084
|
-
{
|
|
2085
|
-
pattern:
|
|
2086
|
-
/(?:backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?=\{)/i,
|
|
2087
|
-
inside: {
|
|
2088
|
-
type: {
|
|
2089
|
-
pattern:
|
|
2090
|
-
/(backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,
|
|
2091
|
-
lookbehind: !0,
|
|
2092
|
-
alias: "variable"
|
|
2093
|
-
}
|
|
2094
|
-
}
|
|
2095
|
-
},
|
|
2096
|
-
/[\w-]+(?=\s+\{)/
|
|
2097
|
-
],
|
|
2098
|
-
property: [
|
|
2099
|
-
/[-\w\.]+(?=\s*=(?!=))/,
|
|
2100
|
-
/"(?:\\[\s\S]|[^\\"])+"(?=\s*[:=])/
|
|
2101
|
-
],
|
|
2102
|
-
string: {
|
|
2103
|
-
pattern:
|
|
2104
|
-
/"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+(?!\$)|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,
|
|
2105
|
-
greedy: !0,
|
|
2106
|
-
inside: {
|
|
2107
|
-
interpolation: {
|
|
2108
|
-
pattern: /(^|[^$])\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\}/,
|
|
2109
|
-
lookbehind: !0,
|
|
2110
|
-
inside: {
|
|
2111
|
-
type: {
|
|
2112
|
-
pattern:
|
|
2113
|
-
/(\b(?:count|data|local|module|path|self|terraform|var)\b\.)[\w\*]+/i,
|
|
2114
|
-
lookbehind: !0,
|
|
2115
|
-
alias: "variable"
|
|
2116
|
-
},
|
|
2117
|
-
keyword:
|
|
2118
|
-
/\b(?:count|data|local|module|path|self|terraform|var)\b/i,
|
|
2119
|
-
function: /\w+(?=\()/,
|
|
2120
|
-
string: {
|
|
2121
|
-
pattern: /"(?:\\[\s\S]|[^\\"])*"/,
|
|
2122
|
-
greedy: !0
|
|
2123
|
-
},
|
|
2124
|
-
number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
|
|
2125
|
-
punctuation: /[!\$#%&'()*+,.\/;<=>@\[\\\]^`{|}~?:]/
|
|
2126
|
-
}
|
|
2127
|
-
}
|
|
2128
|
-
}
|
|
2129
|
-
},
|
|
2130
|
-
number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,
|
|
2131
|
-
boolean: /\b(?:false|true)\b/i,
|
|
2132
|
-
punctuation: /[=\[\]{}]/
|
|
2133
|
-
};
|
|
2134
|
-
!(function (e) {
|
|
2135
|
-
var n =
|
|
2136
|
-
/\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/,
|
|
2137
|
-
t = "(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*",
|
|
2138
|
-
s = {
|
|
2139
|
-
pattern: RegExp(
|
|
2140
|
-
"(^|[^\\w.])" + t + "[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"
|
|
2141
|
-
),
|
|
2142
|
-
lookbehind: !0,
|
|
2143
|
-
inside: {
|
|
2144
|
-
namespace: {
|
|
2145
|
-
pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
|
|
2146
|
-
inside: { punctuation: /\./ }
|
|
2147
|
-
},
|
|
2148
|
-
punctuation: /\./
|
|
2149
|
-
}
|
|
2150
|
-
};
|
|
2151
|
-
(e.languages.java = e.languages.extend("clike", {
|
|
2152
|
-
string: {
|
|
2153
|
-
pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
|
|
2154
|
-
lookbehind: !0,
|
|
2155
|
-
greedy: !0
|
|
2156
|
-
},
|
|
2157
|
-
"class-name": [
|
|
2158
|
-
s,
|
|
2159
|
-
{
|
|
2160
|
-
pattern: RegExp(
|
|
2161
|
-
"(^|[^\\w.])" +
|
|
2162
|
-
t +
|
|
2163
|
-
"[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()]|\\s*(?:\\[[\\s,]*\\]\\s*)?::\\s*new\\b)"
|
|
2164
|
-
),
|
|
2165
|
-
lookbehind: !0,
|
|
2166
|
-
inside: s.inside
|
|
2167
|
-
},
|
|
2168
|
-
{
|
|
2169
|
-
pattern: RegExp(
|
|
2170
|
-
"(\\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\\s+)" +
|
|
2171
|
-
t +
|
|
2172
|
-
"[A-Z]\\w*\\b"
|
|
2173
|
-
),
|
|
2174
|
-
lookbehind: !0,
|
|
2175
|
-
inside: s.inside
|
|
2176
|
-
}
|
|
2177
|
-
],
|
|
2178
|
-
keyword: n,
|
|
2179
|
-
function: [
|
|
2180
|
-
e.languages.clike.function,
|
|
2181
|
-
{ pattern: /(::\s*)[a-z_]\w*/, lookbehind: !0 }
|
|
2182
|
-
],
|
|
2183
|
-
number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
|
|
2184
|
-
operator: {
|
|
2185
|
-
pattern:
|
|
2186
|
-
/(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
|
|
2187
|
-
lookbehind: !0
|
|
2188
|
-
},
|
|
2189
|
-
constant: /\b[A-Z][A-Z_\d]+\b/
|
|
2190
|
-
})),
|
|
2191
|
-
e.languages.insertBefore("java", "string", {
|
|
2192
|
-
"triple-quoted-string": {
|
|
2193
|
-
pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
|
|
2194
|
-
greedy: !0,
|
|
2195
|
-
alias: "string"
|
|
2196
|
-
},
|
|
2197
|
-
char: { pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/, greedy: !0 }
|
|
2198
|
-
}),
|
|
2199
|
-
e.languages.insertBefore("java", "class-name", {
|
|
2200
|
-
annotation: {
|
|
2201
|
-
pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
|
|
2202
|
-
lookbehind: !0,
|
|
2203
|
-
alias: "punctuation"
|
|
2204
|
-
},
|
|
2205
|
-
generics: {
|
|
2206
|
-
pattern:
|
|
2207
|
-
/<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
|
|
2208
|
-
inside: {
|
|
2209
|
-
"class-name": s,
|
|
2210
|
-
keyword: n,
|
|
2211
|
-
punctuation: /[<>(),.:]/,
|
|
2212
|
-
operator: /[?&|]/
|
|
2213
|
-
}
|
|
2214
|
-
},
|
|
2215
|
-
import: [
|
|
2216
|
-
{
|
|
2217
|
-
pattern: RegExp(
|
|
2218
|
-
"(\\bimport\\s+)" + t + "(?:[A-Z]\\w*|\\*)(?=\\s*;)"
|
|
2219
|
-
),
|
|
2220
|
-
lookbehind: !0,
|
|
2221
|
-
inside: {
|
|
2222
|
-
namespace: s.inside.namespace,
|
|
2223
|
-
punctuation: /\./,
|
|
2224
|
-
operator: /\*/,
|
|
2225
|
-
"class-name": /\w+/
|
|
2226
|
-
}
|
|
2227
|
-
},
|
|
2228
|
-
{
|
|
2229
|
-
pattern: RegExp(
|
|
2230
|
-
"(\\bimport\\s+static\\s+)" +
|
|
2231
|
-
t +
|
|
2232
|
-
"(?:\\w+|\\*)(?=\\s*;)"
|
|
2233
|
-
),
|
|
2234
|
-
lookbehind: !0,
|
|
2235
|
-
alias: "static",
|
|
2236
|
-
inside: {
|
|
2237
|
-
namespace: s.inside.namespace,
|
|
2238
|
-
static: /\b\w+$/,
|
|
2239
|
-
punctuation: /\./,
|
|
2240
|
-
operator: /\*/,
|
|
2241
|
-
"class-name": /\w+/
|
|
2242
|
-
}
|
|
2243
|
-
}
|
|
2244
|
-
],
|
|
2245
|
-
namespace: {
|
|
2246
|
-
pattern: RegExp(
|
|
2247
|
-
"(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?".replace(
|
|
2248
|
-
/<keyword>/g,
|
|
2249
|
-
function () {
|
|
2250
|
-
return n.source;
|
|
2251
|
-
}
|
|
2252
|
-
)
|
|
2253
|
-
),
|
|
2254
|
-
lookbehind: !0,
|
|
2255
|
-
inside: { punctuation: /\./ }
|
|
2256
|
-
}
|
|
2257
|
-
});
|
|
2258
|
-
})(Prism);
|
|
2259
|
-
!(function (e) {
|
|
2260
|
-
var a = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/,
|
|
2261
|
-
t = [
|
|
2262
|
-
{ pattern: /\b(?:false|true)\b/i, alias: "boolean" },
|
|
2263
|
-
{
|
|
2264
|
-
pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
|
|
2265
|
-
greedy: !0,
|
|
2266
|
-
lookbehind: !0
|
|
2267
|
-
},
|
|
2268
|
-
{
|
|
2269
|
-
pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
|
|
2270
|
-
greedy: !0,
|
|
2271
|
-
lookbehind: !0
|
|
2272
|
-
},
|
|
2273
|
-
/\b(?:null)\b/i,
|
|
2274
|
-
/\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
|
|
2275
|
-
],
|
|
2276
|
-
i =
|
|
2277
|
-
/\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
|
|
2278
|
-
n =
|
|
2279
|
-
/<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/,
|
|
2280
|
-
s = /[{}\[\](),:;]/;
|
|
2281
|
-
e.languages.php = {
|
|
2282
|
-
delimiter: {
|
|
2283
|
-
pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
|
|
2284
|
-
alias: "important"
|
|
2285
|
-
},
|
|
2286
|
-
comment: a,
|
|
2287
|
-
variable: /\$+(?:\w+\b|(?=\{))/,
|
|
2288
|
-
package: {
|
|
2289
|
-
pattern:
|
|
2290
|
-
/(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
|
|
2291
|
-
lookbehind: !0,
|
|
2292
|
-
inside: { punctuation: /\\/ }
|
|
2293
|
-
},
|
|
2294
|
-
"class-name-definition": {
|
|
2295
|
-
pattern:
|
|
2296
|
-
/(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
|
|
2297
|
-
lookbehind: !0,
|
|
2298
|
-
alias: "class-name"
|
|
2299
|
-
},
|
|
2300
|
-
"function-definition": {
|
|
2301
|
-
pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
|
|
2302
|
-
lookbehind: !0,
|
|
2303
|
-
alias: "function"
|
|
2304
|
-
},
|
|
2305
|
-
keyword: [
|
|
2306
|
-
{
|
|
2307
|
-
pattern:
|
|
2308
|
-
/(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
|
|
2309
|
-
alias: "type-casting",
|
|
2310
|
-
greedy: !0,
|
|
2311
|
-
lookbehind: !0
|
|
2312
|
-
},
|
|
2313
|
-
{
|
|
2314
|
-
pattern:
|
|
2315
|
-
/([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
|
|
2316
|
-
alias: "type-hint",
|
|
2317
|
-
greedy: !0,
|
|
2318
|
-
lookbehind: !0
|
|
2319
|
-
},
|
|
2320
|
-
{
|
|
2321
|
-
pattern:
|
|
2322
|
-
/(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
|
|
2323
|
-
alias: "return-type",
|
|
2324
|
-
greedy: !0,
|
|
2325
|
-
lookbehind: !0
|
|
2326
|
-
},
|
|
2327
|
-
{
|
|
2328
|
-
pattern:
|
|
2329
|
-
/\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
|
|
2330
|
-
alias: "type-declaration",
|
|
2331
|
-
greedy: !0
|
|
2332
|
-
},
|
|
2333
|
-
{
|
|
2334
|
-
pattern:
|
|
2335
|
-
/(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
|
|
2336
|
-
alias: "type-declaration",
|
|
2337
|
-
greedy: !0,
|
|
2338
|
-
lookbehind: !0
|
|
2339
|
-
},
|
|
2340
|
-
{
|
|
2341
|
-
pattern: /\b(?:parent|self|static)(?=\s*::)/i,
|
|
2342
|
-
alias: "static-context",
|
|
2343
|
-
greedy: !0
|
|
2344
|
-
},
|
|
2345
|
-
{ pattern: /(\byield\s+)from\b/i, lookbehind: !0 },
|
|
2346
|
-
/\bclass\b/i,
|
|
2347
|
-
{
|
|
2348
|
-
pattern:
|
|
2349
|
-
/((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
|
|
2350
|
-
lookbehind: !0
|
|
2351
|
-
}
|
|
2352
|
-
],
|
|
2353
|
-
"argument-name": {
|
|
2354
|
-
pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
|
|
2355
|
-
lookbehind: !0
|
|
2356
|
-
},
|
|
2357
|
-
"class-name": [
|
|
2358
|
-
{
|
|
2359
|
-
pattern:
|
|
2360
|
-
/(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
|
|
2361
|
-
greedy: !0,
|
|
2362
|
-
lookbehind: !0
|
|
2363
|
-
},
|
|
2364
|
-
{
|
|
2365
|
-
pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
|
|
2366
|
-
greedy: !0,
|
|
2367
|
-
lookbehind: !0
|
|
2368
|
-
},
|
|
2369
|
-
{ pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i, greedy: !0 },
|
|
2370
|
-
{
|
|
2371
|
-
pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
|
|
2372
|
-
alias: "class-name-fully-qualified",
|
|
2373
|
-
greedy: !0,
|
|
2374
|
-
lookbehind: !0,
|
|
2375
|
-
inside: { punctuation: /\\/ }
|
|
2376
|
-
},
|
|
2377
|
-
{
|
|
2378
|
-
pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
|
|
2379
|
-
alias: "class-name-fully-qualified",
|
|
2380
|
-
greedy: !0,
|
|
2381
|
-
inside: { punctuation: /\\/ }
|
|
2382
|
-
},
|
|
2383
|
-
{
|
|
2384
|
-
pattern:
|
|
2385
|
-
/(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
|
|
2386
|
-
alias: "class-name-fully-qualified",
|
|
2387
|
-
greedy: !0,
|
|
2388
|
-
lookbehind: !0,
|
|
2389
|
-
inside: { punctuation: /\\/ }
|
|
2390
|
-
},
|
|
2391
|
-
{
|
|
2392
|
-
pattern: /\b[a-z_]\w*(?=\s*\$)/i,
|
|
2393
|
-
alias: "type-declaration",
|
|
2394
|
-
greedy: !0
|
|
2395
|
-
},
|
|
2396
|
-
{
|
|
2397
|
-
pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
|
|
2398
|
-
alias: ["class-name-fully-qualified", "type-declaration"],
|
|
2399
|
-
greedy: !0,
|
|
2400
|
-
inside: { punctuation: /\\/ }
|
|
2401
|
-
},
|
|
2402
|
-
{
|
|
2403
|
-
pattern: /\b[a-z_]\w*(?=\s*::)/i,
|
|
2404
|
-
alias: "static-context",
|
|
2405
|
-
greedy: !0
|
|
2406
|
-
},
|
|
2407
|
-
{
|
|
2408
|
-
pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
|
|
2409
|
-
alias: ["class-name-fully-qualified", "static-context"],
|
|
2410
|
-
greedy: !0,
|
|
2411
|
-
inside: { punctuation: /\\/ }
|
|
2412
|
-
},
|
|
2413
|
-
{
|
|
2414
|
-
pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
|
|
2415
|
-
alias: "type-hint",
|
|
2416
|
-
greedy: !0,
|
|
2417
|
-
lookbehind: !0
|
|
2418
|
-
},
|
|
2419
|
-
{
|
|
2420
|
-
pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
|
|
2421
|
-
alias: ["class-name-fully-qualified", "type-hint"],
|
|
2422
|
-
greedy: !0,
|
|
2423
|
-
lookbehind: !0,
|
|
2424
|
-
inside: { punctuation: /\\/ }
|
|
2425
|
-
},
|
|
2426
|
-
{
|
|
2427
|
-
pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
|
|
2428
|
-
alias: "return-type",
|
|
2429
|
-
greedy: !0,
|
|
2430
|
-
lookbehind: !0
|
|
2431
|
-
},
|
|
2432
|
-
{
|
|
2433
|
-
pattern:
|
|
2434
|
-
/(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
|
|
2435
|
-
alias: ["class-name-fully-qualified", "return-type"],
|
|
2436
|
-
greedy: !0,
|
|
2437
|
-
lookbehind: !0,
|
|
2438
|
-
inside: { punctuation: /\\/ }
|
|
2439
|
-
}
|
|
2440
|
-
],
|
|
2441
|
-
constant: t,
|
|
2442
|
-
function: {
|
|
2443
|
-
pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
|
|
2444
|
-
lookbehind: !0,
|
|
2445
|
-
inside: { punctuation: /\\/ }
|
|
2446
|
-
},
|
|
2447
|
-
property: { pattern: /(->\s*)\w+/, lookbehind: !0 },
|
|
2448
|
-
number: i,
|
|
2449
|
-
operator: n,
|
|
2450
|
-
punctuation: s
|
|
2451
|
-
};
|
|
2452
|
-
var l = {
|
|
2453
|
-
pattern:
|
|
2454
|
-
/\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
|
|
2455
|
-
lookbehind: !0,
|
|
2456
|
-
inside: e.languages.php
|
|
2457
|
-
},
|
|
2458
|
-
r = [
|
|
2459
|
-
{
|
|
2460
|
-
pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
|
|
2461
|
-
alias: "nowdoc-string",
|
|
2462
|
-
greedy: !0,
|
|
2463
|
-
inside: {
|
|
2464
|
-
delimiter: {
|
|
2465
|
-
pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
|
|
2466
|
-
alias: "symbol",
|
|
2467
|
-
inside: { punctuation: /^<<<'?|[';]$/ }
|
|
2468
|
-
}
|
|
2469
|
-
}
|
|
2470
|
-
},
|
|
2471
|
-
{
|
|
2472
|
-
pattern:
|
|
2473
|
-
/<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
|
|
2474
|
-
alias: "heredoc-string",
|
|
2475
|
-
greedy: !0,
|
|
2476
|
-
inside: {
|
|
2477
|
-
delimiter: {
|
|
2478
|
-
pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
|
|
2479
|
-
alias: "symbol",
|
|
2480
|
-
inside: { punctuation: /^<<<"?|[";]$/ }
|
|
2481
|
-
},
|
|
2482
|
-
interpolation: l
|
|
2483
|
-
}
|
|
2484
|
-
},
|
|
2485
|
-
{
|
|
2486
|
-
pattern: /`(?:\\[\s\S]|[^\\`])*`/,
|
|
2487
|
-
alias: "backtick-quoted-string",
|
|
2488
|
-
greedy: !0
|
|
2489
|
-
},
|
|
2490
|
-
{
|
|
2491
|
-
pattern: /'(?:\\[\s\S]|[^\\'])*'/,
|
|
2492
|
-
alias: "single-quoted-string",
|
|
2493
|
-
greedy: !0
|
|
2494
|
-
},
|
|
2495
|
-
{
|
|
2496
|
-
pattern: /"(?:\\[\s\S]|[^\\"])*"/,
|
|
2497
|
-
alias: "double-quoted-string",
|
|
2498
|
-
greedy: !0,
|
|
2499
|
-
inside: { interpolation: l }
|
|
2500
|
-
}
|
|
2501
|
-
];
|
|
2502
|
-
e.languages.insertBefore("php", "variable", {
|
|
2503
|
-
string: r,
|
|
2504
|
-
attribute: {
|
|
2505
|
-
pattern:
|
|
2506
|
-
/#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
|
|
2507
|
-
greedy: !0,
|
|
2508
|
-
inside: {
|
|
2509
|
-
"attribute-content": {
|
|
2510
|
-
pattern: /^(#\[)[\s\S]+(?=\]$)/,
|
|
2511
|
-
lookbehind: !0,
|
|
2512
|
-
inside: {
|
|
2513
|
-
comment: a,
|
|
2514
|
-
string: r,
|
|
2515
|
-
"attribute-class-name": [
|
|
2516
|
-
{
|
|
2517
|
-
pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
|
|
2518
|
-
alias: "class-name",
|
|
2519
|
-
greedy: !0,
|
|
2520
|
-
lookbehind: !0
|
|
2521
|
-
},
|
|
2522
|
-
{
|
|
2523
|
-
pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
|
|
2524
|
-
alias: [
|
|
2525
|
-
"class-name",
|
|
2526
|
-
"class-name-fully-qualified"
|
|
2527
|
-
],
|
|
2528
|
-
greedy: !0,
|
|
2529
|
-
lookbehind: !0,
|
|
2530
|
-
inside: { punctuation: /\\/ }
|
|
2531
|
-
}
|
|
2532
|
-
],
|
|
2533
|
-
constant: t,
|
|
2534
|
-
number: i,
|
|
2535
|
-
operator: n,
|
|
2536
|
-
punctuation: s
|
|
2537
|
-
}
|
|
2538
|
-
},
|
|
2539
|
-
delimiter: { pattern: /^#\[|\]$/, alias: "punctuation" }
|
|
2540
|
-
}
|
|
2541
|
-
}
|
|
2542
|
-
}),
|
|
2543
|
-
e.hooks.add("before-tokenize", function (a) {
|
|
2544
|
-
/<\?/.test(a.code) &&
|
|
2545
|
-
e.languages["markup-templating"].buildPlaceholders(
|
|
2546
|
-
a,
|
|
2547
|
-
"php",
|
|
2548
|
-
/<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g
|
|
2549
|
-
);
|
|
2550
|
-
}),
|
|
2551
|
-
e.hooks.add("after-tokenize", function (a) {
|
|
2552
|
-
e.languages["markup-templating"].tokenizePlaceholders(a, "php");
|
|
2553
|
-
});
|
|
2554
|
-
})(Prism);
|
|
2555
|
-
!(function (a) {
|
|
2556
|
-
var e = (a.languages.javadoclike = {
|
|
2557
|
-
parameter: {
|
|
2558
|
-
pattern:
|
|
2559
|
-
/(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
|
|
2560
|
-
lookbehind: !0
|
|
2561
|
-
},
|
|
2562
|
-
keyword: {
|
|
2563
|
-
pattern:
|
|
2564
|
-
/(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
|
|
2565
|
-
lookbehind: !0
|
|
2566
|
-
},
|
|
2567
|
-
punctuation: /[{}]/
|
|
2568
|
-
});
|
|
2569
|
-
Object.defineProperty(e, "addSupport", {
|
|
2570
|
-
value: function (e, n) {
|
|
2571
|
-
"string" == typeof e && (e = [e]),
|
|
2572
|
-
e.forEach(function (e) {
|
|
2573
|
-
!(function (e, n) {
|
|
2574
|
-
var t = "doc-comment",
|
|
2575
|
-
r = a.languages[e];
|
|
2576
|
-
if (r) {
|
|
2577
|
-
var o = r[t];
|
|
2578
|
-
if (
|
|
2579
|
-
(o ||
|
|
2580
|
-
(o = (r = a.languages.insertBefore(
|
|
2581
|
-
e,
|
|
2582
|
-
"comment",
|
|
2583
|
-
{
|
|
2584
|
-
"doc-comment": {
|
|
2585
|
-
pattern:
|
|
2586
|
-
/(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
|
|
2587
|
-
lookbehind: !0,
|
|
2588
|
-
alias: "comment"
|
|
2589
|
-
}
|
|
2590
|
-
}
|
|
2591
|
-
))[t]),
|
|
2592
|
-
o instanceof RegExp &&
|
|
2593
|
-
(o = r[t] = { pattern: o }),
|
|
2594
|
-
Array.isArray(o))
|
|
2595
|
-
)
|
|
2596
|
-
for (var i = 0, s = o.length; i < s; i++)
|
|
2597
|
-
o[i] instanceof RegExp &&
|
|
2598
|
-
(o[i] = { pattern: o[i] }),
|
|
2599
|
-
n(o[i]);
|
|
2600
|
-
else n(o);
|
|
2601
|
-
}
|
|
2602
|
-
})(e, function (a) {
|
|
2603
|
-
a.inside || (a.inside = {}), (a.inside.rest = n);
|
|
2604
|
-
});
|
|
2605
|
-
});
|
|
2606
|
-
}
|
|
2607
|
-
}),
|
|
2608
|
-
e.addSupport(["java", "javascript", "php"], e);
|
|
2609
|
-
})(Prism);
|
|
2610
|
-
!(function (a) {
|
|
2611
|
-
var e = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m,
|
|
2612
|
-
n =
|
|
2613
|
-
"(?:\\b[a-zA-Z]\\w+\\s*\\.\\s*)*\\b[A-Z]\\w*(?:\\s*<mem>)?|<mem>".replace(
|
|
2614
|
-
/<mem>/g,
|
|
2615
|
-
function () {
|
|
2616
|
-
return "#\\s*\\w+(?:\\s*\\([^()]*\\))?";
|
|
2617
|
-
}
|
|
2618
|
-
);
|
|
2619
|
-
(a.languages.javadoc = a.languages.extend("javadoclike", {})),
|
|
2620
|
-
a.languages.insertBefore("javadoc", "keyword", {
|
|
2621
|
-
reference: {
|
|
2622
|
-
pattern: RegExp(
|
|
2623
|
-
"(@(?:exception|link|linkplain|see|throws|value)\\s+(?:\\*\\s*)?)(?:" +
|
|
2624
|
-
n +
|
|
2625
|
-
")"
|
|
2626
|
-
),
|
|
2627
|
-
lookbehind: !0,
|
|
2628
|
-
inside: {
|
|
2629
|
-
function: {
|
|
2630
|
-
pattern: /(#\s*)\w+(?=\s*\()/,
|
|
2631
|
-
lookbehind: !0
|
|
2632
|
-
},
|
|
2633
|
-
field: { pattern: /(#\s*)\w+/, lookbehind: !0 },
|
|
2634
|
-
namespace: {
|
|
2635
|
-
pattern: /\b(?:[a-z]\w*\s*\.\s*)+/,
|
|
2636
|
-
inside: { punctuation: /\./ }
|
|
2637
|
-
},
|
|
2638
|
-
"class-name": /\b[A-Z]\w*/,
|
|
2639
|
-
keyword: a.languages.java.keyword,
|
|
2640
|
-
punctuation: /[#()[\],.]/
|
|
2641
|
-
}
|
|
2642
|
-
},
|
|
2643
|
-
"class-name": {
|
|
2644
|
-
pattern: /(@param\s+)<[A-Z]\w*>/,
|
|
2645
|
-
lookbehind: !0,
|
|
2646
|
-
inside: { punctuation: /[.<>]/ }
|
|
2647
|
-
},
|
|
2648
|
-
"code-section": [
|
|
2649
|
-
{
|
|
2650
|
-
pattern:
|
|
2651
|
-
/(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/,
|
|
2652
|
-
lookbehind: !0,
|
|
2653
|
-
inside: {
|
|
2654
|
-
code: {
|
|
2655
|
-
pattern: e,
|
|
2656
|
-
lookbehind: !0,
|
|
2657
|
-
inside: a.languages.java,
|
|
2658
|
-
alias: "language-java"
|
|
2659
|
-
}
|
|
2660
|
-
}
|
|
2661
|
-
},
|
|
2662
|
-
{
|
|
2663
|
-
pattern:
|
|
2664
|
-
/(<(code|pre|tt)>(?!<code>)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/,
|
|
2665
|
-
lookbehind: !0,
|
|
2666
|
-
inside: {
|
|
2667
|
-
line: {
|
|
2668
|
-
pattern: e,
|
|
2669
|
-
lookbehind: !0,
|
|
2670
|
-
inside: {
|
|
2671
|
-
tag: a.languages.markup.tag,
|
|
2672
|
-
entity: a.languages.markup.entity,
|
|
2673
|
-
code: {
|
|
2674
|
-
pattern: /.+/,
|
|
2675
|
-
inside: a.languages.java,
|
|
2676
|
-
alias: "language-java"
|
|
2677
|
-
}
|
|
2678
|
-
}
|
|
2679
|
-
}
|
|
2680
|
-
}
|
|
2681
|
-
}
|
|
2682
|
-
],
|
|
2683
|
-
tag: a.languages.markup.tag,
|
|
2684
|
-
entity: a.languages.markup.entity
|
|
2685
|
-
}),
|
|
2686
|
-
a.languages.javadoclike.addSupport("java", a.languages.javadoc);
|
|
2687
|
-
})(Prism);
|
|
2688
|
-
!(function (e) {
|
|
2689
|
-
(e.languages.typescript = e.languages.extend("javascript", {
|
|
2690
|
-
"class-name": {
|
|
2691
|
-
pattern:
|
|
2692
|
-
/(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
|
|
2693
|
-
lookbehind: !0,
|
|
2694
|
-
greedy: !0,
|
|
2695
|
-
inside: null
|
|
2696
|
-
},
|
|
2697
|
-
builtin:
|
|
2698
|
-
/\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
|
|
2699
|
-
})),
|
|
2700
|
-
e.languages.typescript.keyword.push(
|
|
2701
|
-
/\b(?:abstract|declare|is|keyof|readonly|require)\b/,
|
|
2702
|
-
/\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
|
|
2703
|
-
/\btype\b(?=\s*(?:[\{*]|$))/
|
|
2704
|
-
),
|
|
2705
|
-
delete e.languages.typescript.parameter,
|
|
2706
|
-
delete e.languages.typescript["literal-property"];
|
|
2707
|
-
var s = e.languages.extend("typescript", {});
|
|
2708
|
-
delete s["class-name"],
|
|
2709
|
-
(e.languages.typescript["class-name"].inside = s),
|
|
2710
|
-
e.languages.insertBefore("typescript", "function", {
|
|
2711
|
-
decorator: {
|
|
2712
|
-
pattern: /@[$\w\xA0-\uFFFF]+/,
|
|
2713
|
-
inside: {
|
|
2714
|
-
at: { pattern: /^@/, alias: "operator" },
|
|
2715
|
-
function: /^[\s\S]+/
|
|
2716
|
-
}
|
|
2717
|
-
},
|
|
2718
|
-
"generic-function": {
|
|
2719
|
-
pattern:
|
|
2720
|
-
/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
|
|
2721
|
-
greedy: !0,
|
|
2722
|
-
inside: {
|
|
2723
|
-
function:
|
|
2724
|
-
/^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
|
|
2725
|
-
generic: {
|
|
2726
|
-
pattern: /<[\s\S]+/,
|
|
2727
|
-
alias: "class-name",
|
|
2728
|
-
inside: s
|
|
2729
|
-
}
|
|
2730
|
-
}
|
|
2731
|
-
}
|
|
2732
|
-
}),
|
|
2733
|
-
(e.languages.ts = e.languages.typescript);
|
|
2734
|
-
})(Prism);
|
|
2735
|
-
!(function (e) {
|
|
2736
|
-
var a = e.languages.javascript,
|
|
2737
|
-
n = "\\{(?:[^{}]|\\{(?:[^{}]|\\{[^{}]*\\})*\\})+\\}",
|
|
2738
|
-
t = "(@(?:arg|argument|param|property)\\s+(?:" + n + "\\s+)?)";
|
|
2739
|
-
(e.languages.jsdoc = e.languages.extend("javadoclike", {
|
|
2740
|
-
parameter: {
|
|
2741
|
-
pattern: RegExp(
|
|
2742
|
-
t + "(?:(?!\\s)[$\\w\\xA0-\\uFFFF.])+(?=\\s|$)"
|
|
2743
|
-
),
|
|
2744
|
-
lookbehind: !0,
|
|
2745
|
-
inside: { punctuation: /\./ }
|
|
2746
|
-
}
|
|
2747
|
-
})),
|
|
2748
|
-
e.languages.insertBefore("jsdoc", "keyword", {
|
|
2749
|
-
"optional-parameter": {
|
|
2750
|
-
pattern: RegExp(
|
|
2751
|
-
t +
|
|
2752
|
-
"\\[(?:(?!\\s)[$\\w\\xA0-\\uFFFF.])+(?:=[^[\\]]+)?\\](?=\\s|$)"
|
|
2753
|
-
),
|
|
2754
|
-
lookbehind: !0,
|
|
2755
|
-
inside: {
|
|
2756
|
-
parameter: {
|
|
2757
|
-
pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/,
|
|
2758
|
-
lookbehind: !0,
|
|
2759
|
-
inside: { punctuation: /\./ }
|
|
2760
|
-
},
|
|
2761
|
-
code: {
|
|
2762
|
-
pattern: /(=)[\s\S]*(?=\]$)/,
|
|
2763
|
-
lookbehind: !0,
|
|
2764
|
-
inside: a,
|
|
2765
|
-
alias: "language-javascript"
|
|
2766
|
-
},
|
|
2767
|
-
punctuation: /[=[\]]/
|
|
2768
|
-
}
|
|
2769
|
-
},
|
|
2770
|
-
"class-name": [
|
|
2771
|
-
{
|
|
2772
|
-
pattern: RegExp(
|
|
2773
|
-
"(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\\s+(?:<TYPE>\\s+)?)[A-Z]\\w*(?:\\.[A-Z]\\w*)*".replace(
|
|
2774
|
-
/<TYPE>/g,
|
|
2775
|
-
function () {
|
|
2776
|
-
return n;
|
|
2777
|
-
}
|
|
2778
|
-
)
|
|
2779
|
-
),
|
|
2780
|
-
lookbehind: !0,
|
|
2781
|
-
inside: { punctuation: /\./ }
|
|
2782
|
-
},
|
|
2783
|
-
{
|
|
2784
|
-
pattern: RegExp("(@[a-z]+\\s+)" + n),
|
|
2785
|
-
lookbehind: !0,
|
|
2786
|
-
inside: {
|
|
2787
|
-
string: a.string,
|
|
2788
|
-
number: a.number,
|
|
2789
|
-
boolean: a.boolean,
|
|
2790
|
-
keyword: e.languages.typescript.keyword,
|
|
2791
|
-
operator: /=>|\.\.\.|[&|?:*]/,
|
|
2792
|
-
punctuation: /[.,;=<>{}()[\]]/
|
|
2793
|
-
}
|
|
2794
|
-
}
|
|
2795
|
-
],
|
|
2796
|
-
example: {
|
|
2797
|
-
pattern:
|
|
2798
|
-
/(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/,
|
|
2799
|
-
lookbehind: !0,
|
|
2800
|
-
inside: {
|
|
2801
|
-
code: {
|
|
2802
|
-
pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m,
|
|
2803
|
-
lookbehind: !0,
|
|
2804
|
-
inside: a,
|
|
2805
|
-
alias: "language-javascript"
|
|
2806
|
-
}
|
|
2807
|
-
}
|
|
2808
|
-
}
|
|
2809
|
-
}),
|
|
2810
|
-
e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
|
|
2811
|
-
})(Prism);
|
|
2812
|
-
!(function (a) {
|
|
2813
|
-
function e(a, e) {
|
|
2814
|
-
return RegExp(
|
|
2815
|
-
a.replace(/<ID>/g, function () {
|
|
2816
|
-
return "(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*";
|
|
2817
|
-
}),
|
|
2818
|
-
e
|
|
2819
|
-
);
|
|
2820
|
-
}
|
|
2821
|
-
a.languages.insertBefore("javascript", "function-variable", {
|
|
2822
|
-
"method-variable": {
|
|
2823
|
-
pattern: RegExp(
|
|
2824
|
-
"(\\.\\s*)" +
|
|
2825
|
-
a.languages.javascript["function-variable"].pattern
|
|
2826
|
-
.source
|
|
2827
|
-
),
|
|
2828
|
-
lookbehind: !0,
|
|
2829
|
-
alias: [
|
|
2830
|
-
"function-variable",
|
|
2831
|
-
"method",
|
|
2832
|
-
"function",
|
|
2833
|
-
"property-access"
|
|
2834
|
-
]
|
|
2835
|
-
}
|
|
2836
|
-
}),
|
|
2837
|
-
a.languages.insertBefore("javascript", "function", {
|
|
2838
|
-
method: {
|
|
2839
|
-
pattern: RegExp(
|
|
2840
|
-
"(\\.\\s*)" + a.languages.javascript.function.source
|
|
2841
|
-
),
|
|
2842
|
-
lookbehind: !0,
|
|
2843
|
-
alias: ["function", "property-access"]
|
|
2844
|
-
}
|
|
2845
|
-
}),
|
|
2846
|
-
a.languages.insertBefore("javascript", "constant", {
|
|
2847
|
-
"known-class-name": [
|
|
2848
|
-
{
|
|
2849
|
-
pattern:
|
|
2850
|
-
/\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
|
|
2851
|
-
alias: "class-name"
|
|
2852
|
-
},
|
|
2853
|
-
{ pattern: /\b(?:[A-Z]\w*)Error\b/, alias: "class-name" }
|
|
2854
|
-
]
|
|
2855
|
-
}),
|
|
2856
|
-
a.languages.insertBefore("javascript", "keyword", {
|
|
2857
|
-
imports: {
|
|
2858
|
-
pattern: e(
|
|
2859
|
-
"(\\bimport\\b\\s*)(?:<ID>(?:\\s*,\\s*(?:\\*\\s*as\\s+<ID>|\\{[^{}]*\\}))?|\\*\\s*as\\s+<ID>|\\{[^{}]*\\})(?=\\s*\\bfrom\\b)"
|
|
2860
|
-
),
|
|
2861
|
-
lookbehind: !0,
|
|
2862
|
-
inside: a.languages.javascript
|
|
2863
|
-
},
|
|
2864
|
-
exports: {
|
|
2865
|
-
pattern: e(
|
|
2866
|
-
"(\\bexport\\b\\s*)(?:\\*(?:\\s*as\\s+<ID>)?(?=\\s*\\bfrom\\b)|\\{[^{}]*\\})"
|
|
2867
|
-
),
|
|
2868
|
-
lookbehind: !0,
|
|
2869
|
-
inside: a.languages.javascript
|
|
2870
|
-
}
|
|
2871
|
-
}),
|
|
2872
|
-
a.languages.javascript.keyword.unshift(
|
|
2873
|
-
{
|
|
2874
|
-
pattern: /\b(?:as|default|export|from|import)\b/,
|
|
2875
|
-
alias: "module"
|
|
2876
|
-
},
|
|
2877
|
-
{
|
|
2878
|
-
pattern:
|
|
2879
|
-
/\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
|
|
2880
|
-
alias: "control-flow"
|
|
2881
|
-
},
|
|
2882
|
-
{ pattern: /\bnull\b/, alias: ["null", "nil"] },
|
|
2883
|
-
{ pattern: /\bundefined\b/, alias: "nil" }
|
|
2884
|
-
),
|
|
2885
|
-
a.languages.insertBefore("javascript", "operator", {
|
|
2886
|
-
spread: { pattern: /\.{3}/, alias: "operator" },
|
|
2887
|
-
arrow: { pattern: /=>/, alias: "operator" }
|
|
2888
|
-
}),
|
|
2889
|
-
a.languages.insertBefore("javascript", "punctuation", {
|
|
2890
|
-
"property-access": {
|
|
2891
|
-
pattern: e("(\\.\\s*)#?<ID>"),
|
|
2892
|
-
lookbehind: !0
|
|
2893
|
-
},
|
|
2894
|
-
"maybe-class-name": {
|
|
2895
|
-
pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
|
|
2896
|
-
lookbehind: !0
|
|
2897
|
-
},
|
|
2898
|
-
dom: {
|
|
2899
|
-
pattern:
|
|
2900
|
-
/\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
|
|
2901
|
-
alias: "variable"
|
|
2902
|
-
},
|
|
2903
|
-
console: { pattern: /\bconsole(?=\s*\.)/, alias: "class-name" }
|
|
2904
|
-
});
|
|
2905
|
-
for (
|
|
2906
|
-
var t = [
|
|
2907
|
-
"function",
|
|
2908
|
-
"function-variable",
|
|
2909
|
-
"method",
|
|
2910
|
-
"method-variable",
|
|
2911
|
-
"property-access"
|
|
2912
|
-
],
|
|
2913
|
-
r = 0;
|
|
2914
|
-
r < t.length;
|
|
2915
|
-
r++
|
|
2916
|
-
) {
|
|
2917
|
-
var n = t[r],
|
|
2918
|
-
s = a.languages.javascript[n];
|
|
2919
|
-
"RegExp" === a.util.type(s) &&
|
|
2920
|
-
(s = a.languages.javascript[n] = { pattern: s });
|
|
2921
|
-
var o = s.inside || {};
|
|
2922
|
-
(s.inside = o), (o["maybe-class-name"] = /^[A-Z][\s\S]*/);
|
|
2923
|
-
}
|
|
2924
|
-
})(Prism);
|
|
2925
|
-
(Prism.languages.json = {
|
|
2926
|
-
property: {
|
|
2927
|
-
pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
|
|
2928
|
-
lookbehind: !0,
|
|
2929
|
-
greedy: !0
|
|
2930
|
-
},
|
|
2931
|
-
string: {
|
|
2932
|
-
pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
|
|
2933
|
-
lookbehind: !0,
|
|
2934
|
-
greedy: !0
|
|
2935
|
-
},
|
|
2936
|
-
comment: { pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: !0 },
|
|
2937
|
-
number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
|
|
2938
|
-
punctuation: /[{}[\],]/,
|
|
2939
|
-
operator: /:/,
|
|
2940
|
-
boolean: /\b(?:false|true)\b/,
|
|
2941
|
-
null: { pattern: /\bnull\b/, alias: "keyword" }
|
|
2942
|
-
}),
|
|
2943
|
-
(Prism.languages.webmanifest = Prism.languages.json);
|
|
2944
|
-
!(function (n) {
|
|
2945
|
-
var e = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
|
|
2946
|
-
n.languages.json5 = n.languages.extend("json", {
|
|
2947
|
-
property: [
|
|
2948
|
-
{ pattern: RegExp(e.source + "(?=\\s*:)"), greedy: !0 },
|
|
2949
|
-
{
|
|
2950
|
-
pattern:
|
|
2951
|
-
/(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
|
|
2952
|
-
alias: "unquoted"
|
|
2953
|
-
}
|
|
2954
|
-
],
|
|
2955
|
-
string: { pattern: e, greedy: !0 },
|
|
2956
|
-
number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
|
|
2957
|
-
});
|
|
2958
|
-
})(Prism);
|
|
2959
|
-
(Prism.languages.jsonp = Prism.languages.extend("json", {
|
|
2960
|
-
punctuation: /[{}[\]();,.]/
|
|
2961
|
-
})),
|
|
2962
|
-
Prism.languages.insertBefore("jsonp", "punctuation", {
|
|
2963
|
-
function:
|
|
2964
|
-
/(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/
|
|
2965
|
-
});
|
|
2966
|
-
Prism.languages.jsstacktrace = {
|
|
2967
|
-
"error-message": { pattern: /^\S.*/m, alias: "string" },
|
|
2968
|
-
"stack-frame": {
|
|
2969
|
-
pattern: /(^[ \t]+)at[ \t].*/m,
|
|
2970
|
-
lookbehind: !0,
|
|
2971
|
-
inside: {
|
|
2972
|
-
"not-my-code": {
|
|
2973
|
-
pattern:
|
|
2974
|
-
/^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m,
|
|
2975
|
-
alias: "comment"
|
|
2976
|
-
},
|
|
2977
|
-
filename: {
|
|
2978
|
-
pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
|
|
2979
|
-
lookbehind: !0,
|
|
2980
|
-
alias: "url"
|
|
2981
|
-
},
|
|
2982
|
-
function: {
|
|
2983
|
-
pattern:
|
|
2984
|
-
/(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
|
|
2985
|
-
lookbehind: !0,
|
|
2986
|
-
inside: { punctuation: /\./ }
|
|
2987
|
-
},
|
|
2988
|
-
punctuation: /[()]/,
|
|
2989
|
-
keyword: /\b(?:at|new)\b/,
|
|
2990
|
-
alias: {
|
|
2991
|
-
pattern:
|
|
2992
|
-
/\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
|
|
2993
|
-
alias: "variable"
|
|
2994
|
-
},
|
|
2995
|
-
"line-number": {
|
|
2996
|
-
pattern: /:\d+(?::\d+)?\b/,
|
|
2997
|
-
alias: "number",
|
|
2998
|
-
inside: { punctuation: /:/ }
|
|
2999
|
-
}
|
|
3000
|
-
}
|
|
3001
|
-
}
|
|
3002
|
-
};
|
|
3003
|
-
!(function (n) {
|
|
3004
|
-
(n.languages.kotlin = n.languages.extend("clike", {
|
|
3005
|
-
keyword: {
|
|
3006
|
-
pattern:
|
|
3007
|
-
/(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
|
|
3008
|
-
lookbehind: !0
|
|
3009
|
-
},
|
|
3010
|
-
function: [
|
|
3011
|
-
{ pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/, greedy: !0 },
|
|
3012
|
-
{
|
|
3013
|
-
pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
|
|
3014
|
-
lookbehind: !0,
|
|
3015
|
-
greedy: !0
|
|
3016
|
-
}
|
|
3017
|
-
],
|
|
3018
|
-
number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
|
|
3019
|
-
operator:
|
|
3020
|
-
/\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
|
|
3021
|
-
})),
|
|
3022
|
-
delete n.languages.kotlin["class-name"];
|
|
3023
|
-
var e = {
|
|
3024
|
-
"interpolation-punctuation": {
|
|
3025
|
-
pattern: /^\$\{?|\}$/,
|
|
3026
|
-
alias: "punctuation"
|
|
3027
|
-
},
|
|
3028
|
-
expression: { pattern: /[\s\S]+/, inside: n.languages.kotlin }
|
|
3029
|
-
};
|
|
3030
|
-
n.languages.insertBefore("kotlin", "string", {
|
|
3031
|
-
"string-literal": [
|
|
3032
|
-
{
|
|
3033
|
-
pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
|
|
3034
|
-
alias: "multiline",
|
|
3035
|
-
inside: {
|
|
3036
|
-
interpolation: {
|
|
3037
|
-
pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
|
|
3038
|
-
inside: e
|
|
3039
|
-
},
|
|
3040
|
-
string: /[\s\S]+/
|
|
3041
|
-
}
|
|
3042
|
-
},
|
|
3043
|
-
{
|
|
3044
|
-
pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
|
|
3045
|
-
alias: "singleline",
|
|
3046
|
-
inside: {
|
|
3047
|
-
interpolation: {
|
|
3048
|
-
pattern:
|
|
3049
|
-
/((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
|
|
3050
|
-
lookbehind: !0,
|
|
3051
|
-
inside: e
|
|
3052
|
-
},
|
|
3053
|
-
string: /[\s\S]+/
|
|
3054
|
-
}
|
|
3055
|
-
}
|
|
3056
|
-
],
|
|
3057
|
-
char: {
|
|
3058
|
-
pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
|
|
3059
|
-
greedy: !0
|
|
3060
|
-
}
|
|
3061
|
-
}),
|
|
3062
|
-
delete n.languages.kotlin.string,
|
|
3063
|
-
n.languages.insertBefore("kotlin", "keyword", {
|
|
3064
|
-
annotation: {
|
|
3065
|
-
pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
|
|
3066
|
-
alias: "builtin"
|
|
3067
|
-
}
|
|
3068
|
-
}),
|
|
3069
|
-
n.languages.insertBefore("kotlin", "function", {
|
|
3070
|
-
label: { pattern: /\b\w+@|@\w+\b/, alias: "symbol" }
|
|
3071
|
-
}),
|
|
3072
|
-
(n.languages.kt = n.languages.kotlin),
|
|
3073
|
-
(n.languages.kts = n.languages.kotlin);
|
|
3074
|
-
})(Prism);
|
|
3075
|
-
!(function (n) {
|
|
3076
|
-
function e(n) {
|
|
3077
|
-
return (
|
|
3078
|
-
(n = n.replace(/<inner>/g, function () {
|
|
3079
|
-
return "(?:\\\\.|[^\\\\\n\r]|(?:\n|\r\n?)(?![\r\n]))";
|
|
3080
|
-
})),
|
|
3081
|
-
RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + n + ")")
|
|
3082
|
-
);
|
|
3083
|
-
}
|
|
3084
|
-
var t = "(?:\\\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\\\|\r\n`])+",
|
|
3085
|
-
a = "\\|?__(?:\\|__)+\\|?(?:(?:\n|\r\n?)|(?![^]))".replace(
|
|
3086
|
-
/__/g,
|
|
3087
|
-
function () {
|
|
3088
|
-
return t;
|
|
3089
|
-
}
|
|
3090
|
-
),
|
|
3091
|
-
i =
|
|
3092
|
-
"\\|?[ \t]*:?-{3,}:?[ \t]*(?:\\|[ \t]*:?-{3,}:?[ \t]*)+\\|?(?:\n|\r\n?)";
|
|
3093
|
-
(n.languages.markdown = n.languages.extend("markup", {})),
|
|
3094
|
-
n.languages.insertBefore("markdown", "prolog", {
|
|
3095
|
-
"front-matter-block": {
|
|
3096
|
-
pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
|
|
3097
|
-
lookbehind: !0,
|
|
3098
|
-
greedy: !0,
|
|
3099
|
-
inside: {
|
|
3100
|
-
punctuation: /^---|---$/,
|
|
3101
|
-
"front-matter": {
|
|
3102
|
-
pattern: /\S+(?:\s+\S+)*/,
|
|
3103
|
-
alias: ["yaml", "language-yaml"],
|
|
3104
|
-
inside: n.languages.yaml
|
|
3105
|
-
}
|
|
3106
|
-
}
|
|
3107
|
-
},
|
|
3108
|
-
blockquote: {
|
|
3109
|
-
pattern: /^>(?:[\t ]*>)*/m,
|
|
3110
|
-
alias: "punctuation"
|
|
3111
|
-
},
|
|
3112
|
-
table: {
|
|
3113
|
-
pattern: RegExp("^" + a + i + "(?:" + a + ")*", "m"),
|
|
3114
|
-
inside: {
|
|
3115
|
-
"table-data-rows": {
|
|
3116
|
-
pattern: RegExp("^(" + a + i + ")(?:" + a + ")*$"),
|
|
3117
|
-
lookbehind: !0,
|
|
3118
|
-
inside: {
|
|
3119
|
-
"table-data": {
|
|
3120
|
-
pattern: RegExp(t),
|
|
3121
|
-
inside: n.languages.markdown
|
|
3122
|
-
},
|
|
3123
|
-
punctuation: /\|/
|
|
3124
|
-
}
|
|
3125
|
-
},
|
|
3126
|
-
"table-line": {
|
|
3127
|
-
pattern: RegExp("^(" + a + ")" + i + "$"),
|
|
3128
|
-
lookbehind: !0,
|
|
3129
|
-
inside: { punctuation: /\||:?-{3,}:?/ }
|
|
3130
|
-
},
|
|
3131
|
-
"table-header-row": {
|
|
3132
|
-
pattern: RegExp("^" + a + "$"),
|
|
3133
|
-
inside: {
|
|
3134
|
-
"table-header": {
|
|
3135
|
-
pattern: RegExp(t),
|
|
3136
|
-
alias: "important",
|
|
3137
|
-
inside: n.languages.markdown
|
|
3138
|
-
},
|
|
3139
|
-
punctuation: /\|/
|
|
3140
|
-
}
|
|
3141
|
-
}
|
|
3142
|
-
}
|
|
3143
|
-
},
|
|
3144
|
-
code: [
|
|
3145
|
-
{
|
|
3146
|
-
pattern:
|
|
3147
|
-
/((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
|
|
3148
|
-
lookbehind: !0,
|
|
3149
|
-
alias: "keyword"
|
|
3150
|
-
},
|
|
3151
|
-
{
|
|
3152
|
-
pattern: /^```[\s\S]*?^```$/m,
|
|
3153
|
-
greedy: !0,
|
|
3154
|
-
inside: {
|
|
3155
|
-
"code-block": {
|
|
3156
|
-
pattern:
|
|
3157
|
-
/^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
|
|
3158
|
-
lookbehind: !0
|
|
3159
|
-
},
|
|
3160
|
-
"code-language": {
|
|
3161
|
-
pattern: /^(```).+/,
|
|
3162
|
-
lookbehind: !0
|
|
3163
|
-
},
|
|
3164
|
-
punctuation: /```/
|
|
3165
|
-
}
|
|
3166
|
-
}
|
|
3167
|
-
],
|
|
3168
|
-
title: [
|
|
3169
|
-
{
|
|
3170
|
-
pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
|
|
3171
|
-
alias: "important",
|
|
3172
|
-
inside: { punctuation: /==+$|--+$/ }
|
|
3173
|
-
},
|
|
3174
|
-
{
|
|
3175
|
-
pattern: /(^\s*)#.+/m,
|
|
3176
|
-
lookbehind: !0,
|
|
3177
|
-
alias: "important",
|
|
3178
|
-
inside: { punctuation: /^#+|#+$/ }
|
|
3179
|
-
}
|
|
3180
|
-
],
|
|
3181
|
-
hr: {
|
|
3182
|
-
pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
|
|
3183
|
-
lookbehind: !0,
|
|
3184
|
-
alias: "punctuation"
|
|
3185
|
-
},
|
|
3186
|
-
list: {
|
|
3187
|
-
pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
|
|
3188
|
-
lookbehind: !0,
|
|
3189
|
-
alias: "punctuation"
|
|
3190
|
-
},
|
|
3191
|
-
"url-reference": {
|
|
3192
|
-
pattern:
|
|
3193
|
-
/!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
|
|
3194
|
-
inside: {
|
|
3195
|
-
variable: { pattern: /^(!?\[)[^\]]+/, lookbehind: !0 },
|
|
3196
|
-
string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
|
|
3197
|
-
punctuation: /^[\[\]!:]|[<>]/
|
|
3198
|
-
},
|
|
3199
|
-
alias: "url"
|
|
3200
|
-
},
|
|
3201
|
-
bold: {
|
|
3202
|
-
pattern: e(
|
|
3203
|
-
"\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"
|
|
3204
|
-
),
|
|
3205
|
-
lookbehind: !0,
|
|
3206
|
-
greedy: !0,
|
|
3207
|
-
inside: {
|
|
3208
|
-
content: {
|
|
3209
|
-
pattern: /(^..)[\s\S]+(?=..$)/,
|
|
3210
|
-
lookbehind: !0,
|
|
3211
|
-
inside: {}
|
|
3212
|
-
},
|
|
3213
|
-
punctuation: /\*\*|__/
|
|
3214
|
-
}
|
|
3215
|
-
},
|
|
3216
|
-
italic: {
|
|
3217
|
-
pattern: e(
|
|
3218
|
-
"\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"
|
|
3219
|
-
),
|
|
3220
|
-
lookbehind: !0,
|
|
3221
|
-
greedy: !0,
|
|
3222
|
-
inside: {
|
|
3223
|
-
content: {
|
|
3224
|
-
pattern: /(^.)[\s\S]+(?=.$)/,
|
|
3225
|
-
lookbehind: !0,
|
|
3226
|
-
inside: {}
|
|
3227
|
-
},
|
|
3228
|
-
punctuation: /[*_]/
|
|
3229
|
-
}
|
|
3230
|
-
},
|
|
3231
|
-
strike: {
|
|
3232
|
-
pattern: e("(~~?)(?:(?!~)<inner>)+\\2"),
|
|
3233
|
-
lookbehind: !0,
|
|
3234
|
-
greedy: !0,
|
|
3235
|
-
inside: {
|
|
3236
|
-
content: {
|
|
3237
|
-
pattern: /(^~~?)[\s\S]+(?=\1$)/,
|
|
3238
|
-
lookbehind: !0,
|
|
3239
|
-
inside: {}
|
|
3240
|
-
},
|
|
3241
|
-
punctuation: /~~?/
|
|
3242
|
-
}
|
|
3243
|
-
},
|
|
3244
|
-
"code-snippet": {
|
|
3245
|
-
pattern:
|
|
3246
|
-
/(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
|
|
3247
|
-
lookbehind: !0,
|
|
3248
|
-
greedy: !0,
|
|
3249
|
-
alias: ["code", "keyword"]
|
|
3250
|
-
},
|
|
3251
|
-
url: {
|
|
3252
|
-
pattern: e(
|
|
3253
|
-
'!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\t ]+"(?:\\\\.|[^"\\\\])*")?\\)|[ \t]?\\[(?:(?!\\])<inner>)+\\])'
|
|
3254
|
-
),
|
|
3255
|
-
lookbehind: !0,
|
|
3256
|
-
greedy: !0,
|
|
3257
|
-
inside: {
|
|
3258
|
-
operator: /^!/,
|
|
3259
|
-
content: {
|
|
3260
|
-
pattern: /(^\[)[^\]]+(?=\])/,
|
|
3261
|
-
lookbehind: !0,
|
|
3262
|
-
inside: {}
|
|
3263
|
-
},
|
|
3264
|
-
variable: {
|
|
3265
|
-
pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
|
|
3266
|
-
lookbehind: !0
|
|
3267
|
-
},
|
|
3268
|
-
url: { pattern: /(^\]\()[^\s)]+/, lookbehind: !0 },
|
|
3269
|
-
string: {
|
|
3270
|
-
pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
|
|
3271
|
-
lookbehind: !0
|
|
3272
|
-
}
|
|
3273
|
-
}
|
|
3274
|
-
}
|
|
3275
|
-
}),
|
|
3276
|
-
["url", "bold", "italic", "strike"].forEach(function (e) {
|
|
3277
|
-
["url", "bold", "italic", "strike", "code-snippet"].forEach(
|
|
3278
|
-
function (t) {
|
|
3279
|
-
e !== t &&
|
|
3280
|
-
(n.languages.markdown[e].inside.content.inside[t] =
|
|
3281
|
-
n.languages.markdown[t]);
|
|
3282
|
-
}
|
|
3283
|
-
);
|
|
3284
|
-
}),
|
|
3285
|
-
n.hooks.add("after-tokenize", function (n) {
|
|
3286
|
-
("markdown" !== n.language && "md" !== n.language) ||
|
|
3287
|
-
(function n(e) {
|
|
3288
|
-
if (e && "string" != typeof e)
|
|
3289
|
-
for (var t = 0, a = e.length; t < a; t++) {
|
|
3290
|
-
var i = e[t];
|
|
3291
|
-
if ("code" === i.type) {
|
|
3292
|
-
var r = i.content[1],
|
|
3293
|
-
o = i.content[3];
|
|
3294
|
-
if (
|
|
3295
|
-
r &&
|
|
3296
|
-
o &&
|
|
3297
|
-
"code-language" === r.type &&
|
|
3298
|
-
"code-block" === o.type &&
|
|
3299
|
-
"string" == typeof r.content
|
|
3300
|
-
) {
|
|
3301
|
-
var l = r.content
|
|
3302
|
-
.replace(/\b#/g, "sharp")
|
|
3303
|
-
.replace(/\b\+\+/g, "pp"),
|
|
3304
|
-
s =
|
|
3305
|
-
"language-" +
|
|
3306
|
-
(l = (/[a-z][\w-]*/i.exec(
|
|
3307
|
-
l
|
|
3308
|
-
) || [""])[0].toLowerCase());
|
|
3309
|
-
o.alias
|
|
3310
|
-
? "string" == typeof o.alias
|
|
3311
|
-
? (o.alias = [o.alias, s])
|
|
3312
|
-
: o.alias.push(s)
|
|
3313
|
-
: (o.alias = [s]);
|
|
3314
|
-
}
|
|
3315
|
-
} else n(i.content);
|
|
3316
|
-
}
|
|
3317
|
-
})(n.tokens);
|
|
3318
|
-
}),
|
|
3319
|
-
n.hooks.add("wrap", function (e) {
|
|
3320
|
-
if ("code-block" === e.type) {
|
|
3321
|
-
for (var t = "", a = 0, i = e.classes.length; a < i; a++) {
|
|
3322
|
-
var s = e.classes[a],
|
|
3323
|
-
d = /language-(.+)/.exec(s);
|
|
3324
|
-
if (d) {
|
|
3325
|
-
t = d[1];
|
|
3326
|
-
break;
|
|
3327
|
-
}
|
|
3328
|
-
}
|
|
3329
|
-
var p = n.languages[t];
|
|
3330
|
-
if (p)
|
|
3331
|
-
e.content = n.highlight(
|
|
3332
|
-
e.content
|
|
3333
|
-
.replace(r, "")
|
|
3334
|
-
.replace(
|
|
3335
|
-
/&(\w{1,8}|#x?[\da-f]{1,8});/gi,
|
|
3336
|
-
function (n, e) {
|
|
3337
|
-
var t;
|
|
3338
|
-
return "#" === (e = e.toLowerCase())[0]
|
|
3339
|
-
? ((t =
|
|
3340
|
-
"x" === e[1]
|
|
3341
|
-
? parseInt(e.slice(2), 16)
|
|
3342
|
-
: Number(e.slice(1))),
|
|
3343
|
-
l(t))
|
|
3344
|
-
: o[e] || n;
|
|
3345
|
-
}
|
|
3346
|
-
),
|
|
3347
|
-
p,
|
|
3348
|
-
t
|
|
3349
|
-
);
|
|
3350
|
-
else if (t && "none" !== t && n.plugins.autoloader) {
|
|
3351
|
-
var u =
|
|
3352
|
-
"md-" +
|
|
3353
|
-
new Date().valueOf() +
|
|
3354
|
-
"-" +
|
|
3355
|
-
Math.floor(1e16 * Math.random());
|
|
3356
|
-
(e.attributes.id = u),
|
|
3357
|
-
n.plugins.autoloader.loadLanguages(t, function () {
|
|
3358
|
-
var e = document.getElementById(u);
|
|
3359
|
-
e &&
|
|
3360
|
-
(e.innerHTML = n.highlight(
|
|
3361
|
-
e.textContent,
|
|
3362
|
-
n.languages[t],
|
|
3363
|
-
t
|
|
3364
|
-
));
|
|
3365
|
-
});
|
|
3366
|
-
}
|
|
3367
|
-
}
|
|
3368
|
-
});
|
|
3369
|
-
var r = RegExp(n.languages.markup.tag.pattern.source, "gi"),
|
|
3370
|
-
o = { amp: "&", lt: "<", gt: ">", quot: '"' },
|
|
3371
|
-
l = String.fromCodePoint || String.fromCharCode;
|
|
3372
|
-
n.languages.md = n.languages.markdown;
|
|
3373
|
-
})(Prism);
|
|
3374
|
-
(Prism.languages.objectivec = Prism.languages.extend("c", {
|
|
3375
|
-
string: {
|
|
3376
|
-
pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
|
|
3377
|
-
greedy: !0
|
|
3378
|
-
},
|
|
3379
|
-
keyword:
|
|
3380
|
-
/\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/,
|
|
3381
|
-
operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/
|
|
3382
|
-
})),
|
|
3383
|
-
delete Prism.languages.objectivec["class-name"],
|
|
3384
|
-
(Prism.languages.objc = Prism.languages.objectivec);
|
|
3385
|
-
!(function (a) {
|
|
3386
|
-
var e = "(?:\\b[a-zA-Z]\\w*|[|\\\\[\\]])+";
|
|
3387
|
-
(a.languages.phpdoc = a.languages.extend("javadoclike", {
|
|
3388
|
-
parameter: {
|
|
3389
|
-
pattern: RegExp(
|
|
3390
|
-
"(@(?:global|param|property(?:-read|-write)?|var)\\s+(?:" +
|
|
3391
|
-
e +
|
|
3392
|
-
"\\s+)?)\\$\\w+"
|
|
3393
|
-
),
|
|
3394
|
-
lookbehind: !0
|
|
3395
|
-
}
|
|
3396
|
-
})),
|
|
3397
|
-
a.languages.insertBefore("phpdoc", "keyword", {
|
|
3398
|
-
"class-name": [
|
|
3399
|
-
{
|
|
3400
|
-
pattern: RegExp(
|
|
3401
|
-
"(@(?:global|package|param|property(?:-read|-write)?|return|subpackage|throws|var)\\s+)" +
|
|
3402
|
-
e
|
|
3403
|
-
),
|
|
3404
|
-
lookbehind: !0,
|
|
3405
|
-
inside: {
|
|
3406
|
-
keyword:
|
|
3407
|
-
/\b(?:array|bool|boolean|callback|double|false|float|int|integer|mixed|null|object|resource|self|string|true|void)\b/,
|
|
3408
|
-
punctuation: /[|\\[\]()]/
|
|
3409
|
-
}
|
|
3410
|
-
}
|
|
3411
|
-
]
|
|
3412
|
-
}),
|
|
3413
|
-
a.languages.javadoclike.addSupport("php", a.languages.phpdoc);
|
|
3414
|
-
})(Prism);
|
|
3415
|
-
Prism.languages.insertBefore("php", "variable", {
|
|
3416
|
-
this: { pattern: /\$this\b/, alias: "keyword" },
|
|
3417
|
-
global: /\$(?:GLOBALS|HTTP_RAW_POST_DATA|_(?:COOKIE|ENV|FILES|GET|POST|REQUEST|SERVER|SESSION)|argc|argv|http_response_header|php_errormsg)\b/,
|
|
3418
|
-
scope: {
|
|
3419
|
-
pattern: /\b[\w\\]+::/,
|
|
3420
|
-
inside: {
|
|
3421
|
-
keyword: /\b(?:parent|self|static)\b/,
|
|
3422
|
-
punctuation: /::|\\/
|
|
3423
|
-
}
|
|
3424
|
-
}
|
|
3425
|
-
});
|
|
3426
|
-
(Prism.languages.plsql = Prism.languages.extend("sql", {
|
|
3427
|
-
comment: { pattern: /\/\*[\s\S]*?\*\/|--.*/, greedy: !0 },
|
|
3428
|
-
keyword:
|
|
3429
|
-
/\b(?:A|ACCESSIBLE|ADD|AGENT|AGGREGATE|ALL|ALTER|AND|ANY|ARRAY|AS|ASC|AT|ATTRIBUTE|AUTHID|AVG|BEGIN|BETWEEN|BFILE_BASE|BINARY|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BULK|BY|BYTE|C|CALL|CALLING|CASCADE|CASE|CHAR|CHARACTER|CHARSET|CHARSETFORM|CHARSETID|CHAR_BASE|CHECK|CLOB_BASE|CLONE|CLOSE|CLUSTER|CLUSTERS|COLAUTH|COLLECT|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPILED|COMPRESS|CONNECT|CONSTANT|CONSTRUCTOR|CONTEXT|CONTINUE|CONVERT|COUNT|CRASH|CREATE|CREDENTIAL|CURRENT|CURSOR|CUSTOMDATUM|DANGLING|DATA|DATE|DATE_BASE|DAY|DECLARE|DEFAULT|DEFINE|DELETE|DESC|DETERMINISTIC|DIRECTORY|DISTINCT|DOUBLE|DROP|DURATION|ELEMENT|ELSE|ELSIF|EMPTY|END|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXECUTE|EXISTS|EXIT|EXTERNAL|FETCH|FINAL|FIRST|FIXED|FLOAT|FOR|FORALL|FORCE|FROM|FUNCTION|GENERAL|GOTO|GRANT|GROUP|HASH|HAVING|HEAP|HIDDEN|HOUR|IDENTIFIED|IF|IMMEDIATE|IMMUTABLE|IN|INCLUDING|INDEX|INDEXES|INDICATOR|INDICES|INFINITE|INSERT|INSTANTIABLE|INT|INTERFACE|INTERSECT|INTERVAL|INTO|INVALIDATE|IS|ISOLATION|JAVA|LANGUAGE|LARGE|LEADING|LENGTH|LEVEL|LIBRARY|LIKE|LIKE2|LIKE4|LIKEC|LIMIT|LIMITED|LOCAL|LOCK|LONG|LOOP|MAP|MAX|MAXLEN|MEMBER|MERGE|MIN|MINUS|MINUTE|MOD|MODE|MODIFY|MONTH|MULTISET|MUTABLE|NAME|NAN|NATIONAL|NATIVE|NCHAR|NEW|NOCOMPRESS|NOCOPY|NOT|NOWAIT|NULL|NUMBER_BASE|OBJECT|OCICOLL|OCIDATE|OCIDATETIME|OCIDURATION|OCIINTERVAL|OCILOBLOCATOR|OCINUMBER|OCIRAW|OCIREF|OCIREFCURSOR|OCIROWID|OCISTRING|OCITYPE|OF|OLD|ON|ONLY|OPAQUE|OPEN|OPERATOR|OPTION|OR|ORACLE|ORADATA|ORDER|ORGANIZATION|ORLANY|ORLVARY|OTHERS|OUT|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETER|PARAMETERS|PARENT|PARTITION|PASCAL|PERSISTABLE|PIPE|PIPELINED|PLUGGABLE|POLYMORPHIC|PRAGMA|PRECISION|PRIOR|PRIVATE|PROCEDURE|PUBLIC|RAISE|RANGE|RAW|READ|RECORD|REF|REFERENCE|RELIES_ON|REM|REMAINDER|RENAME|RESOURCE|RESULT|RESULT_CACHE|RETURN|RETURNING|REVERSE|REVOKE|ROLLBACK|ROW|SAMPLE|SAVE|SAVEPOINT|SB1|SB2|SB4|SECOND|SEGMENT|SELECT|SELF|SEPARATE|SEQUENCE|SERIALIZABLE|SET|SHARE|SHORT|SIZE|SIZE_T|SOME|SPARSE|SQL|SQLCODE|SQLDATA|SQLNAME|SQLSTATE|STANDARD|START|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUM|SYNONYM|TABAUTH|TABLE|TDO|THE|THEN|TIME|TIMESTAMP|TIMEZONE_ABBR|TIMEZONE_HOUR|TIMEZONE_MINUTE|TIMEZONE_REGION|TO|TRAILING|TRANSACTION|TRANSACTIONAL|TRUSTED|TYPE|UB1|UB2|UB4|UNDER|UNION|UNIQUE|UNPLUG|UNSIGNED|UNTRUSTED|UPDATE|USE|USING|VALIST|VALUE|VALUES|VARIABLE|VARIANCE|VARRAY|VARYING|VIEW|VIEWS|VOID|WHEN|WHERE|WHILE|WITH|WORK|WRAPPED|WRITE|YEAR|ZONE)\b/i,
|
|
3430
|
-
operator: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
|
|
3431
|
-
})),
|
|
3432
|
-
Prism.languages.insertBefore("plsql", "operator", {
|
|
3433
|
-
label: { pattern: /<<\s*\w+\s*>>/, alias: "symbol" }
|
|
3434
|
-
});
|
|
3435
|
-
(Prism.languages.python = {
|
|
3436
|
-
comment: { pattern: /(^|[^\\])#.*/, lookbehind: !0, greedy: !0 },
|
|
3437
|
-
"string-interpolation": {
|
|
3438
|
-
pattern:
|
|
3439
|
-
/(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
|
|
3440
|
-
greedy: !0,
|
|
3441
|
-
inside: {
|
|
3442
|
-
interpolation: {
|
|
3443
|
-
pattern:
|
|
3444
|
-
/((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
|
|
3445
|
-
lookbehind: !0,
|
|
3446
|
-
inside: {
|
|
3447
|
-
"format-spec": {
|
|
3448
|
-
pattern: /(:)[^:(){}]+(?=\}$)/,
|
|
3449
|
-
lookbehind: !0
|
|
3450
|
-
},
|
|
3451
|
-
"conversion-option": {
|
|
3452
|
-
pattern: //,
|
|
3453
|
-
alias: "punctuation"
|
|
3454
|
-
},
|
|
3455
|
-
rest: null
|
|
3456
|
-
}
|
|
3457
|
-
},
|
|
3458
|
-
string: /[\s\S]+/
|
|
3459
|
-
}
|
|
3460
|
-
},
|
|
3461
|
-
"triple-quoted-string": {
|
|
3462
|
-
pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
|
|
3463
|
-
greedy: !0,
|
|
3464
|
-
alias: "string"
|
|
3465
|
-
},
|
|
3466
|
-
string: {
|
|
3467
|
-
pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
|
|
3468
|
-
greedy: !0
|
|
3469
|
-
},
|
|
3470
|
-
function: {
|
|
3471
|
-
pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
|
|
3472
|
-
lookbehind: !0
|
|
3473
|
-
},
|
|
3474
|
-
"class-name": { pattern: /(\bclass\s+)\w+/i, lookbehind: !0 },
|
|
3475
|
-
decorator: {
|
|
3476
|
-
pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
|
|
3477
|
-
lookbehind: !0,
|
|
3478
|
-
alias: ["annotation", "punctuation"],
|
|
3479
|
-
inside: { punctuation: /\./ }
|
|
3480
|
-
},
|
|
3481
|
-
keyword:
|
|
3482
|
-
/\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
|
|
3483
|
-
builtin:
|
|
3484
|
-
/\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
|
|
3485
|
-
boolean: /\b(?:False|None|True)\b/,
|
|
3486
|
-
number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
|
|
3487
|
-
operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
|
|
3488
|
-
punctuation: /[{}[\];(),.:]/
|
|
3489
|
-
}),
|
|
3490
|
-
(Prism.languages.python[
|
|
3491
|
-
"string-interpolation"
|
|
3492
|
-
].inside.interpolation.inside.rest = Prism.languages.python),
|
|
3493
|
-
(Prism.languages.py = Prism.languages.python);
|
|
3494
|
-
!(function (t) {
|
|
3495
|
-
var n = t.util.clone(t.languages.javascript),
|
|
3496
|
-
e = "(?:\\{<S>*\\.{3}(?:[^{}]|<BRACES>)*\\})";
|
|
3497
|
-
function a(t, n) {
|
|
3498
|
-
return (
|
|
3499
|
-
(t = t
|
|
3500
|
-
.replace(/<S>/g, function () {
|
|
3501
|
-
return "(?:\\s|//.*(?!.)|/\\*(?:[^*]|\\*(?!/))\\*/)";
|
|
3502
|
-
})
|
|
3503
|
-
.replace(/<BRACES>/g, function () {
|
|
3504
|
-
return "(?:\\{(?:\\{(?:\\{[^{}]*\\}|[^{}])*\\}|[^{}])*\\})";
|
|
3505
|
-
})
|
|
3506
|
-
.replace(/<SPREAD>/g, function () {
|
|
3507
|
-
return e;
|
|
3508
|
-
})),
|
|
3509
|
-
RegExp(t, n)
|
|
3510
|
-
);
|
|
3511
|
-
}
|
|
3512
|
-
(e = a(e).source),
|
|
3513
|
-
(t.languages.jsx = t.languages.extend("markup", n)),
|
|
3514
|
-
(t.languages.jsx.tag.pattern = a(
|
|
3515
|
-
"</?(?:[\\w.:-]+(?:<S>+(?:[\\w.:$-]+(?:=(?:\"(?:\\\\[^]|[^\\\\\"])*\"|'(?:\\\\[^]|[^\\\\'])*'|[^\\s{'\"/>=]+|<BRACES>))?|<SPREAD>))*<S>*/?)?>"
|
|
3516
|
-
)),
|
|
3517
|
-
(t.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/),
|
|
3518
|
-
(t.languages.jsx.tag.inside["attr-value"].pattern =
|
|
3519
|
-
/=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/),
|
|
3520
|
-
(t.languages.jsx.tag.inside.tag.inside["class-name"] =
|
|
3521
|
-
/^[A-Z]\w*(?:\.[A-Z]\w*)*$/),
|
|
3522
|
-
(t.languages.jsx.tag.inside.comment = n.comment),
|
|
3523
|
-
t.languages.insertBefore(
|
|
3524
|
-
"inside",
|
|
3525
|
-
"attr-name",
|
|
3526
|
-
{ spread: { pattern: a("<SPREAD>"), inside: t.languages.jsx } },
|
|
3527
|
-
t.languages.jsx.tag
|
|
3528
|
-
),
|
|
3529
|
-
t.languages.insertBefore(
|
|
3530
|
-
"inside",
|
|
3531
|
-
"special-attr",
|
|
3532
|
-
{
|
|
3533
|
-
script: {
|
|
3534
|
-
pattern: a("=<BRACES>"),
|
|
3535
|
-
alias: "language-javascript",
|
|
3536
|
-
inside: {
|
|
3537
|
-
"script-punctuation": {
|
|
3538
|
-
pattern: /^=(?=\{)/,
|
|
3539
|
-
alias: "punctuation"
|
|
3540
|
-
},
|
|
3541
|
-
rest: t.languages.jsx
|
|
3542
|
-
}
|
|
3543
|
-
}
|
|
3544
|
-
},
|
|
3545
|
-
t.languages.jsx.tag
|
|
3546
|
-
);
|
|
3547
|
-
var s = function (t) {
|
|
3548
|
-
return t
|
|
3549
|
-
? "string" == typeof t
|
|
3550
|
-
? t
|
|
3551
|
-
: "string" == typeof t.content
|
|
3552
|
-
? t.content
|
|
3553
|
-
: t.content.map(s).join("")
|
|
3554
|
-
: "";
|
|
3555
|
-
},
|
|
3556
|
-
g = function (n) {
|
|
3557
|
-
for (var e = [], a = 0; a < n.length; a++) {
|
|
3558
|
-
var o = n[a],
|
|
3559
|
-
i = !1;
|
|
3560
|
-
if (
|
|
3561
|
-
("string" != typeof o &&
|
|
3562
|
-
("tag" === o.type &&
|
|
3563
|
-
o.content[0] &&
|
|
3564
|
-
"tag" === o.content[0].type
|
|
3565
|
-
? "</" === o.content[0].content[0].content
|
|
3566
|
-
? e.length > 0 &&
|
|
3567
|
-
e[e.length - 1].tagName ===
|
|
3568
|
-
s(o.content[0].content[1]) &&
|
|
3569
|
-
e.pop()
|
|
3570
|
-
: "/>" ===
|
|
3571
|
-
o.content[o.content.length - 1]
|
|
3572
|
-
.content ||
|
|
3573
|
-
e.push({
|
|
3574
|
-
tagName: s(o.content[0].content[1]),
|
|
3575
|
-
openedBraces: 0
|
|
3576
|
-
})
|
|
3577
|
-
: e.length > 0 &&
|
|
3578
|
-
"punctuation" === o.type &&
|
|
3579
|
-
"{" === o.content
|
|
3580
|
-
? e[e.length - 1].openedBraces++
|
|
3581
|
-
: e.length > 0 &&
|
|
3582
|
-
e[e.length - 1].openedBraces > 0 &&
|
|
3583
|
-
"punctuation" === o.type &&
|
|
3584
|
-
"}" === o.content
|
|
3585
|
-
? e[e.length - 1].openedBraces--
|
|
3586
|
-
: (i = !0)),
|
|
3587
|
-
(i || "string" == typeof o) &&
|
|
3588
|
-
e.length > 0 &&
|
|
3589
|
-
0 === e[e.length - 1].openedBraces)
|
|
3590
|
-
) {
|
|
3591
|
-
var r = s(o);
|
|
3592
|
-
a < n.length - 1 &&
|
|
3593
|
-
("string" == typeof n[a + 1] ||
|
|
3594
|
-
"plain-text" === n[a + 1].type) &&
|
|
3595
|
-
((r += s(n[a + 1])), n.splice(a + 1, 1)),
|
|
3596
|
-
a > 0 &&
|
|
3597
|
-
("string" == typeof n[a - 1] ||
|
|
3598
|
-
"plain-text" === n[a - 1].type) &&
|
|
3599
|
-
((r = s(n[a - 1]) + r),
|
|
3600
|
-
n.splice(a - 1, 1),
|
|
3601
|
-
a--),
|
|
3602
|
-
(n[a] = new t.Token("plain-text", r, null, r));
|
|
3603
|
-
}
|
|
3604
|
-
o.content && "string" != typeof o.content && g(o.content);
|
|
3605
|
-
}
|
|
3606
|
-
};
|
|
3607
|
-
t.hooks.add("after-tokenize", function (t) {
|
|
3608
|
-
("jsx" !== t.language && "tsx" !== t.language) || g(t.tokens);
|
|
3609
|
-
});
|
|
3610
|
-
})(Prism);
|
|
3611
|
-
!(function (a) {
|
|
3612
|
-
var e = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" },
|
|
3613
|
-
n =
|
|
3614
|
-
/\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/,
|
|
3615
|
-
t = "(?:[^\\\\-]|" + n.source + ")",
|
|
3616
|
-
s = RegExp(t + "-" + t),
|
|
3617
|
-
i = {
|
|
3618
|
-
pattern: /(<|')[^<>']+(?=[>']$)/,
|
|
3619
|
-
lookbehind: !0,
|
|
3620
|
-
alias: "variable"
|
|
3621
|
-
};
|
|
3622
|
-
a.languages.regex = {
|
|
3623
|
-
"char-class": {
|
|
3624
|
-
pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
|
|
3625
|
-
lookbehind: !0,
|
|
3626
|
-
inside: {
|
|
3627
|
-
"char-class-negation": {
|
|
3628
|
-
pattern: /(^\[)\^/,
|
|
3629
|
-
lookbehind: !0,
|
|
3630
|
-
alias: "operator"
|
|
3631
|
-
},
|
|
3632
|
-
"char-class-punctuation": {
|
|
3633
|
-
pattern: /^\[|\]$/,
|
|
3634
|
-
alias: "punctuation"
|
|
3635
|
-
},
|
|
3636
|
-
range: {
|
|
3637
|
-
pattern: s,
|
|
3638
|
-
inside: {
|
|
3639
|
-
escape: n,
|
|
3640
|
-
"range-punctuation": {
|
|
3641
|
-
pattern: /-/,
|
|
3642
|
-
alias: "operator"
|
|
3643
|
-
}
|
|
3644
|
-
}
|
|
3645
|
-
},
|
|
3646
|
-
"special-escape": e,
|
|
3647
|
-
"char-set": {
|
|
3648
|
-
pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
|
|
3649
|
-
alias: "class-name"
|
|
3650
|
-
},
|
|
3651
|
-
escape: n
|
|
3652
|
-
}
|
|
3653
|
-
},
|
|
3654
|
-
"special-escape": e,
|
|
3655
|
-
"char-set": {
|
|
3656
|
-
pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
|
|
3657
|
-
alias: "class-name"
|
|
3658
|
-
},
|
|
3659
|
-
backreference: [
|
|
3660
|
-
{ pattern: /\\(?![123][0-7]{2})[1-9]/, alias: "keyword" },
|
|
3661
|
-
{
|
|
3662
|
-
pattern: /\\k<[^<>']+>/,
|
|
3663
|
-
alias: "keyword",
|
|
3664
|
-
inside: { "group-name": i }
|
|
3665
|
-
}
|
|
3666
|
-
],
|
|
3667
|
-
anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" },
|
|
3668
|
-
escape: n,
|
|
3669
|
-
group: [
|
|
3670
|
-
{
|
|
3671
|
-
pattern:
|
|
3672
|
-
/\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
|
|
3673
|
-
alias: "punctuation",
|
|
3674
|
-
inside: { "group-name": i }
|
|
3675
|
-
},
|
|
3676
|
-
{ pattern: /\)/, alias: "punctuation" }
|
|
3677
|
-
],
|
|
3678
|
-
quantifier: {
|
|
3679
|
-
pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
|
|
3680
|
-
alias: "number"
|
|
3681
|
-
},
|
|
3682
|
-
alternation: { pattern: /\|/, alias: "keyword" }
|
|
3683
|
-
};
|
|
3684
|
-
})(Prism);
|
|
3685
|
-
(Prism.languages.swift = {
|
|
3686
|
-
comment: {
|
|
3687
|
-
pattern:
|
|
3688
|
-
/(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
|
|
3689
|
-
lookbehind: !0,
|
|
3690
|
-
greedy: !0
|
|
3691
|
-
},
|
|
3692
|
-
"string-literal": [
|
|
3693
|
-
{
|
|
3694
|
-
pattern: RegExp(
|
|
3695
|
-
'(^|[^"#])(?:"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\r\n|[^(])|[^\\\\\r\n"])*"|"""(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\"]|"(?!""))*""")(?!["#])'
|
|
3696
|
-
),
|
|
3697
|
-
lookbehind: !0,
|
|
3698
|
-
greedy: !0,
|
|
3699
|
-
inside: {
|
|
3700
|
-
interpolation: {
|
|
3701
|
-
pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
|
|
3702
|
-
lookbehind: !0,
|
|
3703
|
-
inside: null
|
|
3704
|
-
},
|
|
3705
|
-
"interpolation-punctuation": {
|
|
3706
|
-
pattern: /^\)|\\\($/,
|
|
3707
|
-
alias: "punctuation"
|
|
3708
|
-
},
|
|
3709
|
-
punctuation: /\\(?=[\r\n])/,
|
|
3710
|
-
string: /[\s\S]+/
|
|
3711
|
-
}
|
|
3712
|
-
},
|
|
3713
|
-
{
|
|
3714
|
-
pattern: RegExp(
|
|
3715
|
-
'(^|[^"#])(#+)(?:"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\r\n|[^#])|[^\\\\\r\n])*?"|"""(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?""")\\2'
|
|
3716
|
-
),
|
|
3717
|
-
lookbehind: !0,
|
|
3718
|
-
greedy: !0,
|
|
3719
|
-
inside: {
|
|
3720
|
-
interpolation: {
|
|
3721
|
-
pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
|
|
3722
|
-
lookbehind: !0,
|
|
3723
|
-
inside: null
|
|
3724
|
-
},
|
|
3725
|
-
"interpolation-punctuation": {
|
|
3726
|
-
pattern: /^\)|\\#+\($/,
|
|
3727
|
-
alias: "punctuation"
|
|
3728
|
-
},
|
|
3729
|
-
string: /[\s\S]+/
|
|
3730
|
-
}
|
|
3731
|
-
}
|
|
3732
|
-
],
|
|
3733
|
-
directive: {
|
|
3734
|
-
pattern: RegExp(
|
|
3735
|
-
"#(?:(?:elseif|if)\\b(?:[ \t]*(?:![ \t]*)?(?:\\b\\w+\\b(?:[ \t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \t]*(?:&&|\\|\\|))?)+|(?:else|endif)\\b)"
|
|
3736
|
-
),
|
|
3737
|
-
alias: "property",
|
|
3738
|
-
inside: {
|
|
3739
|
-
"directive-name": /^#\w+/,
|
|
3740
|
-
boolean: /\b(?:false|true)\b/,
|
|
3741
|
-
number: /\b\d+(?:\.\d+)*\b/,
|
|
3742
|
-
operator: /!|&&|\|\||[<>]=?/,
|
|
3743
|
-
punctuation: /[(),]/
|
|
3744
|
-
}
|
|
3745
|
-
},
|
|
3746
|
-
literal: {
|
|
3747
|
-
pattern:
|
|
3748
|
-
/#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
|
|
3749
|
-
alias: "constant"
|
|
3750
|
-
},
|
|
3751
|
-
"other-directive": { pattern: /#\w+\b/, alias: "property" },
|
|
3752
|
-
attribute: { pattern: /@\w+/, alias: "atrule" },
|
|
3753
|
-
"function-definition": {
|
|
3754
|
-
pattern: /(\bfunc\s+)\w+/,
|
|
3755
|
-
lookbehind: !0,
|
|
3756
|
-
alias: "function"
|
|
3757
|
-
},
|
|
3758
|
-
label: {
|
|
3759
|
-
pattern:
|
|
3760
|
-
/\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
|
|
3761
|
-
lookbehind: !0,
|
|
3762
|
-
alias: "important"
|
|
3763
|
-
},
|
|
3764
|
-
keyword:
|
|
3765
|
-
/\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
|
|
3766
|
-
boolean: /\b(?:false|true)\b/,
|
|
3767
|
-
nil: { pattern: /\bnil\b/, alias: "constant" },
|
|
3768
|
-
"short-argument": /\$\d+\b/,
|
|
3769
|
-
omit: { pattern: /\b_\b/, alias: "keyword" },
|
|
3770
|
-
number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
|
|
3771
|
-
"class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
|
|
3772
|
-
function: /\b[a-z_]\w*(?=\s*\()/i,
|
|
3773
|
-
constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
|
|
3774
|
-
operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
|
|
3775
|
-
punctuation: /[{}[\]();,.:\\]/
|
|
3776
|
-
}),
|
|
3777
|
-
Prism.languages.swift["string-literal"].forEach(function (e) {
|
|
3778
|
-
e.inside.interpolation.inside = Prism.languages.swift;
|
|
3779
|
-
});
|
|
3780
|
-
!(function (E) {
|
|
3781
|
-
var n =
|
|
3782
|
-
/\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\b/;
|
|
3783
|
-
(E.languages.typoscript = {
|
|
3784
|
-
comment: [
|
|
3785
|
-
{ pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/, lookbehind: !0 },
|
|
3786
|
-
{
|
|
3787
|
-
pattern: /(^|[^\\:= \t]|(?:^|[^= \t])[ \t]+)\/\/.*/,
|
|
3788
|
-
lookbehind: !0,
|
|
3789
|
-
greedy: !0
|
|
3790
|
-
},
|
|
3791
|
-
{ pattern: /(^|[^"'])#.*/, lookbehind: !0, greedy: !0 }
|
|
3792
|
-
],
|
|
3793
|
-
function: [
|
|
3794
|
-
{
|
|
3795
|
-
pattern:
|
|
3796
|
-
/<INCLUDE_TYPOSCRIPT:\s*source\s*=\s*(?:"[^"\r\n]*"|'[^'\r\n]*')\s*>/,
|
|
3797
|
-
inside: {
|
|
3798
|
-
string: {
|
|
3799
|
-
pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
|
|
3800
|
-
inside: { keyword: n }
|
|
3801
|
-
},
|
|
3802
|
-
keyword: { pattern: /INCLUDE_TYPOSCRIPT/ }
|
|
3803
|
-
}
|
|
3804
|
-
},
|
|
3805
|
-
{
|
|
3806
|
-
pattern: /@import\s*(?:"[^"\r\n]*"|'[^'\r\n]*')/,
|
|
3807
|
-
inside: { string: /"[^"\r\n]*"|'[^'\r\n]*'/ }
|
|
3808
|
-
}
|
|
3809
|
-
],
|
|
3810
|
-
string: {
|
|
3811
|
-
pattern: /^([^=]*=[< ]?)(?:(?!\]\n).)*/,
|
|
3812
|
-
lookbehind: !0,
|
|
3813
|
-
inside: {
|
|
3814
|
-
function: /\{\$.*\}/,
|
|
3815
|
-
keyword: n,
|
|
3816
|
-
number: /^\d+$/,
|
|
3817
|
-
punctuation: /[,|:]/
|
|
3818
|
-
}
|
|
3819
|
-
},
|
|
3820
|
-
keyword: n,
|
|
3821
|
-
number: { pattern: /\b\d+\s*[.{=]/, inside: { operator: /[.{=]/ } },
|
|
3822
|
-
tag: { pattern: /\.?[-\w\\]+\.?/, inside: { punctuation: /\./ } },
|
|
3823
|
-
punctuation: /[{}[\];(),.:|]/,
|
|
3824
|
-
operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/
|
|
3825
|
-
}),
|
|
3826
|
-
(E.languages.tsconfig = E.languages.typoscript);
|
|
3827
|
-
})(Prism);
|
|
3828
|
-
(Prism.languages.uri = {
|
|
3829
|
-
scheme: {
|
|
3830
|
-
pattern: /^[a-z][a-z0-9+.-]*:/im,
|
|
3831
|
-
greedy: !0,
|
|
3832
|
-
inside: { "scheme-delimiter": /:$/ }
|
|
3833
|
-
},
|
|
3834
|
-
fragment: {
|
|
3835
|
-
pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
|
|
3836
|
-
inside: { "fragment-delimiter": /^#/ }
|
|
3837
|
-
},
|
|
3838
|
-
query: {
|
|
3839
|
-
pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
|
|
3840
|
-
inside: {
|
|
3841
|
-
"query-delimiter": { pattern: /^\?/, greedy: !0 },
|
|
3842
|
-
"pair-delimiter": /[&;]/,
|
|
3843
|
-
pair: {
|
|
3844
|
-
pattern: /^[^=][\s\S]*/,
|
|
3845
|
-
inside: {
|
|
3846
|
-
key: /^[^=]+/,
|
|
3847
|
-
value: { pattern: /(^=)[\s\S]+/, lookbehind: !0 }
|
|
3848
|
-
}
|
|
3849
|
-
}
|
|
3850
|
-
}
|
|
3851
|
-
},
|
|
3852
|
-
authority: {
|
|
3853
|
-
pattern: RegExp(
|
|
3854
|
-
"^//(?:[\\w\\-.~!$&'()*+,;=%:]*@)?(?:\\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\\.[\\w\\-.~!$&'()*+,;=]+)\\]|[\\w\\-.~!$&'()*+,;=%]*)(?::\\d*)?",
|
|
3855
|
-
"m"
|
|
3856
|
-
),
|
|
3857
|
-
inside: {
|
|
3858
|
-
"authority-delimiter": /^\/\//,
|
|
3859
|
-
"user-info-segment": {
|
|
3860
|
-
pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
|
|
3861
|
-
inside: {
|
|
3862
|
-
"user-info-delimiter": /@$/,
|
|
3863
|
-
"user-info": /^[\w\-.~!$&'()*+,;=%:]+/
|
|
3864
|
-
}
|
|
3865
|
-
},
|
|
3866
|
-
"port-segment": {
|
|
3867
|
-
pattern: /:\d*$/,
|
|
3868
|
-
inside: { "port-delimiter": /^:/, port: /^\d+/ }
|
|
3869
|
-
},
|
|
3870
|
-
host: {
|
|
3871
|
-
pattern: /[\s\S]+/,
|
|
3872
|
-
inside: {
|
|
3873
|
-
"ip-literal": {
|
|
3874
|
-
pattern: /^\[[\s\S]+\]$/,
|
|
3875
|
-
inside: {
|
|
3876
|
-
"ip-literal-delimiter": /^\[|\]$/,
|
|
3877
|
-
"ipv-future": /^v[\s\S]+/,
|
|
3878
|
-
"ipv6-address": /^[\s\S]+/
|
|
3879
|
-
}
|
|
3880
|
-
},
|
|
3881
|
-
"ipv4-address":
|
|
3882
|
-
/^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
|
|
3883
|
-
}
|
|
3884
|
-
}
|
|
3885
|
-
}
|
|
3886
|
-
},
|
|
3887
|
-
path: {
|
|
3888
|
-
pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
|
|
3889
|
-
inside: { "path-separator": /\// }
|
|
3890
|
-
}
|
|
3891
|
-
}),
|
|
3892
|
-
(Prism.languages.url = Prism.languages.uri);
|
|
3893
|
-
Prism.languages.vbnet = Prism.languages.extend("basic", {
|
|
3894
|
-
comment: [
|
|
3895
|
-
{ pattern: /(?:!|REM\b).+/i, inside: { keyword: /^REM/i } },
|
|
3896
|
-
{ pattern: /(^|[^\\:])'.*/, lookbehind: !0, greedy: !0 }
|
|
3897
|
-
],
|
|
3898
|
-
string: {
|
|
3899
|
-
pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
|
|
3900
|
-
lookbehind: !0,
|
|
3901
|
-
greedy: !0
|
|
3902
|
-
},
|
|
3903
|
-
keyword:
|
|
3904
|
-
/(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
|
|
3905
|
-
punctuation: /[,;:(){}]/
|
|
3906
|
-
});
|
|
3907
|
-
!(function (e) {
|
|
3908
|
-
var n = /[*&][^\s[\]{},]+/,
|
|
3909
|
-
r =
|
|
3910
|
-
/!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/,
|
|
3911
|
-
t =
|
|
3912
|
-
"(?:" +
|
|
3913
|
-
r.source +
|
|
3914
|
-
"(?:[ \t]+" +
|
|
3915
|
-
n.source +
|
|
3916
|
-
")?|" +
|
|
3917
|
-
n.source +
|
|
3918
|
-
"(?:[ \t]+" +
|
|
3919
|
-
r.source +
|
|
3920
|
-
")?)",
|
|
3921
|
-
a =
|
|
3922
|
-
"(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*".replace(
|
|
3923
|
-
/<PLAIN>/g,
|
|
3924
|
-
function () {
|
|
3925
|
-
return "[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]";
|
|
3926
|
-
}
|
|
3927
|
-
),
|
|
3928
|
-
d = "\"(?:[^\"\\\\\r\n]|\\\\.)*\"|'(?:[^'\\\\\r\n]|\\\\.)*'";
|
|
3929
|
-
function o(e, n) {
|
|
3930
|
-
n = (n || "").replace(/m/g, "") + "m";
|
|
3931
|
-
var r =
|
|
3932
|
-
"([:\\-,[{]\\s*(?:\\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\\]|\\}|(?:[\r\n]\\s*)?#))"
|
|
3933
|
-
.replace(/<<prop>>/g, function () {
|
|
3934
|
-
return t;
|
|
3935
|
-
})
|
|
3936
|
-
.replace(/<<value>>/g, function () {
|
|
3937
|
-
return e;
|
|
3938
|
-
});
|
|
3939
|
-
return RegExp(r, n);
|
|
3940
|
-
}
|
|
3941
|
-
(e.languages.yaml = {
|
|
3942
|
-
scalar: {
|
|
3943
|
-
pattern: RegExp(
|
|
3944
|
-
"([\\-:]\\s*(?:\\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\\S[^\r\n]*(?:\\2[^\r\n]+)*)".replace(
|
|
3945
|
-
/<<prop>>/g,
|
|
3946
|
-
function () {
|
|
3947
|
-
return t;
|
|
3948
|
-
}
|
|
3949
|
-
)
|
|
3950
|
-
),
|
|
3951
|
-
lookbehind: !0,
|
|
3952
|
-
alias: "string"
|
|
3953
|
-
},
|
|
3954
|
-
comment: /#.*/,
|
|
3955
|
-
key: {
|
|
3956
|
-
pattern: RegExp(
|
|
3957
|
-
"((?:^|[:\\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\\s*:\\s)"
|
|
3958
|
-
.replace(/<<prop>>/g, function () {
|
|
3959
|
-
return t;
|
|
3960
|
-
})
|
|
3961
|
-
.replace(/<<key>>/g, function () {
|
|
3962
|
-
return "(?:" + a + "|" + d + ")";
|
|
3963
|
-
})
|
|
3964
|
-
),
|
|
3965
|
-
lookbehind: !0,
|
|
3966
|
-
greedy: !0,
|
|
3967
|
-
alias: "atrule"
|
|
3968
|
-
},
|
|
3969
|
-
directive: {
|
|
3970
|
-
pattern: /(^[ \t]*)%.+/m,
|
|
3971
|
-
lookbehind: !0,
|
|
3972
|
-
alias: "important"
|
|
3973
|
-
},
|
|
3974
|
-
datetime: {
|
|
3975
|
-
pattern: o(
|
|
3976
|
-
"\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ \t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?"
|
|
3977
|
-
),
|
|
3978
|
-
lookbehind: !0,
|
|
3979
|
-
alias: "number"
|
|
3980
|
-
},
|
|
3981
|
-
boolean: {
|
|
3982
|
-
pattern: o("false|true", "i"),
|
|
3983
|
-
lookbehind: !0,
|
|
3984
|
-
alias: "important"
|
|
3985
|
-
},
|
|
3986
|
-
null: {
|
|
3987
|
-
pattern: o("null|~", "i"),
|
|
3988
|
-
lookbehind: !0,
|
|
3989
|
-
alias: "important"
|
|
3990
|
-
},
|
|
3991
|
-
string: { pattern: o(d), lookbehind: !0, greedy: !0 },
|
|
3992
|
-
number: {
|
|
3993
|
-
pattern: o(
|
|
3994
|
-
"[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)",
|
|
3995
|
-
"i"
|
|
3996
|
-
),
|
|
3997
|
-
lookbehind: !0
|
|
3998
|
-
},
|
|
3999
|
-
tag: r,
|
|
4000
|
-
important: n,
|
|
4001
|
-
punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
|
|
4002
|
-
}),
|
|
4003
|
-
(e.languages.yml = e.languages.yaml);
|
|
4004
|
-
})(Prism);
|
|
4005
|
-
"undefined" != typeof Prism &&
|
|
4006
|
-
"undefined" != typeof document &&
|
|
4007
|
-
(Element.prototype.matches ||
|
|
4008
|
-
(Element.prototype.matches =
|
|
4009
|
-
Element.prototype.msMatchesSelector ||
|
|
4010
|
-
Element.prototype.webkitMatchesSelector),
|
|
4011
|
-
(Prism.plugins.UnescapedMarkup = !0),
|
|
4012
|
-
Prism.hooks.add("before-highlightall", function (e) {
|
|
4013
|
-
e.selector +=
|
|
4014
|
-
', [class*="lang-"] script[type="text/plain"], [class*="language-"] script[type="text/plain"], script[type="text/plain"][class*="lang-"], script[type="text/plain"][class*="language-"]';
|
|
4015
|
-
}),
|
|
4016
|
-
Prism.hooks.add("before-sanity-check", function (e) {
|
|
4017
|
-
var t = e.element;
|
|
4018
|
-
if (t.matches('script[type="text/plain"]')) {
|
|
4019
|
-
var a = document.createElement("code"),
|
|
4020
|
-
c = document.createElement("pre");
|
|
4021
|
-
c.className = a.className = t.className;
|
|
4022
|
-
var n = t.dataset;
|
|
4023
|
-
return (
|
|
4024
|
-
Object.keys(n || {}).forEach(function (e) {
|
|
4025
|
-
Object.prototype.hasOwnProperty.call(n, e) &&
|
|
4026
|
-
(c.dataset[e] = n[e]);
|
|
4027
|
-
}),
|
|
4028
|
-
(a.textContent = e.code =
|
|
4029
|
-
e.code.replace(
|
|
4030
|
-
/<\/script(?:>|>)/gi,
|
|
4031
|
-
"</script>"
|
|
4032
|
-
)),
|
|
4033
|
-
c.appendChild(a),
|
|
4034
|
-
t.parentNode.replaceChild(c, t),
|
|
4035
|
-
void (e.element = a)
|
|
4036
|
-
);
|
|
4037
|
-
}
|
|
4038
|
-
if (!e.code) {
|
|
4039
|
-
var o = t.childNodes;
|
|
4040
|
-
1 === o.length &&
|
|
4041
|
-
"#comment" == o[0].nodeName &&
|
|
4042
|
-
(t.textContent = e.code = o[0].textContent);
|
|
4043
|
-
}
|
|
4044
|
-
}));
|
|
4045
|
-
!(function () {
|
|
4046
|
-
if ("undefined" != typeof Prism && "undefined" != typeof document) {
|
|
4047
|
-
var e = { "(": ")", "[": "]", "{": "}" },
|
|
4048
|
-
t = {
|
|
4049
|
-
"(": "brace-round",
|
|
4050
|
-
"[": "brace-square",
|
|
4051
|
-
"{": "brace-curly"
|
|
4052
|
-
},
|
|
4053
|
-
n = { "${": "{" },
|
|
4054
|
-
r = 0,
|
|
4055
|
-
c = /^(pair-\d+-)(close|open)$/;
|
|
4056
|
-
Prism.hooks.add("complete", function (c) {
|
|
4057
|
-
var i = c.element,
|
|
4058
|
-
d = i.parentElement;
|
|
4059
|
-
if (d && "PRE" == d.tagName) {
|
|
4060
|
-
var u = [];
|
|
4061
|
-
if (
|
|
4062
|
-
(Prism.util.isActive(i, "match-braces") &&
|
|
4063
|
-
u.push("(", "[", "{"),
|
|
4064
|
-
0 != u.length)
|
|
4065
|
-
) {
|
|
4066
|
-
d.__listenerAdded ||
|
|
4067
|
-
(d.addEventListener("mousedown", function () {
|
|
4068
|
-
var e = d.querySelector("code"),
|
|
4069
|
-
t = s("brace-selected");
|
|
4070
|
-
Array.prototype.slice
|
|
4071
|
-
.call(e.querySelectorAll("." + t))
|
|
4072
|
-
.forEach(function (e) {
|
|
4073
|
-
e.classList.remove(t);
|
|
4074
|
-
});
|
|
4075
|
-
}),
|
|
4076
|
-
Object.defineProperty(d, "__listenerAdded", {
|
|
4077
|
-
value: !0
|
|
4078
|
-
}));
|
|
4079
|
-
var f = Array.prototype.slice.call(
|
|
4080
|
-
i.querySelectorAll(
|
|
4081
|
-
"span." +
|
|
4082
|
-
s("token") +
|
|
4083
|
-
"." +
|
|
4084
|
-
s("punctuation")
|
|
4085
|
-
)
|
|
4086
|
-
),
|
|
4087
|
-
h = [];
|
|
4088
|
-
u.forEach(function (c) {
|
|
4089
|
-
for (
|
|
4090
|
-
var i = e[c],
|
|
4091
|
-
d = s(t[c]),
|
|
4092
|
-
u = [],
|
|
4093
|
-
p = [],
|
|
4094
|
-
v = 0;
|
|
4095
|
-
v < f.length;
|
|
4096
|
-
v++
|
|
4097
|
-
) {
|
|
4098
|
-
var m = f[v];
|
|
4099
|
-
if (0 == m.childElementCount) {
|
|
4100
|
-
var b = m.textContent;
|
|
4101
|
-
(b = n[b] || b) === c
|
|
4102
|
-
? (h.push({
|
|
4103
|
-
index: v,
|
|
4104
|
-
open: !0,
|
|
4105
|
-
element: m
|
|
4106
|
-
}),
|
|
4107
|
-
m.classList.add(d),
|
|
4108
|
-
m.classList.add(s("brace-open")),
|
|
4109
|
-
p.push(v))
|
|
4110
|
-
: b === i &&
|
|
4111
|
-
(h.push({
|
|
4112
|
-
index: v,
|
|
4113
|
-
open: !1,
|
|
4114
|
-
element: m
|
|
4115
|
-
}),
|
|
4116
|
-
m.classList.add(d),
|
|
4117
|
-
m.classList.add(s("brace-close")),
|
|
4118
|
-
p.length && u.push([v, p.pop()]));
|
|
4119
|
-
}
|
|
4120
|
-
}
|
|
4121
|
-
u.forEach(function (e) {
|
|
4122
|
-
var t = "pair-" + r++ + "-",
|
|
4123
|
-
n = f[e[0]],
|
|
4124
|
-
c = f[e[1]];
|
|
4125
|
-
(n.id = t + "open"),
|
|
4126
|
-
(c.id = t + "close"),
|
|
4127
|
-
[n, c].forEach(function (e) {
|
|
4128
|
-
e.addEventListener("mouseenter", a),
|
|
4129
|
-
e.addEventListener("mouseleave", o),
|
|
4130
|
-
e.addEventListener("click", l);
|
|
4131
|
-
});
|
|
4132
|
-
});
|
|
4133
|
-
});
|
|
4134
|
-
var p = 0;
|
|
4135
|
-
h.sort(function (e, t) {
|
|
4136
|
-
return e.index - t.index;
|
|
4137
|
-
}),
|
|
4138
|
-
h.forEach(function (e) {
|
|
4139
|
-
e.open
|
|
4140
|
-
? (e.element.classList.add(
|
|
4141
|
-
s("brace-level-" + ((p % 12) + 1))
|
|
4142
|
-
),
|
|
4143
|
-
p++)
|
|
4144
|
-
: ((p = Math.max(0, p - 1)),
|
|
4145
|
-
e.element.classList.add(
|
|
4146
|
-
s("brace-level-" + ((p % 12) + 1))
|
|
4147
|
-
));
|
|
4148
|
-
});
|
|
4149
|
-
}
|
|
4150
|
-
}
|
|
4151
|
-
});
|
|
4152
|
-
}
|
|
4153
|
-
function s(e) {
|
|
4154
|
-
var t = Prism.plugins.customClass;
|
|
4155
|
-
return t ? t.apply(e, "none") : e;
|
|
4156
|
-
}
|
|
4157
|
-
function i(e) {
|
|
4158
|
-
var t = c.exec(e.id);
|
|
4159
|
-
return document.querySelector(
|
|
4160
|
-
"#" + t[1] + ("open" == t[2] ? "close" : "open")
|
|
4161
|
-
);
|
|
4162
|
-
}
|
|
4163
|
-
function a() {
|
|
4164
|
-
Prism.util.isActive(this, "brace-hover", !0) &&
|
|
4165
|
-
[this, i(this)].forEach(function (e) {
|
|
4166
|
-
e.classList.add(s("brace-hover"));
|
|
4167
|
-
});
|
|
4168
|
-
}
|
|
4169
|
-
function o() {
|
|
4170
|
-
[this, i(this)].forEach(function (e) {
|
|
4171
|
-
e.classList.remove(s("brace-hover"));
|
|
4172
|
-
});
|
|
4173
|
-
}
|
|
4174
|
-
function l() {
|
|
4175
|
-
Prism.util.isActive(this, "brace-select", !0) &&
|
|
4176
|
-
[this, i(this)].forEach(function (e) {
|
|
4177
|
-
e.classList.add(s("brace-selected"));
|
|
4178
|
-
});
|
|
4179
|
-
}
|
|
4180
|
-
})();
|
|
4181
|
-
});
|
|
4182
|
-
//End autogenerated code
|
|
4183
|
-
export default prism;
|