| 1 |
efrain |
1 |
/**
|
|
|
2 |
* TinyMCE version 6.8.3 (2024-02-08)
|
|
|
3 |
*/
|
|
|
4 |
|
|
|
5 |
(function () {
|
|
|
6 |
'use strict';
|
|
|
7 |
|
|
|
8 |
var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager');
|
|
|
9 |
|
|
|
10 |
const isNullable = a => a === null || a === undefined;
|
|
|
11 |
const isNonNullable = a => !isNullable(a);
|
|
|
12 |
|
|
|
13 |
const noop = () => {
|
|
|
14 |
};
|
|
|
15 |
const constant = value => {
|
|
|
16 |
return () => {
|
|
|
17 |
return value;
|
|
|
18 |
};
|
|
|
19 |
};
|
|
|
20 |
|
|
|
21 |
class Optional {
|
|
|
22 |
constructor(tag, value) {
|
|
|
23 |
this.tag = tag;
|
|
|
24 |
this.value = value;
|
|
|
25 |
}
|
|
|
26 |
static some(value) {
|
|
|
27 |
return new Optional(true, value);
|
|
|
28 |
}
|
|
|
29 |
static none() {
|
|
|
30 |
return Optional.singletonNone;
|
|
|
31 |
}
|
|
|
32 |
fold(onNone, onSome) {
|
|
|
33 |
if (this.tag) {
|
|
|
34 |
return onSome(this.value);
|
|
|
35 |
} else {
|
|
|
36 |
return onNone();
|
|
|
37 |
}
|
|
|
38 |
}
|
|
|
39 |
isSome() {
|
|
|
40 |
return this.tag;
|
|
|
41 |
}
|
|
|
42 |
isNone() {
|
|
|
43 |
return !this.tag;
|
|
|
44 |
}
|
|
|
45 |
map(mapper) {
|
|
|
46 |
if (this.tag) {
|
|
|
47 |
return Optional.some(mapper(this.value));
|
|
|
48 |
} else {
|
|
|
49 |
return Optional.none();
|
|
|
50 |
}
|
|
|
51 |
}
|
|
|
52 |
bind(binder) {
|
|
|
53 |
if (this.tag) {
|
|
|
54 |
return binder(this.value);
|
|
|
55 |
} else {
|
|
|
56 |
return Optional.none();
|
|
|
57 |
}
|
|
|
58 |
}
|
|
|
59 |
exists(predicate) {
|
|
|
60 |
return this.tag && predicate(this.value);
|
|
|
61 |
}
|
|
|
62 |
forall(predicate) {
|
|
|
63 |
return !this.tag || predicate(this.value);
|
|
|
64 |
}
|
|
|
65 |
filter(predicate) {
|
|
|
66 |
if (!this.tag || predicate(this.value)) {
|
|
|
67 |
return this;
|
|
|
68 |
} else {
|
|
|
69 |
return Optional.none();
|
|
|
70 |
}
|
|
|
71 |
}
|
|
|
72 |
getOr(replacement) {
|
|
|
73 |
return this.tag ? this.value : replacement;
|
|
|
74 |
}
|
|
|
75 |
or(replacement) {
|
|
|
76 |
return this.tag ? this : replacement;
|
|
|
77 |
}
|
|
|
78 |
getOrThunk(thunk) {
|
|
|
79 |
return this.tag ? this.value : thunk();
|
|
|
80 |
}
|
|
|
81 |
orThunk(thunk) {
|
|
|
82 |
return this.tag ? this : thunk();
|
|
|
83 |
}
|
|
|
84 |
getOrDie(message) {
|
|
|
85 |
if (!this.tag) {
|
|
|
86 |
throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
|
|
|
87 |
} else {
|
|
|
88 |
return this.value;
|
|
|
89 |
}
|
|
|
90 |
}
|
|
|
91 |
static from(value) {
|
|
|
92 |
return isNonNullable(value) ? Optional.some(value) : Optional.none();
|
|
|
93 |
}
|
|
|
94 |
getOrNull() {
|
|
|
95 |
return this.tag ? this.value : null;
|
|
|
96 |
}
|
|
|
97 |
getOrUndefined() {
|
|
|
98 |
return this.value;
|
|
|
99 |
}
|
|
|
100 |
each(worker) {
|
|
|
101 |
if (this.tag) {
|
|
|
102 |
worker(this.value);
|
|
|
103 |
}
|
|
|
104 |
}
|
|
|
105 |
toArray() {
|
|
|
106 |
return this.tag ? [this.value] : [];
|
|
|
107 |
}
|
|
|
108 |
toString() {
|
|
|
109 |
return this.tag ? `some(${ this.value })` : 'none()';
|
|
|
110 |
}
|
|
|
111 |
}
|
|
|
112 |
Optional.singletonNone = new Optional(false);
|
|
|
113 |
|
|
|
114 |
const get$1 = (xs, i) => i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
|
|
|
115 |
const head = xs => get$1(xs, 0);
|
|
|
116 |
|
|
|
117 |
var global$1 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
|
|
|
118 |
|
|
|
119 |
const Global = typeof window !== 'undefined' ? window : Function('return this;')();
|
|
|
120 |
|
|
|
121 |
const prismjs = function (global, module, exports) {
|
|
|
122 |
const oldprism = window.Prism;
|
|
|
123 |
window.Prism = { manual: true };
|
|
|
124 |
var _self = typeof window !== 'undefined' ? window : typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self : {};
|
|
|
125 |
var Prism = function (_self) {
|
|
|
126 |
var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
|
|
|
127 |
var uniqueId = 0;
|
|
|
128 |
var plainTextGrammar = {};
|
|
|
129 |
var _ = {
|
|
|
130 |
manual: _self.Prism && _self.Prism.manual,
|
|
|
131 |
disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
|
|
|
132 |
util: {
|
|
|
133 |
encode: function encode(tokens) {
|
|
|
134 |
if (tokens instanceof Token) {
|
|
|
135 |
return new Token(tokens.type, encode(tokens.content), tokens.alias);
|
|
|
136 |
} else if (Array.isArray(tokens)) {
|
|
|
137 |
return tokens.map(encode);
|
|
|
138 |
} else {
|
|
|
139 |
return tokens.replace(/&/g, '&').replace(/</g, '<').replace(/\u00a0/g, ' ');
|
|
|
140 |
}
|
|
|
141 |
},
|
|
|
142 |
type: function (o) {
|
|
|
143 |
return Object.prototype.toString.call(o).slice(8, -1);
|
|
|
144 |
},
|
|
|
145 |
objId: function (obj) {
|
|
|
146 |
if (!obj['__id']) {
|
|
|
147 |
Object.defineProperty(obj, '__id', { value: ++uniqueId });
|
|
|
148 |
}
|
|
|
149 |
return obj['__id'];
|
|
|
150 |
},
|
|
|
151 |
clone: function deepClone(o, visited) {
|
|
|
152 |
visited = visited || {};
|
|
|
153 |
var clone;
|
|
|
154 |
var id;
|
|
|
155 |
switch (_.util.type(o)) {
|
|
|
156 |
case 'Object':
|
|
|
157 |
id = _.util.objId(o);
|
|
|
158 |
if (visited[id]) {
|
|
|
159 |
return visited[id];
|
|
|
160 |
}
|
|
|
161 |
clone = {};
|
|
|
162 |
visited[id] = clone;
|
|
|
163 |
for (var key in o) {
|
|
|
164 |
if (o.hasOwnProperty(key)) {
|
|
|
165 |
clone[key] = deepClone(o[key], visited);
|
|
|
166 |
}
|
|
|
167 |
}
|
|
|
168 |
return clone;
|
|
|
169 |
case 'Array':
|
|
|
170 |
id = _.util.objId(o);
|
|
|
171 |
if (visited[id]) {
|
|
|
172 |
return visited[id];
|
|
|
173 |
}
|
|
|
174 |
clone = [];
|
|
|
175 |
visited[id] = clone;
|
|
|
176 |
o.forEach(function (v, i) {
|
|
|
177 |
clone[i] = deepClone(v, visited);
|
|
|
178 |
});
|
|
|
179 |
return clone;
|
|
|
180 |
default:
|
|
|
181 |
return o;
|
|
|
182 |
}
|
|
|
183 |
},
|
|
|
184 |
getLanguage: function (element) {
|
|
|
185 |
while (element) {
|
|
|
186 |
var m = lang.exec(element.className);
|
|
|
187 |
if (m) {
|
|
|
188 |
return m[1].toLowerCase();
|
|
|
189 |
}
|
|
|
190 |
element = element.parentElement;
|
|
|
191 |
}
|
|
|
192 |
return 'none';
|
|
|
193 |
},
|
|
|
194 |
setLanguage: function (element, language) {
|
|
|
195 |
element.className = element.className.replace(RegExp(lang, 'gi'), '');
|
|
|
196 |
element.classList.add('language-' + language);
|
|
|
197 |
},
|
|
|
198 |
currentScript: function () {
|
|
|
199 |
if (typeof document === 'undefined') {
|
|
|
200 |
return null;
|
|
|
201 |
}
|
|
|
202 |
if ('currentScript' in document && 1 < 2) {
|
|
|
203 |
return document.currentScript;
|
|
|
204 |
}
|
|
|
205 |
try {
|
|
|
206 |
throw new Error();
|
|
|
207 |
} catch (err) {
|
|
|
208 |
var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) || [])[1];
|
|
|
209 |
if (src) {
|
|
|
210 |
var scripts = document.getElementsByTagName('script');
|
|
|
211 |
for (var i in scripts) {
|
|
|
212 |
if (scripts[i].src == src) {
|
|
|
213 |
return scripts[i];
|
|
|
214 |
}
|
|
|
215 |
}
|
|
|
216 |
}
|
|
|
217 |
return null;
|
|
|
218 |
}
|
|
|
219 |
},
|
|
|
220 |
isActive: function (element, className, defaultActivation) {
|
|
|
221 |
var no = 'no-' + className;
|
|
|
222 |
while (element) {
|
|
|
223 |
var classList = element.classList;
|
|
|
224 |
if (classList.contains(className)) {
|
|
|
225 |
return true;
|
|
|
226 |
}
|
|
|
227 |
if (classList.contains(no)) {
|
|
|
228 |
return false;
|
|
|
229 |
}
|
|
|
230 |
element = element.parentElement;
|
|
|
231 |
}
|
|
|
232 |
return !!defaultActivation;
|
|
|
233 |
}
|
|
|
234 |
},
|
|
|
235 |
languages: {
|
|
|
236 |
plain: plainTextGrammar,
|
|
|
237 |
plaintext: plainTextGrammar,
|
|
|
238 |
text: plainTextGrammar,
|
|
|
239 |
txt: plainTextGrammar,
|
|
|
240 |
extend: function (id, redef) {
|
|
|
241 |
var lang = _.util.clone(_.languages[id]);
|
|
|
242 |
for (var key in redef) {
|
|
|
243 |
lang[key] = redef[key];
|
|
|
244 |
}
|
|
|
245 |
return lang;
|
|
|
246 |
},
|
|
|
247 |
insertBefore: function (inside, before, insert, root) {
|
|
|
248 |
root = root || _.languages;
|
|
|
249 |
var grammar = root[inside];
|
|
|
250 |
var ret = {};
|
|
|
251 |
for (var token in grammar) {
|
|
|
252 |
if (grammar.hasOwnProperty(token)) {
|
|
|
253 |
if (token == before) {
|
|
|
254 |
for (var newToken in insert) {
|
|
|
255 |
if (insert.hasOwnProperty(newToken)) {
|
|
|
256 |
ret[newToken] = insert[newToken];
|
|
|
257 |
}
|
|
|
258 |
}
|
|
|
259 |
}
|
|
|
260 |
if (!insert.hasOwnProperty(token)) {
|
|
|
261 |
ret[token] = grammar[token];
|
|
|
262 |
}
|
|
|
263 |
}
|
|
|
264 |
}
|
|
|
265 |
var old = root[inside];
|
|
|
266 |
root[inside] = ret;
|
|
|
267 |
_.languages.DFS(_.languages, function (key, value) {
|
|
|
268 |
if (value === old && key != inside) {
|
|
|
269 |
this[key] = ret;
|
|
|
270 |
}
|
|
|
271 |
});
|
|
|
272 |
return ret;
|
|
|
273 |
},
|
|
|
274 |
DFS: function DFS(o, callback, type, visited) {
|
|
|
275 |
visited = visited || {};
|
|
|
276 |
var objId = _.util.objId;
|
|
|
277 |
for (var i in o) {
|
|
|
278 |
if (o.hasOwnProperty(i)) {
|
|
|
279 |
callback.call(o, i, o[i], type || i);
|
|
|
280 |
var property = o[i];
|
|
|
281 |
var propertyType = _.util.type(property);
|
|
|
282 |
if (propertyType === 'Object' && !visited[objId(property)]) {
|
|
|
283 |
visited[objId(property)] = true;
|
|
|
284 |
DFS(property, callback, null, visited);
|
|
|
285 |
} else if (propertyType === 'Array' && !visited[objId(property)]) {
|
|
|
286 |
visited[objId(property)] = true;
|
|
|
287 |
DFS(property, callback, i, visited);
|
|
|
288 |
}
|
|
|
289 |
}
|
|
|
290 |
}
|
|
|
291 |
}
|
|
|
292 |
},
|
|
|
293 |
plugins: {},
|
|
|
294 |
highlightAll: function (async, callback) {
|
|
|
295 |
_.highlightAllUnder(document, async, callback);
|
|
|
296 |
},
|
|
|
297 |
highlightAllUnder: function (container, async, callback) {
|
|
|
298 |
var env = {
|
|
|
299 |
callback: callback,
|
|
|
300 |
container: container,
|
|
|
301 |
selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
|
|
|
302 |
};
|
|
|
303 |
_.hooks.run('before-highlightall', env);
|
|
|
304 |
env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));
|
|
|
305 |
_.hooks.run('before-all-elements-highlight', env);
|
|
|
306 |
for (var i = 0, element; element = env.elements[i++];) {
|
|
|
307 |
_.highlightElement(element, async === true, env.callback);
|
|
|
308 |
}
|
|
|
309 |
},
|
|
|
310 |
highlightElement: function (element, async, callback) {
|
|
|
311 |
var language = _.util.getLanguage(element);
|
|
|
312 |
var grammar = _.languages[language];
|
|
|
313 |
_.util.setLanguage(element, language);
|
|
|
314 |
var parent = element.parentElement;
|
|
|
315 |
if (parent && parent.nodeName.toLowerCase() === 'pre') {
|
|
|
316 |
_.util.setLanguage(parent, language);
|
|
|
317 |
}
|
|
|
318 |
var code = element.textContent;
|
|
|
319 |
var env = {
|
|
|
320 |
element: element,
|
|
|
321 |
language: language,
|
|
|
322 |
grammar: grammar,
|
|
|
323 |
code: code
|
|
|
324 |
};
|
|
|
325 |
function insertHighlightedCode(highlightedCode) {
|
|
|
326 |
env.highlightedCode = highlightedCode;
|
|
|
327 |
_.hooks.run('before-insert', env);
|
|
|
328 |
env.element.innerHTML = env.highlightedCode;
|
|
|
329 |
_.hooks.run('after-highlight', env);
|
|
|
330 |
_.hooks.run('complete', env);
|
|
|
331 |
callback && callback.call(env.element);
|
|
|
332 |
}
|
|
|
333 |
_.hooks.run('before-sanity-check', env);
|
|
|
334 |
parent = env.element.parentElement;
|
|
|
335 |
if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) {
|
|
|
336 |
parent.setAttribute('tabindex', '0');
|
|
|
337 |
}
|
|
|
338 |
if (!env.code) {
|
|
|
339 |
_.hooks.run('complete', env);
|
|
|
340 |
callback && callback.call(env.element);
|
|
|
341 |
return;
|
|
|
342 |
}
|
|
|
343 |
_.hooks.run('before-highlight', env);
|
|
|
344 |
if (!env.grammar) {
|
|
|
345 |
insertHighlightedCode(_.util.encode(env.code));
|
|
|
346 |
return;
|
|
|
347 |
}
|
|
|
348 |
if (async && _self.Worker) {
|
|
|
349 |
var worker = new Worker(_.filename);
|
|
|
350 |
worker.onmessage = function (evt) {
|
|
|
351 |
insertHighlightedCode(evt.data);
|
|
|
352 |
};
|
|
|
353 |
worker.postMessage(JSON.stringify({
|
|
|
354 |
language: env.language,
|
|
|
355 |
code: env.code,
|
|
|
356 |
immediateClose: true
|
|
|
357 |
}));
|
|
|
358 |
} else {
|
|
|
359 |
insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
|
|
|
360 |
}
|
|
|
361 |
},
|
|
|
362 |
highlight: function (text, grammar, language) {
|
|
|
363 |
var env = {
|
|
|
364 |
code: text,
|
|
|
365 |
grammar: grammar,
|
|
|
366 |
language: language
|
|
|
367 |
};
|
|
|
368 |
_.hooks.run('before-tokenize', env);
|
|
|
369 |
if (!env.grammar) {
|
|
|
370 |
throw new Error('The language "' + env.language + '" has no grammar.');
|
|
|
371 |
}
|
|
|
372 |
env.tokens = _.tokenize(env.code, env.grammar);
|
|
|
373 |
_.hooks.run('after-tokenize', env);
|
|
|
374 |
return Token.stringify(_.util.encode(env.tokens), env.language);
|
|
|
375 |
},
|
|
|
376 |
tokenize: function (text, grammar) {
|
|
|
377 |
var rest = grammar.rest;
|
|
|
378 |
if (rest) {
|
|
|
379 |
for (var token in rest) {
|
|
|
380 |
grammar[token] = rest[token];
|
|
|
381 |
}
|
|
|
382 |
delete grammar.rest;
|
|
|
383 |
}
|
|
|
384 |
var tokenList = new LinkedList();
|
|
|
385 |
addAfter(tokenList, tokenList.head, text);
|
|
|
386 |
matchGrammar(text, tokenList, grammar, tokenList.head, 0);
|
|
|
387 |
return toArray(tokenList);
|
|
|
388 |
},
|
|
|
389 |
hooks: {
|
|
|
390 |
all: {},
|
|
|
391 |
add: function (name, callback) {
|
|
|
392 |
var hooks = _.hooks.all;
|
|
|
393 |
hooks[name] = hooks[name] || [];
|
|
|
394 |
hooks[name].push(callback);
|
|
|
395 |
},
|
|
|
396 |
run: function (name, env) {
|
|
|
397 |
var callbacks = _.hooks.all[name];
|
|
|
398 |
if (!callbacks || !callbacks.length) {
|
|
|
399 |
return;
|
|
|
400 |
}
|
|
|
401 |
for (var i = 0, callback; callback = callbacks[i++];) {
|
|
|
402 |
callback(env);
|
|
|
403 |
}
|
|
|
404 |
}
|
|
|
405 |
},
|
|
|
406 |
Token: Token
|
|
|
407 |
};
|
|
|
408 |
_self.Prism = _;
|
|
|
409 |
function Token(type, content, alias, matchedStr) {
|
|
|
410 |
this.type = type;
|
|
|
411 |
this.content = content;
|
|
|
412 |
this.alias = alias;
|
|
|
413 |
this.length = (matchedStr || '').length | 0;
|
|
|
414 |
}
|
|
|
415 |
Token.stringify = function stringify(o, language) {
|
|
|
416 |
if (typeof o == 'string') {
|
|
|
417 |
return o;
|
|
|
418 |
}
|
|
|
419 |
if (Array.isArray(o)) {
|
|
|
420 |
var s = '';
|
|
|
421 |
o.forEach(function (e) {
|
|
|
422 |
s += stringify(e, language);
|
|
|
423 |
});
|
|
|
424 |
return s;
|
|
|
425 |
}
|
|
|
426 |
var env = {
|
|
|
427 |
type: o.type,
|
|
|
428 |
content: stringify(o.content, language),
|
|
|
429 |
tag: 'span',
|
|
|
430 |
classes: [
|
|
|
431 |
'token',
|
|
|
432 |
o.type
|
|
|
433 |
],
|
|
|
434 |
attributes: {},
|
|
|
435 |
language: language
|
|
|
436 |
};
|
|
|
437 |
var aliases = o.alias;
|
|
|
438 |
if (aliases) {
|
|
|
439 |
if (Array.isArray(aliases)) {
|
|
|
440 |
Array.prototype.push.apply(env.classes, aliases);
|
|
|
441 |
} else {
|
|
|
442 |
env.classes.push(aliases);
|
|
|
443 |
}
|
|
|
444 |
}
|
|
|
445 |
_.hooks.run('wrap', env);
|
|
|
446 |
var attributes = '';
|
|
|
447 |
for (var name in env.attributes) {
|
|
|
448 |
attributes += ' ' + name + '="' + (env.attributes[name] || '').replace(/"/g, '"') + '"';
|
|
|
449 |
}
|
|
|
450 |
return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + attributes + '>' + env.content + '</' + env.tag + '>';
|
|
|
451 |
};
|
|
|
452 |
function matchPattern(pattern, pos, text, lookbehind) {
|
|
|
453 |
pattern.lastIndex = pos;
|
|
|
454 |
var match = pattern.exec(text);
|
|
|
455 |
if (match && lookbehind && match[1]) {
|
|
|
456 |
var lookbehindLength = match[1].length;
|
|
|
457 |
match.index += lookbehindLength;
|
|
|
458 |
match[0] = match[0].slice(lookbehindLength);
|
|
|
459 |
}
|
|
|
460 |
return match;
|
|
|
461 |
}
|
|
|
462 |
function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
|
|
|
463 |
for (var token in grammar) {
|
|
|
464 |
if (!grammar.hasOwnProperty(token) || !grammar[token]) {
|
|
|
465 |
continue;
|
|
|
466 |
}
|
|
|
467 |
var patterns = grammar[token];
|
|
|
468 |
patterns = Array.isArray(patterns) ? patterns : [patterns];
|
|
|
469 |
for (var j = 0; j < patterns.length; ++j) {
|
|
|
470 |
if (rematch && rematch.cause == token + ',' + j) {
|
|
|
471 |
return;
|
|
|
472 |
}
|
|
|
473 |
var patternObj = patterns[j];
|
|
|
474 |
var inside = patternObj.inside;
|
|
|
475 |
var lookbehind = !!patternObj.lookbehind;
|
|
|
476 |
var greedy = !!patternObj.greedy;
|
|
|
477 |
var alias = patternObj.alias;
|
|
|
478 |
if (greedy && !patternObj.pattern.global) {
|
|
|
479 |
var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
|
|
|
480 |
patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');
|
|
|
481 |
}
|
|
|
482 |
var pattern = patternObj.pattern || patternObj;
|
|
|
483 |
for (var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
|
|
|
484 |
if (rematch && pos >= rematch.reach) {
|
|
|
485 |
break;
|
|
|
486 |
}
|
|
|
487 |
var str = currentNode.value;
|
|
|
488 |
if (tokenList.length > text.length) {
|
|
|
489 |
return;
|
|
|
490 |
}
|
|
|
491 |
if (str instanceof Token) {
|
|
|
492 |
continue;
|
|
|
493 |
}
|
|
|
494 |
var removeCount = 1;
|
|
|
495 |
var match;
|
|
|
496 |
if (greedy) {
|
|
|
497 |
match = matchPattern(pattern, pos, text, lookbehind);
|
|
|
498 |
if (!match || match.index >= text.length) {
|
|
|
499 |
break;
|
|
|
500 |
}
|
|
|
501 |
var from = match.index;
|
|
|
502 |
var to = match.index + match[0].length;
|
|
|
503 |
var p = pos;
|
|
|
504 |
p += currentNode.value.length;
|
|
|
505 |
while (from >= p) {
|
|
|
506 |
currentNode = currentNode.next;
|
|
|
507 |
p += currentNode.value.length;
|
|
|
508 |
}
|
|
|
509 |
p -= currentNode.value.length;
|
|
|
510 |
pos = p;
|
|
|
511 |
if (currentNode.value instanceof Token) {
|
|
|
512 |
continue;
|
|
|
513 |
}
|
|
|
514 |
for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string'); k = k.next) {
|
|
|
515 |
removeCount++;
|
|
|
516 |
p += k.value.length;
|
|
|
517 |
}
|
|
|
518 |
removeCount--;
|
|
|
519 |
str = text.slice(pos, p);
|
|
|
520 |
match.index -= pos;
|
|
|
521 |
} else {
|
|
|
522 |
match = matchPattern(pattern, 0, str, lookbehind);
|
|
|
523 |
if (!match) {
|
|
|
524 |
continue;
|
|
|
525 |
}
|
|
|
526 |
}
|
|
|
527 |
var from = match.index;
|
|
|
528 |
var matchStr = match[0];
|
|
|
529 |
var before = str.slice(0, from);
|
|
|
530 |
var after = str.slice(from + matchStr.length);
|
|
|
531 |
var reach = pos + str.length;
|
|
|
532 |
if (rematch && reach > rematch.reach) {
|
|
|
533 |
rematch.reach = reach;
|
|
|
534 |
}
|
|
|
535 |
var removeFrom = currentNode.prev;
|
|
|
536 |
if (before) {
|
|
|
537 |
removeFrom = addAfter(tokenList, removeFrom, before);
|
|
|
538 |
pos += before.length;
|
|
|
539 |
}
|
|
|
540 |
removeRange(tokenList, removeFrom, removeCount);
|
|
|
541 |
var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
|
|
|
542 |
currentNode = addAfter(tokenList, removeFrom, wrapped);
|
|
|
543 |
if (after) {
|
|
|
544 |
addAfter(tokenList, currentNode, after);
|
|
|
545 |
}
|
|
|
546 |
if (removeCount > 1) {
|
|
|
547 |
var nestedRematch = {
|
|
|
548 |
cause: token + ',' + j,
|
|
|
549 |
reach: reach
|
|
|
550 |
};
|
|
|
551 |
matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
|
|
|
552 |
if (rematch && nestedRematch.reach > rematch.reach) {
|
|
|
553 |
rematch.reach = nestedRematch.reach;
|
|
|
554 |
}
|
|
|
555 |
}
|
|
|
556 |
}
|
|
|
557 |
}
|
|
|
558 |
}
|
|
|
559 |
}
|
|
|
560 |
function LinkedList() {
|
|
|
561 |
var head = {
|
|
|
562 |
value: null,
|
|
|
563 |
prev: null,
|
|
|
564 |
next: null
|
|
|
565 |
};
|
|
|
566 |
var tail = {
|
|
|
567 |
value: null,
|
|
|
568 |
prev: head,
|
|
|
569 |
next: null
|
|
|
570 |
};
|
|
|
571 |
head.next = tail;
|
|
|
572 |
this.head = head;
|
|
|
573 |
this.tail = tail;
|
|
|
574 |
this.length = 0;
|
|
|
575 |
}
|
|
|
576 |
function addAfter(list, node, value) {
|
|
|
577 |
var next = node.next;
|
|
|
578 |
var newNode = {
|
|
|
579 |
value: value,
|
|
|
580 |
prev: node,
|
|
|
581 |
next: next
|
|
|
582 |
};
|
|
|
583 |
node.next = newNode;
|
|
|
584 |
next.prev = newNode;
|
|
|
585 |
list.length++;
|
|
|
586 |
return newNode;
|
|
|
587 |
}
|
|
|
588 |
function removeRange(list, node, count) {
|
|
|
589 |
var next = node.next;
|
|
|
590 |
for (var i = 0; i < count && next !== list.tail; i++) {
|
|
|
591 |
next = next.next;
|
|
|
592 |
}
|
|
|
593 |
node.next = next;
|
|
|
594 |
next.prev = node;
|
|
|
595 |
list.length -= i;
|
|
|
596 |
}
|
|
|
597 |
function toArray(list) {
|
|
|
598 |
var array = [];
|
|
|
599 |
var node = list.head.next;
|
|
|
600 |
while (node !== list.tail) {
|
|
|
601 |
array.push(node.value);
|
|
|
602 |
node = node.next;
|
|
|
603 |
}
|
|
|
604 |
return array;
|
|
|
605 |
}
|
|
|
606 |
if (!_self.document) {
|
|
|
607 |
if (!_self.addEventListener) {
|
|
|
608 |
return _;
|
|
|
609 |
}
|
|
|
610 |
if (!_.disableWorkerMessageHandler) {
|
|
|
611 |
_self.addEventListener('message', function (evt) {
|
|
|
612 |
var message = JSON.parse(evt.data);
|
|
|
613 |
var lang = message.language;
|
|
|
614 |
var code = message.code;
|
|
|
615 |
var immediateClose = message.immediateClose;
|
|
|
616 |
_self.postMessage(_.highlight(code, _.languages[lang], lang));
|
|
|
617 |
if (immediateClose) {
|
|
|
618 |
_self.close();
|
|
|
619 |
}
|
|
|
620 |
}, false);
|
|
|
621 |
}
|
|
|
622 |
return _;
|
|
|
623 |
}
|
|
|
624 |
var script = _.util.currentScript();
|
|
|
625 |
if (script) {
|
|
|
626 |
_.filename = script.src;
|
|
|
627 |
if (script.hasAttribute('data-manual')) {
|
|
|
628 |
_.manual = true;
|
|
|
629 |
}
|
|
|
630 |
}
|
|
|
631 |
function highlightAutomaticallyCallback() {
|
|
|
632 |
if (!_.manual) {
|
|
|
633 |
_.highlightAll();
|
|
|
634 |
}
|
|
|
635 |
}
|
|
|
636 |
if (!_.manual) {
|
|
|
637 |
var readyState = document.readyState;
|
|
|
638 |
if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
|
|
|
639 |
document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
|
|
|
640 |
} else {
|
|
|
641 |
if (window.requestAnimationFrame) {
|
|
|
642 |
window.requestAnimationFrame(highlightAutomaticallyCallback);
|
|
|
643 |
} else {
|
|
|
644 |
window.setTimeout(highlightAutomaticallyCallback, 16);
|
|
|
645 |
}
|
|
|
646 |
}
|
|
|
647 |
}
|
|
|
648 |
return _;
|
|
|
649 |
}(_self);
|
|
|
650 |
if (typeof module !== 'undefined' && module.exports) {
|
|
|
651 |
module.exports = Prism;
|
|
|
652 |
}
|
|
|
653 |
if (typeof global !== 'undefined') {
|
|
|
654 |
global.Prism = Prism;
|
|
|
655 |
}
|
|
|
656 |
Prism.languages.clike = {
|
|
|
657 |
'comment': [
|
|
|
658 |
{
|
|
|
659 |
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
|
|
|
660 |
lookbehind: true,
|
|
|
661 |
greedy: true
|
|
|
662 |
},
|
|
|
663 |
{
|
|
|
664 |
pattern: /(^|[^\\:])\/\/.*/,
|
|
|
665 |
lookbehind: true,
|
|
|
666 |
greedy: true
|
|
|
667 |
}
|
|
|
668 |
],
|
|
|
669 |
'string': {
|
|
|
670 |
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
|
|
|
671 |
greedy: true
|
|
|
672 |
},
|
|
|
673 |
'class-name': {
|
|
|
674 |
pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
|
|
|
675 |
lookbehind: true,
|
|
|
676 |
inside: { 'punctuation': /[.\\]/ }
|
|
|
677 |
},
|
|
|
678 |
'keyword': /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
|
|
|
679 |
'boolean': /\b(?:false|true)\b/,
|
|
|
680 |
'function': /\b\w+(?=\()/,
|
|
|
681 |
'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
|
|
|
682 |
'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
|
|
|
683 |
'punctuation': /[{}[\];(),.:]/
|
|
|
684 |
};
|
|
|
685 |
(function (Prism) {
|
|
|
686 |
function getPlaceholder(language, index) {
|
|
|
687 |
return '___' + language.toUpperCase() + index + '___';
|
|
|
688 |
}
|
|
|
689 |
Object.defineProperties(Prism.languages['markup-templating'] = {}, {
|
|
|
690 |
buildPlaceholders: {
|
|
|
691 |
value: function (env, language, placeholderPattern, replaceFilter) {
|
|
|
692 |
if (env.language !== language) {
|
|
|
693 |
return;
|
|
|
694 |
}
|
|
|
695 |
var tokenStack = env.tokenStack = [];
|
|
|
696 |
env.code = env.code.replace(placeholderPattern, function (match) {
|
|
|
697 |
if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
|
|
|
698 |
return match;
|
|
|
699 |
}
|
|
|
700 |
var i = tokenStack.length;
|
|
|
701 |
var placeholder;
|
|
|
702 |
while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {
|
|
|
703 |
++i;
|
|
|
704 |
}
|
|
|
705 |
tokenStack[i] = match;
|
|
|
706 |
return placeholder;
|
|
|
707 |
});
|
|
|
708 |
env.grammar = Prism.languages.markup;
|
|
|
709 |
}
|
|
|
710 |
},
|
|
|
711 |
tokenizePlaceholders: {
|
|
|
712 |
value: function (env, language) {
|
|
|
713 |
if (env.language !== language || !env.tokenStack) {
|
|
|
714 |
return;
|
|
|
715 |
}
|
|
|
716 |
env.grammar = Prism.languages[language];
|
|
|
717 |
var j = 0;
|
|
|
718 |
var keys = Object.keys(env.tokenStack);
|
|
|
719 |
function walkTokens(tokens) {
|
|
|
720 |
for (var i = 0; i < tokens.length; i++) {
|
|
|
721 |
if (j >= keys.length) {
|
|
|
722 |
break;
|
|
|
723 |
}
|
|
|
724 |
var token = tokens[i];
|
|
|
725 |
if (typeof token === 'string' || token.content && typeof token.content === 'string') {
|
|
|
726 |
var k = keys[j];
|
|
|
727 |
var t = env.tokenStack[k];
|
|
|
728 |
var s = typeof token === 'string' ? token : token.content;
|
|
|
729 |
var placeholder = getPlaceholder(language, k);
|
|
|
730 |
var index = s.indexOf(placeholder);
|
|
|
731 |
if (index > -1) {
|
|
|
732 |
++j;
|
|
|
733 |
var before = s.substring(0, index);
|
|
|
734 |
var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);
|
|
|
735 |
var after = s.substring(index + placeholder.length);
|
|
|
736 |
var replacement = [];
|
|
|
737 |
if (before) {
|
|
|
738 |
replacement.push.apply(replacement, walkTokens([before]));
|
|
|
739 |
}
|
|
|
740 |
replacement.push(middle);
|
|
|
741 |
if (after) {
|
|
|
742 |
replacement.push.apply(replacement, walkTokens([after]));
|
|
|
743 |
}
|
|
|
744 |
if (typeof token === 'string') {
|
|
|
745 |
tokens.splice.apply(tokens, [
|
|
|
746 |
i,
|
|
|
747 |
1
|
|
|
748 |
].concat(replacement));
|
|
|
749 |
} else {
|
|
|
750 |
token.content = replacement;
|
|
|
751 |
}
|
|
|
752 |
}
|
|
|
753 |
} else if (token.content) {
|
|
|
754 |
walkTokens(token.content);
|
|
|
755 |
}
|
|
|
756 |
}
|
|
|
757 |
return tokens;
|
|
|
758 |
}
|
|
|
759 |
walkTokens(env.tokens);
|
|
|
760 |
}
|
|
|
761 |
}
|
|
|
762 |
});
|
|
|
763 |
}(Prism));
|
|
|
764 |
Prism.languages.c = Prism.languages.extend('clike', {
|
|
|
765 |
'comment': {
|
|
|
766 |
pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
|
|
|
767 |
greedy: true
|
|
|
768 |
},
|
|
|
769 |
'string': {
|
|
|
770 |
pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
|
|
|
771 |
greedy: true
|
|
|
772 |
},
|
|
|
773 |
'class-name': {
|
|
|
774 |
pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
|
|
|
775 |
lookbehind: true
|
|
|
776 |
},
|
|
|
777 |
'keyword': /\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/,
|
|
|
778 |
'function': /\b[a-z_]\w*(?=\s*\()/i,
|
|
|
779 |
'number': /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
|
|
|
780 |
'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
|
|
|
781 |
});
|
|
|
782 |
Prism.languages.insertBefore('c', 'string', {
|
|
|
783 |
'char': {
|
|
|
784 |
pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
|
|
|
785 |
greedy: true
|
|
|
786 |
}
|
|
|
787 |
});
|
|
|
788 |
Prism.languages.insertBefore('c', 'string', {
|
|
|
789 |
'macro': {
|
|
|
790 |
pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
|
|
|
791 |
lookbehind: true,
|
|
|
792 |
greedy: true,
|
|
|
793 |
alias: 'property',
|
|
|
794 |
inside: {
|
|
|
795 |
'string': [
|
|
|
796 |
{
|
|
|
797 |
pattern: /^(#\s*include\s*)<[^>]+>/,
|
|
|
798 |
lookbehind: true
|
|
|
799 |
},
|
|
|
800 |
Prism.languages.c['string']
|
|
|
801 |
],
|
|
|
802 |
'char': Prism.languages.c['char'],
|
|
|
803 |
'comment': Prism.languages.c['comment'],
|
|
|
804 |
'macro-name': [
|
|
|
805 |
{
|
|
|
806 |
pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
|
|
|
807 |
lookbehind: true
|
|
|
808 |
},
|
|
|
809 |
{
|
|
|
810 |
pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
|
|
|
811 |
lookbehind: true,
|
|
|
812 |
alias: 'function'
|
|
|
813 |
}
|
|
|
814 |
],
|
|
|
815 |
'directive': {
|
|
|
816 |
pattern: /^(#\s*)[a-z]+/,
|
|
|
817 |
lookbehind: true,
|
|
|
818 |
alias: 'keyword'
|
|
|
819 |
},
|
|
|
820 |
'directive-hash': /^#/,
|
|
|
821 |
'punctuation': /##|\\(?=[\r\n])/,
|
|
|
822 |
'expression': {
|
|
|
823 |
pattern: /\S[\s\S]*/,
|
|
|
824 |
inside: Prism.languages.c
|
|
|
825 |
}
|
|
|
826 |
}
|
|
|
827 |
}
|
|
|
828 |
});
|
|
|
829 |
Prism.languages.insertBefore('c', 'function', { 'constant': /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ });
|
|
|
830 |
delete Prism.languages.c['boolean'];
|
|
|
831 |
(function (Prism) {
|
|
|
832 |
var keyword = /\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/;
|
|
|
833 |
var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function () {
|
|
|
834 |
return keyword.source;
|
|
|
835 |
});
|
|
|
836 |
Prism.languages.cpp = Prism.languages.extend('c', {
|
|
|
837 |
'class-name': [
|
|
|
838 |
{
|
|
|
839 |
pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g, function () {
|
|
|
840 |
return keyword.source;
|
|
|
841 |
})),
|
|
|
842 |
lookbehind: true
|
|
|
843 |
},
|
|
|
844 |
/\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
|
|
|
845 |
/\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
|
|
|
846 |
/\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
|
|
|
847 |
],
|
|
|
848 |
'keyword': keyword,
|
|
|
849 |
'number': {
|
|
|
850 |
pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
|
|
|
851 |
greedy: true
|
|
|
852 |
},
|
|
|
853 |
'operator': />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
|
|
|
854 |
'boolean': /\b(?:false|true)\b/
|
|
|
855 |
});
|
|
|
856 |
Prism.languages.insertBefore('cpp', 'string', {
|
|
|
857 |
'module': {
|
|
|
858 |
pattern: RegExp(/(\b(?:import|module)\s+)/.source + '(?:' + /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + '|' + /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function () {
|
|
|
859 |
return modName;
|
|
|
860 |
}) + ')'),
|
|
|
861 |
lookbehind: true,
|
|
|
862 |
greedy: true,
|
|
|
863 |
inside: {
|
|
|
864 |
'string': /^[<"][\s\S]+/,
|
|
|
865 |
'operator': /:/,
|
|
|
866 |
'punctuation': /\./
|
|
|
867 |
}
|
|
|
868 |
},
|
|
|
869 |
'raw-string': {
|
|
|
870 |
pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
|
|
|
871 |
alias: 'string',
|
|
|
872 |
greedy: true
|
|
|
873 |
}
|
|
|
874 |
});
|
|
|
875 |
Prism.languages.insertBefore('cpp', 'keyword', {
|
|
|
876 |
'generic-function': {
|
|
|
877 |
pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
|
|
|
878 |
inside: {
|
|
|
879 |
'function': /^\w+/,
|
|
|
880 |
'generic': {
|
|
|
881 |
pattern: /<[\s\S]+/,
|
|
|
882 |
alias: 'class-name',
|
|
|
883 |
inside: Prism.languages.cpp
|
|
|
884 |
}
|
|
|
885 |
}
|
|
|
886 |
}
|
|
|
887 |
});
|
|
|
888 |
Prism.languages.insertBefore('cpp', 'operator', {
|
|
|
889 |
'double-colon': {
|
|
|
890 |
pattern: /::/,
|
|
|
891 |
alias: 'punctuation'
|
|
|
892 |
}
|
|
|
893 |
});
|
|
|
894 |
Prism.languages.insertBefore('cpp', 'class-name', {
|
|
|
895 |
'base-clause': {
|
|
|
896 |
pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
|
|
|
897 |
lookbehind: true,
|
|
|
898 |
greedy: true,
|
|
|
899 |
inside: Prism.languages.extend('cpp', {})
|
|
|
900 |
}
|
|
|
901 |
});
|
|
|
902 |
Prism.languages.insertBefore('inside', 'double-colon', { 'class-name': /\b[a-z_]\w*\b(?!\s*::)/i }, Prism.languages.cpp['base-clause']);
|
|
|
903 |
}(Prism));
|
|
|
904 |
(function (Prism) {
|
|
|
905 |
function replace(pattern, replacements) {
|
|
|
906 |
return pattern.replace(/<<(\d+)>>/g, function (m, index) {
|
|
|
907 |
return '(?:' + replacements[+index] + ')';
|
|
|
908 |
});
|
|
|
909 |
}
|
|
|
910 |
function re(pattern, replacements, flags) {
|
|
|
911 |
return RegExp(replace(pattern, replacements), flags || '');
|
|
|
912 |
}
|
|
|
913 |
function nested(pattern, depthLog2) {
|
|
|
914 |
for (var i = 0; i < depthLog2; i++) {
|
|
|
915 |
pattern = pattern.replace(/<<self>>/g, function () {
|
|
|
916 |
return '(?:' + pattern + ')';
|
|
|
917 |
});
|
|
|
918 |
}
|
|
|
919 |
return pattern.replace(/<<self>>/g, '[^\\s\\S]');
|
|
|
920 |
}
|
|
|
921 |
var keywordKinds = {
|
|
|
922 |
type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',
|
|
|
923 |
typeDeclaration: 'class enum interface record struct',
|
|
|
924 |
contextual: '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*{)',
|
|
|
925 |
other: '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'
|
|
|
926 |
};
|
|
|
927 |
function keywordsToPattern(words) {
|
|
|
928 |
return '\\b(?:' + words.trim().replace(/ /g, '|') + ')\\b';
|
|
|
929 |
}
|
|
|
930 |
var typeDeclarationKeywords = keywordsToPattern(keywordKinds.typeDeclaration);
|
|
|
931 |
var keywords = RegExp(keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other));
|
|
|
932 |
var nonTypeKeywords = keywordsToPattern(keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other);
|
|
|
933 |
var nonContextualKeywords = keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.other);
|
|
|
934 |
var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2);
|
|
|
935 |
var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.source, 2);
|
|
|
936 |
var name = /@?\b[A-Za-z_]\w*\b/.source;
|
|
|
937 |
var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [
|
|
|
938 |
name,
|
|
|
939 |
generic
|
|
|
940 |
]);
|
|
|
941 |
var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [
|
|
|
942 |
nonTypeKeywords,
|
|
|
943 |
genericName
|
|
|
944 |
]);
|
|
|
945 |
var array = /\[\s*(?:,\s*)*\]/.source;
|
|
|
946 |
var typeExpressionWithoutTuple = replace(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [
|
|
|
947 |
identifier,
|
|
|
948 |
array
|
|
|
949 |
]);
|
|
|
950 |
var tupleElement = replace(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [
|
|
|
951 |
generic,
|
|
|
952 |
nestedRound,
|
|
|
953 |
array
|
|
|
954 |
]);
|
|
|
955 |
var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]);
|
|
|
956 |
var typeExpression = replace(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [
|
|
|
957 |
tuple,
|
|
|
958 |
identifier,
|
|
|
959 |
array
|
|
|
960 |
]);
|
|
|
961 |
var typeInside = {
|
|
|
962 |
'keyword': keywords,
|
|
|
963 |
'punctuation': /[<>()?,.:[\]]/
|
|
|
964 |
};
|
|
|
965 |
var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source;
|
|
|
966 |
var regularString = /"(?:\\.|[^\\"\r\n])*"/.source;
|
|
|
967 |
var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source;
|
|
|
968 |
Prism.languages.csharp = Prism.languages.extend('clike', {
|
|
|
969 |
'string': [
|
|
|
970 |
{
|
|
|
971 |
pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]),
|
|
|
972 |
lookbehind: true,
|
|
|
973 |
greedy: true
|
|
|
974 |
},
|
|
|
975 |
{
|
|
|
976 |
pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]),
|
|
|
977 |
lookbehind: true,
|
|
|
978 |
greedy: true
|
|
|
979 |
}
|
|
|
980 |
],
|
|
|
981 |
'class-name': [
|
|
|
982 |
{
|
|
|
983 |
pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [identifier]),
|
|
|
984 |
lookbehind: true,
|
|
|
985 |
inside: typeInside
|
|
|
986 |
},
|
|
|
987 |
{
|
|
|
988 |
pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
|
|
|
989 |
name,
|
|
|
990 |
typeExpression
|
|
|
991 |
]),
|
|
|
992 |
lookbehind: true,
|
|
|
993 |
inside: typeInside
|
|
|
994 |
},
|
|
|
995 |
{
|
|
|
996 |
pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
|
|
|
997 |
lookbehind: true
|
|
|
998 |
},
|
|
|
999 |
{
|
|
|
1000 |
pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
|
|
|
1001 |
typeDeclarationKeywords,
|
|
|
1002 |
genericName
|
|
|
1003 |
]),
|
|
|
1004 |
lookbehind: true,
|
|
|
1005 |
inside: typeInside
|
|
|
1006 |
},
|
|
|
1007 |
{
|
|
|
1008 |
pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
|
|
|
1009 |
lookbehind: true,
|
|
|
1010 |
inside: typeInside
|
|
|
1011 |
},
|
|
|
1012 |
{
|
|
|
1013 |
pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
|
|
|
1014 |
lookbehind: true
|
|
|
1015 |
},
|
|
|
1016 |
{
|
|
|
1017 |
pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [typeExpressionWithoutTuple]),
|
|
|
1018 |
lookbehind: true,
|
|
|
1019 |
inside: typeInside
|
|
|
1020 |
},
|
|
|
1021 |
{
|
|
|
1022 |
pattern: re(/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source, [
|
|
|
1023 |
typeExpression,
|
|
|
1024 |
nonContextualKeywords,
|
|
|
1025 |
name
|
|
|
1026 |
]),
|
|
|
1027 |
inside: typeInside
|
|
|
1028 |
}
|
|
|
1029 |
],
|
|
|
1030 |
'keyword': keywords,
|
|
|
1031 |
'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,
|
|
|
1032 |
'operator': />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/,
|
|
|
1033 |
'punctuation': /\?\.?|::|[{}[\];(),.:]/
|
|
|
1034 |
});
|
|
|
1035 |
Prism.languages.insertBefore('csharp', 'number', {
|
|
|
1036 |
'range': {
|
|
|
1037 |
pattern: /\.\./,
|
|
|
1038 |
alias: 'operator'
|
|
|
1039 |
}
|
|
|
1040 |
});
|
|
|
1041 |
Prism.languages.insertBefore('csharp', 'punctuation', {
|
|
|
1042 |
'named-parameter': {
|
|
|
1043 |
pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]),
|
|
|
1044 |
lookbehind: true,
|
|
|
1045 |
alias: 'punctuation'
|
|
|
1046 |
}
|
|
|
1047 |
});
|
|
|
1048 |
Prism.languages.insertBefore('csharp', 'class-name', {
|
|
|
1049 |
'namespace': {
|
|
|
1050 |
pattern: re(/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source, [name]),
|
|
|
1051 |
lookbehind: true,
|
|
|
1052 |
inside: { 'punctuation': /\./ }
|
|
|
1053 |
},
|
|
|
1054 |
'type-expression': {
|
|
|
1055 |
pattern: re(/(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source, [nestedRound]),
|
|
|
1056 |
lookbehind: true,
|
|
|
1057 |
alias: 'class-name',
|
|
|
1058 |
inside: typeInside
|
|
|
1059 |
},
|
|
|
1060 |
'return-type': {
|
|
|
1061 |
pattern: re(/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source, [
|
|
|
1062 |
typeExpression,
|
|
|
1063 |
identifier
|
|
|
1064 |
]),
|
|
|
1065 |
inside: typeInside,
|
|
|
1066 |
alias: 'class-name'
|
|
|
1067 |
},
|
|
|
1068 |
'constructor-invocation': {
|
|
|
1069 |
pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
|
|
|
1070 |
lookbehind: true,
|
|
|
1071 |
inside: typeInside,
|
|
|
1072 |
alias: 'class-name'
|
|
|
1073 |
},
|
|
|
1074 |
'generic-method': {
|
|
|
1075 |
pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [
|
|
|
1076 |
name,
|
|
|
1077 |
generic
|
|
|
1078 |
]),
|
|
|
1079 |
inside: {
|
|
|
1080 |
'function': re(/^<<0>>/.source, [name]),
|
|
|
1081 |
'generic': {
|
|
|
1082 |
pattern: RegExp(generic),
|
|
|
1083 |
alias: 'class-name',
|
|
|
1084 |
inside: typeInside
|
|
|
1085 |
}
|
|
|
1086 |
}
|
|
|
1087 |
},
|
|
|
1088 |
'type-list': {
|
|
|
1089 |
pattern: re(/\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|[{;]|=>|$))/.source, [
|
|
|
1090 |
typeDeclarationKeywords,
|
|
|
1091 |
genericName,
|
|
|
1092 |
name,
|
|
|
1093 |
typeExpression,
|
|
|
1094 |
keywords.source,
|
|
|
1095 |
nestedRound,
|
|
|
1096 |
/\bnew\s*\(\s*\)/.source
|
|
|
1097 |
]),
|
|
|
1098 |
lookbehind: true,
|
|
|
1099 |
inside: {
|
|
|
1100 |
'record-arguments': {
|
|
|
1101 |
pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [
|
|
|
1102 |
genericName,
|
|
|
1103 |
nestedRound
|
|
|
1104 |
]),
|
|
|
1105 |
lookbehind: true,
|
|
|
1106 |
greedy: true,
|
|
|
1107 |
inside: Prism.languages.csharp
|
|
|
1108 |
},
|
|
|
1109 |
'keyword': keywords,
|
|
|
1110 |
'class-name': {
|
|
|
1111 |
pattern: RegExp(typeExpression),
|
|
|
1112 |
greedy: true,
|
|
|
1113 |
inside: typeInside
|
|
|
1114 |
},
|
|
|
1115 |
'punctuation': /[,()]/
|
|
|
1116 |
}
|
|
|
1117 |
},
|
|
|
1118 |
'preprocessor': {
|
|
|
1119 |
pattern: /(^[\t ]*)#.*/m,
|
|
|
1120 |
lookbehind: true,
|
|
|
1121 |
alias: 'property',
|
|
|
1122 |
inside: {
|
|
|
1123 |
'directive': {
|
|
|
1124 |
pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
|
|
|
1125 |
lookbehind: true,
|
|
|
1126 |
alias: 'keyword'
|
|
|
1127 |
}
|
|
|
1128 |
}
|
|
|
1129 |
}
|
|
|
1130 |
});
|
|
|
1131 |
var regularStringOrCharacter = regularString + '|' + character;
|
|
|
1132 |
var regularStringCharacterOrComment = replace(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source, [regularStringOrCharacter]);
|
|
|
1133 |
var roundExpression = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
|
|
|
1134 |
var attrTarget = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source;
|
|
|
1135 |
var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [
|
|
|
1136 |
identifier,
|
|
|
1137 |
roundExpression
|
|
|
1138 |
]);
|
|
|
1139 |
Prism.languages.insertBefore('csharp', 'class-name', {
|
|
|
1140 |
'attribute': {
|
|
|
1141 |
pattern: re(/((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source, [
|
|
|
1142 |
attrTarget,
|
|
|
1143 |
attr
|
|
|
1144 |
]),
|
|
|
1145 |
lookbehind: true,
|
|
|
1146 |
greedy: true,
|
|
|
1147 |
inside: {
|
|
|
1148 |
'target': {
|
|
|
1149 |
pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]),
|
|
|
1150 |
alias: 'keyword'
|
|
|
1151 |
},
|
|
|
1152 |
'attribute-arguments': {
|
|
|
1153 |
pattern: re(/\(<<0>>*\)/.source, [roundExpression]),
|
|
|
1154 |
inside: Prism.languages.csharp
|
|
|
1155 |
},
|
|
|
1156 |
'class-name': {
|
|
|
1157 |
pattern: RegExp(identifier),
|
|
|
1158 |
inside: { 'punctuation': /\./ }
|
|
|
1159 |
},
|
|
|
1160 |
'punctuation': /[:,]/
|
|
|
1161 |
}
|
|
|
1162 |
}
|
|
|
1163 |
});
|
|
|
1164 |
var formatString = /:[^}\r\n]+/.source;
|
|
|
1165 |
var mInterpolationRound = nested(replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [regularStringCharacterOrComment]), 2);
|
|
|
1166 |
var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
|
|
|
1167 |
mInterpolationRound,
|
|
|
1168 |
formatString
|
|
|
1169 |
]);
|
|
|
1170 |
var sInterpolationRound = nested(replace(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/.source, [regularStringOrCharacter]), 2);
|
|
|
1171 |
var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
|
|
|
1172 |
sInterpolationRound,
|
|
|
1173 |
formatString
|
|
|
1174 |
]);
|
|
|
1175 |
function createInterpolationInside(interpolation, interpolationRound) {
|
|
|
1176 |
return {
|
|
|
1177 |
'interpolation': {
|
|
|
1178 |
pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]),
|
|
|
1179 |
lookbehind: true,
|
|
|
1180 |
inside: {
|
|
|
1181 |
'format-string': {
|
|
|
1182 |
pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [
|
|
|
1183 |
interpolationRound,
|
|
|
1184 |
formatString
|
|
|
1185 |
]),
|
|
|
1186 |
lookbehind: true,
|
|
|
1187 |
inside: { 'punctuation': /^:/ }
|
|
|
1188 |
},
|
|
|
1189 |
'punctuation': /^\{|\}$/,
|
|
|
1190 |
'expression': {
|
|
|
1191 |
pattern: /[\s\S]+/,
|
|
|
1192 |
alias: 'language-csharp',
|
|
|
1193 |
inside: Prism.languages.csharp
|
|
|
1194 |
}
|
|
|
1195 |
}
|
|
|
1196 |
},
|
|
|
1197 |
'string': /[\s\S]+/
|
|
|
1198 |
};
|
|
|
1199 |
}
|
|
|
1200 |
Prism.languages.insertBefore('csharp', 'string', {
|
|
|
1201 |
'interpolation-string': [
|
|
|
1202 |
{
|
|
|
1203 |
pattern: re(/(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source, [mInterpolation]),
|
|
|
1204 |
lookbehind: true,
|
|
|
1205 |
greedy: true,
|
|
|
1206 |
inside: createInterpolationInside(mInterpolation, mInterpolationRound)
|
|
|
1207 |
},
|
|
|
1208 |
{
|
|
|
1209 |
pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [sInterpolation]),
|
|
|
1210 |
lookbehind: true,
|
|
|
1211 |
greedy: true,
|
|
|
1212 |
inside: createInterpolationInside(sInterpolation, sInterpolationRound)
|
|
|
1213 |
}
|
|
|
1214 |
],
|
|
|
1215 |
'char': {
|
|
|
1216 |
pattern: RegExp(character),
|
|
|
1217 |
greedy: true
|
|
|
1218 |
}
|
|
|
1219 |
});
|
|
|
1220 |
Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp;
|
|
|
1221 |
}(Prism));
|
|
|
1222 |
(function (Prism) {
|
|
|
1223 |
var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
|
|
|
1224 |
Prism.languages.css = {
|
|
|
1225 |
'comment': /\/\*[\s\S]*?\*\//,
|
|
|
1226 |
'atrule': {
|
|
|
1227 |
pattern: RegExp('@[\\w-](?:' + /[^;{\s"']|\s+(?!\s)/.source + '|' + string.source + ')*?' + /(?:;|(?=\s*\{))/.source),
|
|
|
1228 |
inside: {
|
|
|
1229 |
'rule': /^@[\w-]+/,
|
|
|
1230 |
'selector-function-argument': {
|
|
|
1231 |
pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
|
|
|
1232 |
lookbehind: true,
|
|
|
1233 |
alias: 'selector'
|
|
|
1234 |
},
|
|
|
1235 |
'keyword': {
|
|
|
1236 |
pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
|
|
|
1237 |
lookbehind: true
|
|
|
1238 |
}
|
|
|
1239 |
}
|
|
|
1240 |
},
|
|
|
1241 |
'url': {
|
|
|
1242 |
pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'),
|
|
|
1243 |
greedy: true,
|
|
|
1244 |
inside: {
|
|
|
1245 |
'function': /^url/i,
|
|
|
1246 |
'punctuation': /^\(|\)$/,
|
|
|
1247 |
'string': {
|
|
|
1248 |
pattern: RegExp('^' + string.source + '$'),
|
|
|
1249 |
alias: 'url'
|
|
|
1250 |
}
|
|
|
1251 |
}
|
|
|
1252 |
},
|
|
|
1253 |
'selector': {
|
|
|
1254 |
pattern: RegExp('(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'),
|
|
|
1255 |
lookbehind: true
|
|
|
1256 |
},
|
|
|
1257 |
'string': {
|
|
|
1258 |
pattern: string,
|
|
|
1259 |
greedy: true
|
|
|
1260 |
},
|
|
|
1261 |
'property': {
|
|
|
1262 |
pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
|
|
|
1263 |
lookbehind: true
|
|
|
1264 |
},
|
|
|
1265 |
'important': /!important\b/i,
|
|
|
1266 |
'function': {
|
|
|
1267 |
pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
|
|
|
1268 |
lookbehind: true
|
|
|
1269 |
},
|
|
|
1270 |
'punctuation': /[(){};:,]/
|
|
|
1271 |
};
|
|
|
1272 |
Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
|
|
|
1273 |
var markup = Prism.languages.markup;
|
|
|
1274 |
if (markup) {
|
|
|
1275 |
markup.tag.addInlined('style', 'css');
|
|
|
1276 |
markup.tag.addAttribute('style', 'css');
|
|
|
1277 |
}
|
|
|
1278 |
}(Prism));
|
|
|
1279 |
(function (Prism) {
|
|
|
1280 |
var keywords = /\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/;
|
|
|
1281 |
var classNamePrefix = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
|
|
|
1282 |
var className = {
|
|
|
1283 |
pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
|
|
|
1284 |
lookbehind: true,
|
|
|
1285 |
inside: {
|
|
|
1286 |
'namespace': {
|
|
|
1287 |
pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
|
|
|
1288 |
inside: { 'punctuation': /\./ }
|
|
|
1289 |
},
|
|
|
1290 |
'punctuation': /\./
|
|
|
1291 |
}
|
|
|
1292 |
};
|
|
|
1293 |
Prism.languages.java = Prism.languages.extend('clike', {
|
|
|
1294 |
'string': {
|
|
|
1295 |
pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
|
|
|
1296 |
lookbehind: true,
|
|
|
1297 |
greedy: true
|
|
|
1298 |
},
|
|
|
1299 |
'class-name': [
|
|
|
1300 |
className,
|
|
|
1301 |
{
|
|
|
1302 |
pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source),
|
|
|
1303 |
lookbehind: true,
|
|
|
1304 |
inside: className.inside
|
|
|
1305 |
},
|
|
|
1306 |
{
|
|
|
1307 |
pattern: RegExp(/(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + classNamePrefix + /[A-Z]\w*\b/.source),
|
|
|
1308 |
lookbehind: true,
|
|
|
1309 |
inside: className.inside
|
|
|
1310 |
}
|
|
|
1311 |
],
|
|
|
1312 |
'keyword': keywords,
|
|
|
1313 |
'function': [
|
|
|
1314 |
Prism.languages.clike.function,
|
|
|
1315 |
{
|
|
|
1316 |
pattern: /(::\s*)[a-z_]\w*/,
|
|
|
1317 |
lookbehind: true
|
|
|
1318 |
}
|
|
|
1319 |
],
|
|
|
1320 |
'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,
|
|
|
1321 |
'operator': {
|
|
|
1322 |
pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
|
|
|
1323 |
lookbehind: true
|
|
|
1324 |
},
|
|
|
1325 |
'constant': /\b[A-Z][A-Z_\d]+\b/
|
|
|
1326 |
});
|
|
|
1327 |
Prism.languages.insertBefore('java', 'string', {
|
|
|
1328 |
'triple-quoted-string': {
|
|
|
1329 |
pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
|
|
|
1330 |
greedy: true,
|
|
|
1331 |
alias: 'string'
|
|
|
1332 |
},
|
|
|
1333 |
'char': {
|
|
|
1334 |
pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
|
|
|
1335 |
greedy: true
|
|
|
1336 |
}
|
|
|
1337 |
});
|
|
|
1338 |
Prism.languages.insertBefore('java', 'class-name', {
|
|
|
1339 |
'annotation': {
|
|
|
1340 |
pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
|
|
|
1341 |
lookbehind: true,
|
|
|
1342 |
alias: 'punctuation'
|
|
|
1343 |
},
|
|
|
1344 |
'generics': {
|
|
|
1345 |
pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
|
|
|
1346 |
inside: {
|
|
|
1347 |
'class-name': className,
|
|
|
1348 |
'keyword': keywords,
|
|
|
1349 |
'punctuation': /[<>(),.:]/,
|
|
|
1350 |
'operator': /[?&|]/
|
|
|
1351 |
}
|
|
|
1352 |
},
|
|
|
1353 |
'import': [
|
|
|
1354 |
{
|
|
|
1355 |
pattern: RegExp(/(\bimport\s+)/.source + classNamePrefix + /(?:[A-Z]\w*|\*)(?=\s*;)/.source),
|
|
|
1356 |
lookbehind: true,
|
|
|
1357 |
inside: {
|
|
|
1358 |
'namespace': className.inside.namespace,
|
|
|
1359 |
'punctuation': /\./,
|
|
|
1360 |
'operator': /\*/,
|
|
|
1361 |
'class-name': /\w+/
|
|
|
1362 |
}
|
|
|
1363 |
},
|
|
|
1364 |
{
|
|
|
1365 |
pattern: RegExp(/(\bimport\s+static\s+)/.source + classNamePrefix + /(?:\w+|\*)(?=\s*;)/.source),
|
|
|
1366 |
lookbehind: true,
|
|
|
1367 |
alias: 'static',
|
|
|
1368 |
inside: {
|
|
|
1369 |
'namespace': className.inside.namespace,
|
|
|
1370 |
'static': /\b\w+$/,
|
|
|
1371 |
'punctuation': /\./,
|
|
|
1372 |
'operator': /\*/,
|
|
|
1373 |
'class-name': /\w+/
|
|
|
1374 |
}
|
|
|
1375 |
}
|
|
|
1376 |
],
|
|
|
1377 |
'namespace': {
|
|
|
1378 |
pattern: RegExp(/(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(/<keyword>/g, function () {
|
|
|
1379 |
return keywords.source;
|
|
|
1380 |
})),
|
|
|
1381 |
lookbehind: true,
|
|
|
1382 |
inside: { 'punctuation': /\./ }
|
|
|
1383 |
}
|
|
|
1384 |
});
|
|
|
1385 |
}(Prism));
|
|
|
1386 |
Prism.languages.javascript = Prism.languages.extend('clike', {
|
|
|
1387 |
'class-name': [
|
|
|
1388 |
Prism.languages.clike['class-name'],
|
|
|
1389 |
{
|
|
|
1390 |
pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
|
|
|
1391 |
lookbehind: true
|
|
|
1392 |
}
|
|
|
1393 |
],
|
|
|
1394 |
'keyword': [
|
|
|
1395 |
{
|
|
|
1396 |
pattern: /((?:^|\})\s*)catch\b/,
|
|
|
1397 |
lookbehind: true
|
|
|
1398 |
},
|
|
|
1399 |
{
|
|
|
1400 |
pattern: /(^|[^.]|\.\.\.\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/,
|
|
|
1401 |
lookbehind: true
|
|
|
1402 |
}
|
|
|
1403 |
],
|
|
|
1404 |
'function': /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
|
|
|
1405 |
'number': {
|
|
|
1406 |
pattern: RegExp(/(^|[^\w$])/.source + '(?:' + (/NaN|Infinity/.source + '|' + /0[bB][01]+(?:_[01]+)*n?/.source + '|' + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + '|' + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + '|' + /\d+(?:_\d+)*n/.source + '|' + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ')' + /(?![\w$])/.source),
|
|
|
1407 |
lookbehind: true
|
|
|
1408 |
},
|
|
|
1409 |
'operator': /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
|
|
|
1410 |
});
|
|
|
1411 |
Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
|
|
|
1412 |
Prism.languages.insertBefore('javascript', 'keyword', {
|
|
|
1413 |
'regex': {
|
|
|
1414 |
pattern: RegExp(/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + /\//.source + '(?:' + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + '|' + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ')' + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source),
|
|
|
1415 |
lookbehind: true,
|
|
|
1416 |
greedy: true,
|
|
|
1417 |
inside: {
|
|
|
1418 |
'regex-source': {
|
|
|
1419 |
pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
|
|
|
1420 |
lookbehind: true,
|
|
|
1421 |
alias: 'language-regex',
|
|
|
1422 |
inside: Prism.languages.regex
|
|
|
1423 |
},
|
|
|
1424 |
'regex-delimiter': /^\/|\/$/,
|
|
|
1425 |
'regex-flags': /^[a-z]+$/
|
|
|
1426 |
}
|
|
|
1427 |
},
|
|
|
1428 |
'function-variable': {
|
|
|
1429 |
pattern: /#?(?!\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*=>))/,
|
|
|
1430 |
alias: 'function'
|
|
|
1431 |
},
|
|
|
1432 |
'parameter': [
|
|
|
1433 |
{
|
|
|
1434 |
pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
|
|
|
1435 |
lookbehind: true,
|
|
|
1436 |
inside: Prism.languages.javascript
|
|
|
1437 |
},
|
|
|
1438 |
{
|
|
|
1439 |
pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
|
|
|
1440 |
lookbehind: true,
|
|
|
1441 |
inside: Prism.languages.javascript
|
|
|
1442 |
},
|
|
|
1443 |
{
|
|
|
1444 |
pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
|
|
|
1445 |
lookbehind: true,
|
|
|
1446 |
inside: Prism.languages.javascript
|
|
|
1447 |
},
|
|
|
1448 |
{
|
|
|
1449 |
pattern: /((?:\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*\{)/,
|
|
|
1450 |
lookbehind: true,
|
|
|
1451 |
inside: Prism.languages.javascript
|
|
|
1452 |
}
|
|
|
1453 |
],
|
|
|
1454 |
'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/
|
|
|
1455 |
});
|
|
|
1456 |
Prism.languages.insertBefore('javascript', 'string', {
|
|
|
1457 |
'hashbang': {
|
|
|
1458 |
pattern: /^#!.*/,
|
|
|
1459 |
greedy: true,
|
|
|
1460 |
alias: 'comment'
|
|
|
1461 |
},
|
|
|
1462 |
'template-string': {
|
|
|
1463 |
pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
|
|
|
1464 |
greedy: true,
|
|
|
1465 |
inside: {
|
|
|
1466 |
'template-punctuation': {
|
|
|
1467 |
pattern: /^`|`$/,
|
|
|
1468 |
alias: 'string'
|
|
|
1469 |
},
|
|
|
1470 |
'interpolation': {
|
|
|
1471 |
pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
|
|
|
1472 |
lookbehind: true,
|
|
|
1473 |
inside: {
|
|
|
1474 |
'interpolation-punctuation': {
|
|
|
1475 |
pattern: /^\$\{|\}$/,
|
|
|
1476 |
alias: 'punctuation'
|
|
|
1477 |
},
|
|
|
1478 |
rest: Prism.languages.javascript
|
|
|
1479 |
}
|
|
|
1480 |
},
|
|
|
1481 |
'string': /[\s\S]+/
|
|
|
1482 |
}
|
|
|
1483 |
},
|
|
|
1484 |
'string-property': {
|
|
|
1485 |
pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
|
|
|
1486 |
lookbehind: true,
|
|
|
1487 |
greedy: true,
|
|
|
1488 |
alias: 'property'
|
|
|
1489 |
}
|
|
|
1490 |
});
|
|
|
1491 |
Prism.languages.insertBefore('javascript', 'operator', {
|
|
|
1492 |
'literal-property': {
|
|
|
1493 |
pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
|
|
|
1494 |
lookbehind: true,
|
|
|
1495 |
alias: 'property'
|
|
|
1496 |
}
|
|
|
1497 |
});
|
|
|
1498 |
if (Prism.languages.markup) {
|
|
|
1499 |
Prism.languages.markup.tag.addInlined('script', 'javascript');
|
|
|
1500 |
Prism.languages.markup.tag.addAttribute(/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)/.source, 'javascript');
|
|
|
1501 |
}
|
|
|
1502 |
Prism.languages.js = Prism.languages.javascript;
|
|
|
1503 |
Prism.languages.markup = {
|
|
|
1504 |
'comment': {
|
|
|
1505 |
pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
|
|
|
1506 |
greedy: true
|
|
|
1507 |
},
|
|
|
1508 |
'prolog': {
|
|
|
1509 |
pattern: /<\?[\s\S]+?\?>/,
|
|
|
1510 |
greedy: true
|
|
|
1511 |
},
|
|
|
1512 |
'doctype': {
|
|
|
1513 |
pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
|
|
|
1514 |
greedy: true,
|
|
|
1515 |
inside: {
|
|
|
1516 |
'internal-subset': {
|
|
|
1517 |
pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
|
|
|
1518 |
lookbehind: true,
|
|
|
1519 |
greedy: true,
|
|
|
1520 |
inside: null
|
|
|
1521 |
},
|
|
|
1522 |
'string': {
|
|
|
1523 |
pattern: /"[^"]*"|'[^']*'/,
|
|
|
1524 |
greedy: true
|
|
|
1525 |
},
|
|
|
1526 |
'punctuation': /^<!|>$|[[\]]/,
|
|
|
1527 |
'doctype-tag': /^DOCTYPE/i,
|
|
|
1528 |
'name': /[^\s<>'"]+/
|
|
|
1529 |
}
|
|
|
1530 |
},
|
|
|
1531 |
'cdata': {
|
|
|
1532 |
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
|
|
1533 |
greedy: true
|
|
|
1534 |
},
|
|
|
1535 |
'tag': {
|
|
|
1536 |
pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
|
|
|
1537 |
greedy: true,
|
|
|
1538 |
inside: {
|
|
|
1539 |
'tag': {
|
|
|
1540 |
pattern: /^<\/?[^\s>\/]+/,
|
|
|
1541 |
inside: {
|
|
|
1542 |
'punctuation': /^<\/?/,
|
|
|
1543 |
'namespace': /^[^\s>\/:]+:/
|
|
|
1544 |
}
|
|
|
1545 |
},
|
|
|
1546 |
'special-attr': [],
|
|
|
1547 |
'attr-value': {
|
|
|
1548 |
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
|
|
|
1549 |
inside: {
|
|
|
1550 |
'punctuation': [
|
|
|
1551 |
{
|
|
|
1552 |
pattern: /^=/,
|
|
|
1553 |
alias: 'attr-equals'
|
|
|
1554 |
},
|
|
|
1555 |
{
|
|
|
1556 |
pattern: /^(\s*)["']|["']$/,
|
|
|
1557 |
lookbehind: true
|
|
|
1558 |
}
|
|
|
1559 |
]
|
|
|
1560 |
}
|
|
|
1561 |
},
|
|
|
1562 |
'punctuation': /\/?>/,
|
|
|
1563 |
'attr-name': {
|
|
|
1564 |
pattern: /[^\s>\/]+/,
|
|
|
1565 |
inside: { 'namespace': /^[^\s>\/:]+:/ }
|
|
|
1566 |
}
|
|
|
1567 |
}
|
|
|
1568 |
},
|
|
|
1569 |
'entity': [
|
|
|
1570 |
{
|
|
|
1571 |
pattern: /&[\da-z]{1,8};/i,
|
|
|
1572 |
alias: 'named-entity'
|
|
|
1573 |
},
|
|
|
1574 |
/&#x?[\da-f]{1,8};/i
|
|
|
1575 |
]
|
|
|
1576 |
};
|
|
|
1577 |
Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity'];
|
|
|
1578 |
Prism.languages.markup['doctype'].inside['internal-subset'].inside = Prism.languages.markup;
|
|
|
1579 |
Prism.hooks.add('wrap', function (env) {
|
|
|
1580 |
if (env.type === 'entity') {
|
|
|
1581 |
env.attributes['title'] = env.content.replace(/&/, '&');
|
|
|
1582 |
}
|
|
|
1583 |
});
|
|
|
1584 |
Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {
|
|
|
1585 |
value: function addInlined(tagName, lang) {
|
|
|
1586 |
var includedCdataInside = {};
|
|
|
1587 |
includedCdataInside['language-' + lang] = {
|
|
|
1588 |
pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
|
|
|
1589 |
lookbehind: true,
|
|
|
1590 |
inside: Prism.languages[lang]
|
|
|
1591 |
};
|
|
|
1592 |
includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
|
|
|
1593 |
var inside = {
|
|
|
1594 |
'included-cdata': {
|
|
|
1595 |
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
|
|
|
1596 |
inside: includedCdataInside
|
|
|
1597 |
}
|
|
|
1598 |
};
|
|
|
1599 |
inside['language-' + lang] = {
|
|
|
1600 |
pattern: /[\s\S]+/,
|
|
|
1601 |
inside: Prism.languages[lang]
|
|
|
1602 |
};
|
|
|
1603 |
var def = {};
|
|
|
1604 |
def[tagName] = {
|
|
|
1605 |
pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () {
|
|
|
1606 |
return tagName;
|
|
|
1607 |
}), 'i'),
|
|
|
1608 |
lookbehind: true,
|
|
|
1609 |
greedy: true,
|
|
|
1610 |
inside: inside
|
|
|
1611 |
};
|
|
|
1612 |
Prism.languages.insertBefore('markup', 'cdata', def);
|
|
|
1613 |
}
|
|
|
1614 |
});
|
|
|
1615 |
Object.defineProperty(Prism.languages.markup.tag, 'addAttribute', {
|
|
|
1616 |
value: function (attrName, lang) {
|
|
|
1617 |
Prism.languages.markup.tag.inside['special-attr'].push({
|
|
|
1618 |
pattern: RegExp(/(^|["'\s])/.source + '(?:' + attrName + ')' + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, 'i'),
|
|
|
1619 |
lookbehind: true,
|
|
|
1620 |
inside: {
|
|
|
1621 |
'attr-name': /^[^\s=]+/,
|
|
|
1622 |
'attr-value': {
|
|
|
1623 |
pattern: /=[\s\S]+/,
|
|
|
1624 |
inside: {
|
|
|
1625 |
'value': {
|
|
|
1626 |
pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
|
|
|
1627 |
lookbehind: true,
|
|
|
1628 |
alias: [
|
|
|
1629 |
lang,
|
|
|
1630 |
'language-' + lang
|
|
|
1631 |
],
|
|
|
1632 |
inside: Prism.languages[lang]
|
|
|
1633 |
},
|
|
|
1634 |
'punctuation': [
|
|
|
1635 |
{
|
|
|
1636 |
pattern: /^=/,
|
|
|
1637 |
alias: 'attr-equals'
|
|
|
1638 |
},
|
|
|
1639 |
/"|'/
|
|
|
1640 |
]
|
|
|
1641 |
}
|
|
|
1642 |
}
|
|
|
1643 |
}
|
|
|
1644 |
});
|
|
|
1645 |
}
|
|
|
1646 |
});
|
|
|
1647 |
Prism.languages.html = Prism.languages.markup;
|
|
|
1648 |
Prism.languages.mathml = Prism.languages.markup;
|
|
|
1649 |
Prism.languages.svg = Prism.languages.markup;
|
|
|
1650 |
Prism.languages.xml = Prism.languages.extend('markup', {});
|
|
|
1651 |
Prism.languages.ssml = Prism.languages.xml;
|
|
|
1652 |
Prism.languages.atom = Prism.languages.xml;
|
|
|
1653 |
Prism.languages.rss = Prism.languages.xml;
|
|
|
1654 |
(function (Prism) {
|
|
|
1655 |
var comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/;
|
|
|
1656 |
var constant = [
|
|
|
1657 |
{
|
|
|
1658 |
pattern: /\b(?:false|true)\b/i,
|
|
|
1659 |
alias: 'boolean'
|
|
|
1660 |
},
|
|
|
1661 |
{
|
|
|
1662 |
pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
|
|
|
1663 |
greedy: true,
|
|
|
1664 |
lookbehind: true
|
|
|
1665 |
},
|
|
|
1666 |
{
|
|
|
1667 |
pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
|
|
|
1668 |
greedy: true,
|
|
|
1669 |
lookbehind: true
|
|
|
1670 |
},
|
|
|
1671 |
/\b(?:null)\b/i,
|
|
|
1672 |
/\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
|
|
|
1673 |
];
|
|
|
1674 |
var number = /\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;
|
|
|
1675 |
var operator = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/;
|
|
|
1676 |
var punctuation = /[{}\[\](),:;]/;
|
|
|
1677 |
Prism.languages.php = {
|
|
|
1678 |
'delimiter': {
|
|
|
1679 |
pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
|
|
|
1680 |
alias: 'important'
|
|
|
1681 |
},
|
|
|
1682 |
'comment': comment,
|
|
|
1683 |
'variable': /\$+(?:\w+\b|(?=\{))/,
|
|
|
1684 |
'package': {
|
|
|
1685 |
pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
|
|
|
1686 |
lookbehind: true,
|
|
|
1687 |
inside: { 'punctuation': /\\/ }
|
|
|
1688 |
},
|
|
|
1689 |
'class-name-definition': {
|
|
|
1690 |
pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
|
|
|
1691 |
lookbehind: true,
|
|
|
1692 |
alias: 'class-name'
|
|
|
1693 |
},
|
|
|
1694 |
'function-definition': {
|
|
|
1695 |
pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
|
|
|
1696 |
lookbehind: true,
|
|
|
1697 |
alias: 'function'
|
|
|
1698 |
},
|
|
|
1699 |
'keyword': [
|
|
|
1700 |
{
|
|
|
1701 |
pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
|
|
|
1702 |
alias: 'type-casting',
|
|
|
1703 |
greedy: true,
|
|
|
1704 |
lookbehind: true
|
|
|
1705 |
},
|
|
|
1706 |
{
|
|
|
1707 |
pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
|
|
|
1708 |
alias: 'type-hint',
|
|
|
1709 |
greedy: true,
|
|
|
1710 |
lookbehind: true
|
|
|
1711 |
},
|
|
|
1712 |
{
|
|
|
1713 |
pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
|
|
|
1714 |
alias: 'return-type',
|
|
|
1715 |
greedy: true,
|
|
|
1716 |
lookbehind: true
|
|
|
1717 |
},
|
|
|
1718 |
{
|
|
|
1719 |
pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
|
|
|
1720 |
alias: 'type-declaration',
|
|
|
1721 |
greedy: true
|
|
|
1722 |
},
|
|
|
1723 |
{
|
|
|
1724 |
pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
|
|
|
1725 |
alias: 'type-declaration',
|
|
|
1726 |
greedy: true,
|
|
|
1727 |
lookbehind: true
|
|
|
1728 |
},
|
|
|
1729 |
{
|
|
|
1730 |
pattern: /\b(?:parent|self|static)(?=\s*::)/i,
|
|
|
1731 |
alias: 'static-context',
|
|
|
1732 |
greedy: true
|
|
|
1733 |
},
|
|
|
1734 |
{
|
|
|
1735 |
pattern: /(\byield\s+)from\b/i,
|
|
|
1736 |
lookbehind: true
|
|
|
1737 |
},
|
|
|
1738 |
/\bclass\b/i,
|
|
|
1739 |
{
|
|
|
1740 |
pattern: /((?:^|[^\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,
|
|
|
1741 |
lookbehind: true
|
|
|
1742 |
}
|
|
|
1743 |
],
|
|
|
1744 |
'argument-name': {
|
|
|
1745 |
pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
|
|
|
1746 |
lookbehind: true
|
|
|
1747 |
},
|
|
|
1748 |
'class-name': [
|
|
|
1749 |
{
|
|
|
1750 |
pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
|
|
|
1751 |
greedy: true,
|
|
|
1752 |
lookbehind: true
|
|
|
1753 |
},
|
|
|
1754 |
{
|
|
|
1755 |
pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
|
|
|
1756 |
greedy: true,
|
|
|
1757 |
lookbehind: true
|
|
|
1758 |
},
|
|
|
1759 |
{
|
|
|
1760 |
pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
|
|
|
1761 |
greedy: true
|
|
|
1762 |
},
|
|
|
1763 |
{
|
|
|
1764 |
pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
|
|
|
1765 |
alias: 'class-name-fully-qualified',
|
|
|
1766 |
greedy: true,
|
|
|
1767 |
lookbehind: true,
|
|
|
1768 |
inside: { 'punctuation': /\\/ }
|
|
|
1769 |
},
|
|
|
1770 |
{
|
|
|
1771 |
pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
|
|
|
1772 |
alias: 'class-name-fully-qualified',
|
|
|
1773 |
greedy: true,
|
|
|
1774 |
inside: { 'punctuation': /\\/ }
|
|
|
1775 |
},
|
|
|
1776 |
{
|
|
|
1777 |
pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
|
|
|
1778 |
alias: 'class-name-fully-qualified',
|
|
|
1779 |
greedy: true,
|
|
|
1780 |
lookbehind: true,
|
|
|
1781 |
inside: { 'punctuation': /\\/ }
|
|
|
1782 |
},
|
|
|
1783 |
{
|
|
|
1784 |
pattern: /\b[a-z_]\w*(?=\s*\$)/i,
|
|
|
1785 |
alias: 'type-declaration',
|
|
|
1786 |
greedy: true
|
|
|
1787 |
},
|
|
|
1788 |
{
|
|
|
1789 |
pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
|
|
|
1790 |
alias: [
|
|
|
1791 |
'class-name-fully-qualified',
|
|
|
1792 |
'type-declaration'
|
|
|
1793 |
],
|
|
|
1794 |
greedy: true,
|
|
|
1795 |
inside: { 'punctuation': /\\/ }
|
|
|
1796 |
},
|
|
|
1797 |
{
|
|
|
1798 |
pattern: /\b[a-z_]\w*(?=\s*::)/i,
|
|
|
1799 |
alias: 'static-context',
|
|
|
1800 |
greedy: true
|
|
|
1801 |
},
|
|
|
1802 |
{
|
|
|
1803 |
pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
|
|
|
1804 |
alias: [
|
|
|
1805 |
'class-name-fully-qualified',
|
|
|
1806 |
'static-context'
|
|
|
1807 |
],
|
|
|
1808 |
greedy: true,
|
|
|
1809 |
inside: { 'punctuation': /\\/ }
|
|
|
1810 |
},
|
|
|
1811 |
{
|
|
|
1812 |
pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
|
|
|
1813 |
alias: 'type-hint',
|
|
|
1814 |
greedy: true,
|
|
|
1815 |
lookbehind: true
|
|
|
1816 |
},
|
|
|
1817 |
{
|
|
|
1818 |
pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
|
|
|
1819 |
alias: [
|
|
|
1820 |
'class-name-fully-qualified',
|
|
|
1821 |
'type-hint'
|
|
|
1822 |
],
|
|
|
1823 |
greedy: true,
|
|
|
1824 |
lookbehind: true,
|
|
|
1825 |
inside: { 'punctuation': /\\/ }
|
|
|
1826 |
},
|
|
|
1827 |
{
|
|
|
1828 |
pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
|
|
|
1829 |
alias: 'return-type',
|
|
|
1830 |
greedy: true,
|
|
|
1831 |
lookbehind: true
|
|
|
1832 |
},
|
|
|
1833 |
{
|
|
|
1834 |
pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
|
|
|
1835 |
alias: [
|
|
|
1836 |
'class-name-fully-qualified',
|
|
|
1837 |
'return-type'
|
|
|
1838 |
],
|
|
|
1839 |
greedy: true,
|
|
|
1840 |
lookbehind: true,
|
|
|
1841 |
inside: { 'punctuation': /\\/ }
|
|
|
1842 |
}
|
|
|
1843 |
],
|
|
|
1844 |
'constant': constant,
|
|
|
1845 |
'function': {
|
|
|
1846 |
pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
|
|
|
1847 |
lookbehind: true,
|
|
|
1848 |
inside: { 'punctuation': /\\/ }
|
|
|
1849 |
},
|
|
|
1850 |
'property': {
|
|
|
1851 |
pattern: /(->\s*)\w+/,
|
|
|
1852 |
lookbehind: true
|
|
|
1853 |
},
|
|
|
1854 |
'number': number,
|
|
|
1855 |
'operator': operator,
|
|
|
1856 |
'punctuation': punctuation
|
|
|
1857 |
};
|
|
|
1858 |
var string_interpolation = {
|
|
|
1859 |
pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
|
|
|
1860 |
lookbehind: true,
|
|
|
1861 |
inside: Prism.languages.php
|
|
|
1862 |
};
|
|
|
1863 |
var string = [
|
|
|
1864 |
{
|
|
|
1865 |
pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
|
|
|
1866 |
alias: 'nowdoc-string',
|
|
|
1867 |
greedy: true,
|
|
|
1868 |
inside: {
|
|
|
1869 |
'delimiter': {
|
|
|
1870 |
pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
|
|
|
1871 |
alias: 'symbol',
|
|
|
1872 |
inside: { 'punctuation': /^<<<'?|[';]$/ }
|
|
|
1873 |
}
|
|
|
1874 |
}
|
|
|
1875 |
},
|
|
|
1876 |
{
|
|
|
1877 |
pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
|
|
|
1878 |
alias: 'heredoc-string',
|
|
|
1879 |
greedy: true,
|
|
|
1880 |
inside: {
|
|
|
1881 |
'delimiter': {
|
|
|
1882 |
pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
|
|
|
1883 |
alias: 'symbol',
|
|
|
1884 |
inside: { 'punctuation': /^<<<"?|[";]$/ }
|
|
|
1885 |
},
|
|
|
1886 |
'interpolation': string_interpolation
|
|
|
1887 |
}
|
|
|
1888 |
},
|
|
|
1889 |
{
|
|
|
1890 |
pattern: /`(?:\\[\s\S]|[^\\`])*`/,
|
|
|
1891 |
alias: 'backtick-quoted-string',
|
|
|
1892 |
greedy: true
|
|
|
1893 |
},
|
|
|
1894 |
{
|
|
|
1895 |
pattern: /'(?:\\[\s\S]|[^\\'])*'/,
|
|
|
1896 |
alias: 'single-quoted-string',
|
|
|
1897 |
greedy: true
|
|
|
1898 |
},
|
|
|
1899 |
{
|
|
|
1900 |
pattern: /"(?:\\[\s\S]|[^\\"])*"/,
|
|
|
1901 |
alias: 'double-quoted-string',
|
|
|
1902 |
greedy: true,
|
|
|
1903 |
inside: { 'interpolation': string_interpolation }
|
|
|
1904 |
}
|
|
|
1905 |
];
|
|
|
1906 |
Prism.languages.insertBefore('php', 'variable', {
|
|
|
1907 |
'string': string,
|
|
|
1908 |
'attribute': {
|
|
|
1909 |
pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
|
|
|
1910 |
greedy: true,
|
|
|
1911 |
inside: {
|
|
|
1912 |
'attribute-content': {
|
|
|
1913 |
pattern: /^(#\[)[\s\S]+(?=\]$)/,
|
|
|
1914 |
lookbehind: true,
|
|
|
1915 |
inside: {
|
|
|
1916 |
'comment': comment,
|
|
|
1917 |
'string': string,
|
|
|
1918 |
'attribute-class-name': [
|
|
|
1919 |
{
|
|
|
1920 |
pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
|
|
|
1921 |
alias: 'class-name',
|
|
|
1922 |
greedy: true,
|
|
|
1923 |
lookbehind: true
|
|
|
1924 |
},
|
|
|
1925 |
{
|
|
|
1926 |
pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
|
|
|
1927 |
alias: [
|
|
|
1928 |
'class-name',
|
|
|
1929 |
'class-name-fully-qualified'
|
|
|
1930 |
],
|
|
|
1931 |
greedy: true,
|
|
|
1932 |
lookbehind: true,
|
|
|
1933 |
inside: { 'punctuation': /\\/ }
|
|
|
1934 |
}
|
|
|
1935 |
],
|
|
|
1936 |
'constant': constant,
|
|
|
1937 |
'number': number,
|
|
|
1938 |
'operator': operator,
|
|
|
1939 |
'punctuation': punctuation
|
|
|
1940 |
}
|
|
|
1941 |
},
|
|
|
1942 |
'delimiter': {
|
|
|
1943 |
pattern: /^#\[|\]$/,
|
|
|
1944 |
alias: 'punctuation'
|
|
|
1945 |
}
|
|
|
1946 |
}
|
|
|
1947 |
}
|
|
|
1948 |
});
|
|
|
1949 |
Prism.hooks.add('before-tokenize', function (env) {
|
|
|
1950 |
if (!/<\?/.test(env.code)) {
|
|
|
1951 |
return;
|
|
|
1952 |
}
|
|
|
1953 |
var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
|
|
|
1954 |
Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern);
|
|
|
1955 |
});
|
|
|
1956 |
Prism.hooks.add('after-tokenize', function (env) {
|
|
|
1957 |
Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php');
|
|
|
1958 |
});
|
|
|
1959 |
}(Prism));
|
|
|
1960 |
Prism.languages.python = {
|
|
|
1961 |
'comment': {
|
|
|
1962 |
pattern: /(^|[^\\])#.*/,
|
|
|
1963 |
lookbehind: true,
|
|
|
1964 |
greedy: true
|
|
|
1965 |
},
|
|
|
1966 |
'string-interpolation': {
|
|
|
1967 |
pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
|
|
|
1968 |
greedy: true,
|
|
|
1969 |
inside: {
|
|
|
1970 |
'interpolation': {
|
|
|
1971 |
pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
|
|
|
1972 |
lookbehind: true,
|
|
|
1973 |
inside: {
|
|
|
1974 |
'format-spec': {
|
|
|
1975 |
pattern: /(:)[^:(){}]+(?=\}$)/,
|
|
|
1976 |
lookbehind: true
|
|
|
1977 |
},
|
|
|
1978 |
'conversion-option': {
|
|
|
1979 |
pattern: //,
|
|
|
1980 |
alias: 'punctuation'
|
|
|
1981 |
},
|
|
|
1982 |
rest: null
|
|
|
1983 |
}
|
|
|
1984 |
},
|
|
|
1985 |
'string': /[\s\S]+/
|
|
|
1986 |
}
|
|
|
1987 |
},
|
|
|
1988 |
'triple-quoted-string': {
|
|
|
1989 |
pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
|
|
|
1990 |
greedy: true,
|
|
|
1991 |
alias: 'string'
|
|
|
1992 |
},
|
|
|
1993 |
'string': {
|
|
|
1994 |
pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
|
|
|
1995 |
greedy: true
|
|
|
1996 |
},
|
|
|
1997 |
'function': {
|
|
|
1998 |
pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
|
|
|
1999 |
lookbehind: true
|
|
|
2000 |
},
|
|
|
2001 |
'class-name': {
|
|
|
2002 |
pattern: /(\bclass\s+)\w+/i,
|
|
|
2003 |
lookbehind: true
|
|
|
2004 |
},
|
|
|
2005 |
'decorator': {
|
|
|
2006 |
pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
|
|
|
2007 |
lookbehind: true,
|
|
|
2008 |
alias: [
|
|
|
2009 |
'annotation',
|
|
|
2010 |
'punctuation'
|
|
|
2011 |
],
|
|
|
2012 |
inside: { 'punctuation': /\./ }
|
|
|
2013 |
},
|
|
|
2014 |
'keyword': /\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/,
|
|
|
2015 |
'builtin': /\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/,
|
|
|
2016 |
'boolean': /\b(?:False|None|True)\b/,
|
|
|
2017 |
'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,
|
|
|
2018 |
'operator': /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
|
|
|
2019 |
'punctuation': /[{}[\];(),.:]/
|
|
|
2020 |
};
|
|
|
2021 |
Prism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python;
|
|
|
2022 |
Prism.languages.py = Prism.languages.python;
|
|
|
2023 |
(function (Prism) {
|
|
|
2024 |
Prism.languages.ruby = Prism.languages.extend('clike', {
|
|
|
2025 |
'comment': {
|
|
|
2026 |
pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
|
|
|
2027 |
greedy: true
|
|
|
2028 |
},
|
|
|
2029 |
'class-name': {
|
|
|
2030 |
pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
|
|
|
2031 |
lookbehind: true,
|
|
|
2032 |
inside: { 'punctuation': /[.\\]/ }
|
|
|
2033 |
},
|
|
|
2034 |
'keyword': /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
|
|
|
2035 |
'operator': /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
|
|
|
2036 |
'punctuation': /[(){}[\].,;]/
|
|
|
2037 |
});
|
|
|
2038 |
Prism.languages.insertBefore('ruby', 'operator', {
|
|
|
2039 |
'double-colon': {
|
|
|
2040 |
pattern: /::/,
|
|
|
2041 |
alias: 'punctuation'
|
|
|
2042 |
}
|
|
|
2043 |
});
|
|
|
2044 |
var interpolation = {
|
|
|
2045 |
pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
|
|
|
2046 |
lookbehind: true,
|
|
|
2047 |
inside: {
|
|
|
2048 |
'content': {
|
|
|
2049 |
pattern: /^(#\{)[\s\S]+(?=\}$)/,
|
|
|
2050 |
lookbehind: true,
|
|
|
2051 |
inside: Prism.languages.ruby
|
|
|
2052 |
},
|
|
|
2053 |
'delimiter': {
|
|
|
2054 |
pattern: /^#\{|\}$/,
|
|
|
2055 |
alias: 'punctuation'
|
|
|
2056 |
}
|
|
|
2057 |
}
|
|
|
2058 |
};
|
|
|
2059 |
delete Prism.languages.ruby.function;
|
|
|
2060 |
var percentExpression = '(?:' + [
|
|
|
2061 |
/([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
|
|
|
2062 |
/\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
|
|
|
2063 |
/\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
|
|
|
2064 |
/\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
|
|
|
2065 |
/<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
|
|
|
2066 |
].join('|') + ')';
|
|
|
2067 |
var symbolName = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
|
|
|
2068 |
Prism.languages.insertBefore('ruby', 'keyword', {
|
|
|
2069 |
'regex-literal': [
|
|
|
2070 |
{
|
|
|
2071 |
pattern: RegExp(/%r/.source + percentExpression + /[egimnosux]{0,6}/.source),
|
|
|
2072 |
greedy: true,
|
|
|
2073 |
inside: {
|
|
|
2074 |
'interpolation': interpolation,
|
|
|
2075 |
'regex': /[\s\S]+/
|
|
|
2076 |
}
|
|
|
2077 |
},
|
|
|
2078 |
{
|
|
|
2079 |
pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
|
|
|
2080 |
lookbehind: true,
|
|
|
2081 |
greedy: true,
|
|
|
2082 |
inside: {
|
|
|
2083 |
'interpolation': interpolation,
|
|
|
2084 |
'regex': /[\s\S]+/
|
|
|
2085 |
}
|
|
|
2086 |
}
|
|
|
2087 |
],
|
|
|
2088 |
'variable': /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
|
|
|
2089 |
'symbol': [
|
|
|
2090 |
{
|
|
|
2091 |
pattern: RegExp(/(^|[^:]):/.source + symbolName),
|
|
|
2092 |
lookbehind: true,
|
|
|
2093 |
greedy: true
|
|
|
2094 |
},
|
|
|
2095 |
{
|
|
|
2096 |
pattern: RegExp(/([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source),
|
|
|
2097 |
lookbehind: true,
|
|
|
2098 |
greedy: true
|
|
|
2099 |
}
|
|
|
2100 |
],
|
|
|
2101 |
'method-definition': {
|
|
|
2102 |
pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
|
|
|
2103 |
lookbehind: true,
|
|
|
2104 |
inside: {
|
|
|
2105 |
'function': /\b\w+$/,
|
|
|
2106 |
'keyword': /^self\b/,
|
|
|
2107 |
'class-name': /^\w+/,
|
|
|
2108 |
'punctuation': /\./
|
|
|
2109 |
}
|
|
|
2110 |
}
|
|
|
2111 |
});
|
|
|
2112 |
Prism.languages.insertBefore('ruby', 'string', {
|
|
|
2113 |
'string-literal': [
|
|
|
2114 |
{
|
|
|
2115 |
pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
|
|
|
2116 |
greedy: true,
|
|
|
2117 |
inside: {
|
|
|
2118 |
'interpolation': interpolation,
|
|
|
2119 |
'string': /[\s\S]+/
|
|
|
2120 |
}
|
|
|
2121 |
},
|
|
|
2122 |
{
|
|
|
2123 |
pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
|
|
|
2124 |
greedy: true,
|
|
|
2125 |
inside: {
|
|
|
2126 |
'interpolation': interpolation,
|
|
|
2127 |
'string': /[\s\S]+/
|
|
|
2128 |
}
|
|
|
2129 |
},
|
|
|
2130 |
{
|
|
|
2131 |
pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
|
|
|
2132 |
alias: 'heredoc-string',
|
|
|
2133 |
greedy: true,
|
|
|
2134 |
inside: {
|
|
|
2135 |
'delimiter': {
|
|
|
2136 |
pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
|
|
|
2137 |
inside: {
|
|
|
2138 |
'symbol': /\b\w+/,
|
|
|
2139 |
'punctuation': /^<<[-~]?/
|
|
|
2140 |
}
|
|
|
2141 |
},
|
|
|
2142 |
'interpolation': interpolation,
|
|
|
2143 |
'string': /[\s\S]+/
|
|
|
2144 |
}
|
|
|
2145 |
},
|
|
|
2146 |
{
|
|
|
2147 |
pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
|
|
|
2148 |
alias: 'heredoc-string',
|
|
|
2149 |
greedy: true,
|
|
|
2150 |
inside: {
|
|
|
2151 |
'delimiter': {
|
|
|
2152 |
pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
|
|
|
2153 |
inside: {
|
|
|
2154 |
'symbol': /\b\w+/,
|
|
|
2155 |
'punctuation': /^<<[-~]?'|'$/
|
|
|
2156 |
}
|
|
|
2157 |
},
|
|
|
2158 |
'string': /[\s\S]+/
|
|
|
2159 |
}
|
|
|
2160 |
}
|
|
|
2161 |
],
|
|
|
2162 |
'command-literal': [
|
|
|
2163 |
{
|
|
|
2164 |
pattern: RegExp(/%x/.source + percentExpression),
|
|
|
2165 |
greedy: true,
|
|
|
2166 |
inside: {
|
|
|
2167 |
'interpolation': interpolation,
|
|
|
2168 |
'command': {
|
|
|
2169 |
pattern: /[\s\S]+/,
|
|
|
2170 |
alias: 'string'
|
|
|
2171 |
}
|
|
|
2172 |
}
|
|
|
2173 |
},
|
|
|
2174 |
{
|
|
|
2175 |
pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
|
|
|
2176 |
greedy: true,
|
|
|
2177 |
inside: {
|
|
|
2178 |
'interpolation': interpolation,
|
|
|
2179 |
'command': {
|
|
|
2180 |
pattern: /[\s\S]+/,
|
|
|
2181 |
alias: 'string'
|
|
|
2182 |
}
|
|
|
2183 |
}
|
|
|
2184 |
}
|
|
|
2185 |
]
|
|
|
2186 |
});
|
|
|
2187 |
delete Prism.languages.ruby.string;
|
|
|
2188 |
Prism.languages.insertBefore('ruby', 'number', {
|
|
|
2189 |
'builtin': /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
|
|
|
2190 |
'constant': /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
|
|
|
2191 |
});
|
|
|
2192 |
Prism.languages.rb = Prism.languages.ruby;
|
|
|
2193 |
}(Prism));
|
|
|
2194 |
window.Prism = oldprism;
|
|
|
2195 |
return Prism;
|
|
|
2196 |
}(undefined, undefined);
|
|
|
2197 |
|
|
|
2198 |
const option = name => editor => editor.options.get(name);
|
|
|
2199 |
const register$2 = editor => {
|
|
|
2200 |
const registerOption = editor.options.register;
|
|
|
2201 |
registerOption('codesample_languages', { processor: 'object[]' });
|
|
|
2202 |
registerOption('codesample_global_prismjs', {
|
|
|
2203 |
processor: 'boolean',
|
|
|
2204 |
default: false
|
|
|
2205 |
});
|
|
|
2206 |
};
|
|
|
2207 |
const getLanguages$1 = option('codesample_languages');
|
|
|
2208 |
const useGlobalPrismJS = option('codesample_global_prismjs');
|
|
|
2209 |
|
|
|
2210 |
const get = editor => Global.Prism && useGlobalPrismJS(editor) ? Global.Prism : prismjs;
|
|
|
2211 |
|
|
|
2212 |
const isCodeSample = elm => {
|
|
|
2213 |
return isNonNullable(elm) && elm.nodeName === 'PRE' && elm.className.indexOf('language-') !== -1;
|
|
|
2214 |
};
|
|
|
2215 |
|
|
|
2216 |
const getSelectedCodeSample = editor => {
|
|
|
2217 |
const node = editor.selection ? editor.selection.getNode() : null;
|
|
|
2218 |
return isCodeSample(node) ? Optional.some(node) : Optional.none();
|
|
|
2219 |
};
|
|
|
2220 |
const insertCodeSample = (editor, language, code) => {
|
|
|
2221 |
const dom = editor.dom;
|
|
|
2222 |
editor.undoManager.transact(() => {
|
|
|
2223 |
const node = getSelectedCodeSample(editor);
|
|
|
2224 |
code = global$1.DOM.encode(code);
|
|
|
2225 |
return node.fold(() => {
|
|
|
2226 |
editor.insertContent('<pre id="__new" class="language-' + language + '">' + code + '</pre>');
|
|
|
2227 |
const newPre = dom.select('#__new')[0];
|
|
|
2228 |
dom.setAttrib(newPre, 'id', null);
|
|
|
2229 |
editor.selection.select(newPre);
|
|
|
2230 |
}, n => {
|
|
|
2231 |
dom.setAttrib(n, 'class', 'language-' + language);
|
|
|
2232 |
n.innerHTML = code;
|
|
|
2233 |
get(editor).highlightElement(n);
|
|
|
2234 |
editor.selection.select(n);
|
|
|
2235 |
});
|
|
|
2236 |
});
|
|
|
2237 |
};
|
|
|
2238 |
const getCurrentCode = editor => {
|
|
|
2239 |
const node = getSelectedCodeSample(editor);
|
|
|
2240 |
return node.bind(n => Optional.from(n.textContent)).getOr('');
|
|
|
2241 |
};
|
|
|
2242 |
|
|
|
2243 |
const getLanguages = editor => {
|
|
|
2244 |
const defaultLanguages = [
|
|
|
2245 |
{
|
|
|
2246 |
text: 'HTML/XML',
|
|
|
2247 |
value: 'markup'
|
|
|
2248 |
},
|
|
|
2249 |
{
|
|
|
2250 |
text: 'JavaScript',
|
|
|
2251 |
value: 'javascript'
|
|
|
2252 |
},
|
|
|
2253 |
{
|
|
|
2254 |
text: 'CSS',
|
|
|
2255 |
value: 'css'
|
|
|
2256 |
},
|
|
|
2257 |
{
|
|
|
2258 |
text: 'PHP',
|
|
|
2259 |
value: 'php'
|
|
|
2260 |
},
|
|
|
2261 |
{
|
|
|
2262 |
text: 'Ruby',
|
|
|
2263 |
value: 'ruby'
|
|
|
2264 |
},
|
|
|
2265 |
{
|
|
|
2266 |
text: 'Python',
|
|
|
2267 |
value: 'python'
|
|
|
2268 |
},
|
|
|
2269 |
{
|
|
|
2270 |
text: 'Java',
|
|
|
2271 |
value: 'java'
|
|
|
2272 |
},
|
|
|
2273 |
{
|
|
|
2274 |
text: 'C',
|
|
|
2275 |
value: 'c'
|
|
|
2276 |
},
|
|
|
2277 |
{
|
|
|
2278 |
text: 'C#',
|
|
|
2279 |
value: 'csharp'
|
|
|
2280 |
},
|
|
|
2281 |
{
|
|
|
2282 |
text: 'C++',
|
|
|
2283 |
value: 'cpp'
|
|
|
2284 |
}
|
|
|
2285 |
];
|
|
|
2286 |
const customLanguages = getLanguages$1(editor);
|
|
|
2287 |
return customLanguages ? customLanguages : defaultLanguages;
|
|
|
2288 |
};
|
|
|
2289 |
const getCurrentLanguage = (editor, fallback) => {
|
|
|
2290 |
const node = getSelectedCodeSample(editor);
|
|
|
2291 |
return node.fold(() => fallback, n => {
|
|
|
2292 |
const matches = n.className.match(/language-(\w+)/);
|
|
|
2293 |
return matches ? matches[1] : fallback;
|
|
|
2294 |
});
|
|
|
2295 |
};
|
|
|
2296 |
|
|
|
2297 |
const open = editor => {
|
|
|
2298 |
const languages = getLanguages(editor);
|
|
|
2299 |
const defaultLanguage = head(languages).fold(constant(''), l => l.value);
|
|
|
2300 |
const currentLanguage = getCurrentLanguage(editor, defaultLanguage);
|
|
|
2301 |
const currentCode = getCurrentCode(editor);
|
|
|
2302 |
editor.windowManager.open({
|
|
|
2303 |
title: 'Insert/Edit Code Sample',
|
|
|
2304 |
size: 'large',
|
|
|
2305 |
body: {
|
|
|
2306 |
type: 'panel',
|
|
|
2307 |
items: [
|
|
|
2308 |
{
|
|
|
2309 |
type: 'listbox',
|
|
|
2310 |
name: 'language',
|
|
|
2311 |
label: 'Language',
|
|
|
2312 |
items: languages
|
|
|
2313 |
},
|
|
|
2314 |
{
|
|
|
2315 |
type: 'textarea',
|
|
|
2316 |
name: 'code',
|
|
|
2317 |
label: 'Code view'
|
|
|
2318 |
}
|
|
|
2319 |
]
|
|
|
2320 |
},
|
|
|
2321 |
buttons: [
|
|
|
2322 |
{
|
|
|
2323 |
type: 'cancel',
|
|
|
2324 |
name: 'cancel',
|
|
|
2325 |
text: 'Cancel'
|
|
|
2326 |
},
|
|
|
2327 |
{
|
|
|
2328 |
type: 'submit',
|
|
|
2329 |
name: 'save',
|
|
|
2330 |
text: 'Save',
|
|
|
2331 |
primary: true
|
|
|
2332 |
}
|
|
|
2333 |
],
|
|
|
2334 |
initialData: {
|
|
|
2335 |
language: currentLanguage,
|
|
|
2336 |
code: currentCode
|
|
|
2337 |
},
|
|
|
2338 |
onSubmit: api => {
|
|
|
2339 |
const data = api.getData();
|
|
|
2340 |
insertCodeSample(editor, data.language, data.code);
|
|
|
2341 |
api.close();
|
|
|
2342 |
}
|
|
|
2343 |
});
|
|
|
2344 |
};
|
|
|
2345 |
|
|
|
2346 |
const register$1 = editor => {
|
|
|
2347 |
editor.addCommand('codesample', () => {
|
|
|
2348 |
const node = editor.selection.getNode();
|
|
|
2349 |
if (editor.selection.isCollapsed() || isCodeSample(node)) {
|
|
|
2350 |
open(editor);
|
|
|
2351 |
} else {
|
|
|
2352 |
editor.formatter.toggle('code');
|
|
|
2353 |
}
|
|
|
2354 |
});
|
|
|
2355 |
};
|
|
|
2356 |
|
|
|
2357 |
const blank = r => s => s.replace(r, '');
|
|
|
2358 |
const trim = blank(/^\s+|\s+$/g);
|
|
|
2359 |
|
|
|
2360 |
var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
|
|
|
2361 |
|
|
|
2362 |
const setup = editor => {
|
|
|
2363 |
editor.on('PreProcess', e => {
|
|
|
2364 |
const dom = editor.dom;
|
|
|
2365 |
const pres = dom.select('pre[contenteditable=false]', e.node);
|
|
|
2366 |
global.each(global.grep(pres, isCodeSample), elm => {
|
|
|
2367 |
const code = elm.textContent;
|
|
|
2368 |
dom.setAttrib(elm, 'class', trim(dom.getAttrib(elm, 'class')));
|
|
|
2369 |
dom.setAttrib(elm, 'contentEditable', null);
|
|
|
2370 |
dom.setAttrib(elm, 'data-mce-highlighted', null);
|
|
|
2371 |
let child;
|
|
|
2372 |
while (child = elm.firstChild) {
|
|
|
2373 |
elm.removeChild(child);
|
|
|
2374 |
}
|
|
|
2375 |
const codeElm = dom.add(elm, 'code');
|
|
|
2376 |
codeElm.textContent = code;
|
|
|
2377 |
});
|
|
|
2378 |
});
|
|
|
2379 |
editor.on('SetContent', () => {
|
|
|
2380 |
const dom = editor.dom;
|
|
|
2381 |
const unprocessedCodeSamples = global.grep(dom.select('pre'), elm => {
|
|
|
2382 |
return isCodeSample(elm) && dom.getAttrib(elm, 'data-mce-highlighted') !== 'true';
|
|
|
2383 |
});
|
|
|
2384 |
if (unprocessedCodeSamples.length) {
|
|
|
2385 |
editor.undoManager.transact(() => {
|
|
|
2386 |
global.each(unprocessedCodeSamples, elm => {
|
|
|
2387 |
var _a;
|
|
|
2388 |
global.each(dom.select('br', elm), elm => {
|
|
|
2389 |
dom.replace(editor.getDoc().createTextNode('\n'), elm);
|
|
|
2390 |
});
|
|
|
2391 |
elm.innerHTML = dom.encode((_a = elm.textContent) !== null && _a !== void 0 ? _a : '');
|
|
|
2392 |
get(editor).highlightElement(elm);
|
|
|
2393 |
dom.setAttrib(elm, 'data-mce-highlighted', true);
|
|
|
2394 |
elm.className = trim(elm.className);
|
|
|
2395 |
});
|
|
|
2396 |
});
|
|
|
2397 |
}
|
|
|
2398 |
});
|
|
|
2399 |
editor.on('PreInit', () => {
|
|
|
2400 |
editor.parser.addNodeFilter('pre', nodes => {
|
|
|
2401 |
var _a;
|
|
|
2402 |
for (let i = 0, l = nodes.length; i < l; i++) {
|
|
|
2403 |
const node = nodes[i];
|
|
|
2404 |
const isCodeSample = ((_a = node.attr('class')) !== null && _a !== void 0 ? _a : '').indexOf('language-') !== -1;
|
|
|
2405 |
if (isCodeSample) {
|
|
|
2406 |
node.attr('contenteditable', 'false');
|
|
|
2407 |
node.attr('data-mce-highlighted', 'false');
|
|
|
2408 |
}
|
|
|
2409 |
}
|
|
|
2410 |
});
|
|
|
2411 |
});
|
|
|
2412 |
};
|
|
|
2413 |
|
|
|
2414 |
const onSetupEditable = (editor, onChanged = noop) => api => {
|
|
|
2415 |
const nodeChanged = () => {
|
|
|
2416 |
api.setEnabled(editor.selection.isEditable());
|
|
|
2417 |
onChanged(api);
|
|
|
2418 |
};
|
|
|
2419 |
editor.on('NodeChange', nodeChanged);
|
|
|
2420 |
nodeChanged();
|
|
|
2421 |
return () => {
|
|
|
2422 |
editor.off('NodeChange', nodeChanged);
|
|
|
2423 |
};
|
|
|
2424 |
};
|
|
|
2425 |
const isCodeSampleSelection = editor => {
|
|
|
2426 |
const node = editor.selection.getStart();
|
|
|
2427 |
return editor.dom.is(node, 'pre[class*="language-"]');
|
|
|
2428 |
};
|
|
|
2429 |
const register = editor => {
|
|
|
2430 |
const onAction = () => editor.execCommand('codesample');
|
|
|
2431 |
editor.ui.registry.addToggleButton('codesample', {
|
|
|
2432 |
icon: 'code-sample',
|
|
|
2433 |
tooltip: 'Insert/edit code sample',
|
|
|
2434 |
onAction,
|
|
|
2435 |
onSetup: onSetupEditable(editor, api => {
|
|
|
2436 |
api.setActive(isCodeSampleSelection(editor));
|
|
|
2437 |
})
|
|
|
2438 |
});
|
|
|
2439 |
editor.ui.registry.addMenuItem('codesample', {
|
|
|
2440 |
text: 'Code sample...',
|
|
|
2441 |
icon: 'code-sample',
|
|
|
2442 |
onAction,
|
|
|
2443 |
onSetup: onSetupEditable(editor)
|
|
|
2444 |
});
|
|
|
2445 |
};
|
|
|
2446 |
|
|
|
2447 |
var Plugin = () => {
|
|
|
2448 |
global$2.add('codesample', editor => {
|
|
|
2449 |
register$2(editor);
|
|
|
2450 |
setup(editor);
|
|
|
2451 |
register(editor);
|
|
|
2452 |
register$1(editor);
|
|
|
2453 |
editor.on('dblclick', ev => {
|
|
|
2454 |
if (isCodeSample(ev.target)) {
|
|
|
2455 |
open(editor);
|
|
|
2456 |
}
|
|
|
2457 |
});
|
|
|
2458 |
});
|
|
|
2459 |
};
|
|
|
2460 |
|
|
|
2461 |
Plugin();
|
|
|
2462 |
|
|
|
2463 |
})();
|