Debian Codegraph @

debian/missing-sources/prism.js

raw
1 /* PrismJS 1.30.0
2 https://prismjs.com/download.html#themes=prism-okaidia&languages=clike&plugins=show-invisibles */
3 /// <reference lib="WebWorker"/>
4
5 var _self = (typeof window !== 'undefined')
6 ? window // if in browser
7 : (
8 (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
9 ? self // if in worker
10 : {} // if in node js
11 );
12
13 /**
14 * Prism: Lightweight, robust, elegant syntax highlighting
15 *
16 * @license MIT <https://opensource.org/licenses/MIT>
17 * @author Lea Verou <https://lea.verou.me>
18 * @namespace
19 * @public
20 */
21 var Prism = (function (_self) {
22
23 // Private helper vars
24 var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
25 var uniqueId = 0;
26
27 // The grammar object for plaintext
28 var plainTextGrammar = {};
29
30
31 var _ = {
32 /**
33 * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
34 * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
35 * additional languages or plugins yourself.
36 *
37 * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
38 *
39 * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
40 * empty Prism object into the global scope before loading the Prism script like this:
41 *
42 * ```js
43 * window.Prism = window.Prism || {};
44 * Prism.manual = true;
45 * // add a new <script> to load Prism's script
46 * ```
47 *
48 * @default false
49 * @type {boolean}
50 * @memberof Prism
51 * @public
52 */
53 manual: _self.Prism && _self.Prism.manual,
54 /**
55 * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
56 * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
57 * own worker, you don't want it to do this.
58 *
59 * By setting this value to `true`, Prism will not add its own listeners to the worker.
60 *
61 * You obviously have to change this value before Prism executes. To do this, you can add an
62 * empty Prism object into the global scope before loading the Prism script like this:
63 *
64 * ```js
65 * window.Prism = window.Prism || {};
66 * Prism.disableWorkerMessageHandler = true;
67 * // Load Prism's script
68 * ```
69 *
70 * @default false
71 * @type {boolean}
72 * @memberof Prism
73 * @public
74 */
75 disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
76
77 /**
78 * A namespace for utility methods.
79 *
80 * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
81 * change or disappear at any time.
82 *
83 * @namespace
84 * @memberof Prism
85 */
86 util: {
87 encode: function encode(tokens) {
88 if (tokens instanceof Token) {
89 return new Token(tokens.type, encode(tokens.content), tokens.alias);
90 } else if (Array.isArray(tokens)) {
91 return tokens.map(encode);
92 } else {
93 return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ');
94 }
95 },
96
97 /**
98 * Returns the name of the type of the given value.
99 *
100 * @param {any} o
101 * @returns {string}
102 * @example
103 * type(null) === 'Null'
104 * type(undefined) === 'Undefined'
105 * type(123) === 'Number'
106 * type('foo') === 'String'
107 * type(true) === 'Boolean'
108 * type([1, 2]) === 'Array'
109 * type({}) === 'Object'
110 * type(String) === 'Function'
111 * type(/abc+/) === 'RegExp'
112 */
113 type: function (o) {
114 return Object.prototype.toString.call(o).slice(8, -1);
115 },
116
117 /**
118 * Returns a unique number for the given object. Later calls will still return the same number.
119 *
120 * @param {Object} obj
121 * @returns {number}
122 */
123 objId: function (obj) {
124 if (!obj['__id']) {
125 Object.defineProperty(obj, '__id', { value: ++uniqueId });
126 }
127 return obj['__id'];
128 },
129
130 /**
131 * Creates a deep clone of the given object.
132 *
133 * The main intended use of this function is to clone language definitions.
134 *
135 * @param {T} o
136 * @param {Record<number, any>} [visited]
137 * @returns {T}
138 * @template T
139 */
140 clone: function deepClone(o, visited) {
141 visited = visited || {};
142
143 var clone; var id;
144 switch (_.util.type(o)) {
145 case 'Object':
146 id = _.util.objId(o);
147 if (visited[id]) {
148 return visited[id];
149 }
150 clone = /** @type {Record<string, any>} */ ({});
151 visited[id] = clone;
152
153 for (var key in o) {
154 if (o.hasOwnProperty(key)) {
155 clone[key] = deepClone(o[key], visited);
156 }
157 }
158
159 return /** @type {any} */ (clone);
160
161 case 'Array':
162 id = _.util.objId(o);
163 if (visited[id]) {
164 return visited[id];
165 }
166 clone = [];
167 visited[id] = clone;
168
169 (/** @type {Array} */(/** @type {any} */(o))).forEach(function (v, i) {
170 clone[i] = deepClone(v, visited);
171 });
172
173 return /** @type {any} */ (clone);
174
175 default:
176 return o;
177 }
178 },
179
180 /**
181 * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
182 *
183 * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
184 *
185 * @param {Element} element
186 * @returns {string}
187 */
188 getLanguage: function (element) {
189 while (element) {
190 var m = lang.exec(element.className);
191 if (m) {
192 return m[1].toLowerCase();
193 }
194 element = element.parentElement;
195 }
196 return 'none';
197 },
198
199 /**
200 * Sets the Prism `language-xxxx` class of the given element.
201 *
202 * @param {Element} element
203 * @param {string} language
204 * @returns {void}
205 */
206 setLanguage: function (element, language) {
207 // remove all `language-xxxx` classes
208 // (this might leave behind a leading space)
209 element.className = element.className.replace(RegExp(lang, 'gi'), '');
210
211 // add the new `language-xxxx` class
212 // (using `classList` will automatically clean up spaces for us)
213 element.classList.add('language-' + language);
214 },
215
216 /**
217 * Returns the script element that is currently executing.
218 *
219 * This does __not__ work for line script element.
220 *
221 * @returns {HTMLScriptElement | null}
222 */
223 currentScript: function () {
224 if (typeof document === 'undefined') {
225 return null;
226 }
227 if (document.currentScript && document.currentScript.tagName === 'SCRIPT' && 1 < 2 /* hack to trip TS' flow analysis */) {
228 return /** @type {any} */ (document.currentScript);
229 }
230
231 // IE11 workaround
232 // we'll get the src of the current script by parsing IE11's error stack trace
233 // this will not work for inline scripts
234
235 try {
236 throw new Error();
237 } catch (err) {
238 // Get file src url from stack. Specifically works with the format of stack traces in IE.
239 // A stack will look like this:
240 //
241 // Error
242 // at _.util.currentScript (http://localhost/components/prism-core.js:119:5)
243 // at Global code (http://localhost/components/prism-core.js:606:1)
244
245 var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) || [])[1];
246 if (src) {
247 var scripts = document.getElementsByTagName('script');
248 for (var i in scripts) {
249 if (scripts[i].src == src) {
250 return scripts[i];
251 }
252 }
253 }
254 return null;
255 }
256 },
257
258 /**
259 * Returns whether a given class is active for `element`.
260 *
261 * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
262 * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
263 * given class is just the given class with a `no-` prefix.
264 *
265 * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
266 * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
267 * ancestors have the given class or the negated version of it, then the default activation will be returned.
268 *
269 * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
270 * version of it, the class is considered active.
271 *
272 * @param {Element} element
273 * @param {string} className
274 * @param {boolean} [defaultActivation=false]
275 * @returns {boolean}
276 */
277 isActive: function (element, className, defaultActivation) {
278 var no = 'no-' + className;
279
280 while (element) {
281 var classList = element.classList;
282 if (classList.contains(className)) {
283 return true;
284 }
285 if (classList.contains(no)) {
286 return false;
287 }
288 element = element.parentElement;
289 }
290 return !!defaultActivation;
291 }
292 },
293
294 /**
295 * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
296 *
297 * @namespace
298 * @memberof Prism
299 * @public
300 */
301 languages: {
302 /**
303 * The grammar for plain, unformatted text.
304 */
305 plain: plainTextGrammar,
306 plaintext: plainTextGrammar,
307 text: plainTextGrammar,
308 txt: plainTextGrammar,
309
310 /**
311 * Creates a deep copy of the language with the given id and appends the given tokens.
312 *
313 * If a token in `redef` also appears in the copied language, then the existing token in the copied language
314 * will be overwritten at its original position.
315 *
316 * ## Best practices
317 *
318 * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
319 * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
320 * understand the language definition because, normally, the order of tokens matters in Prism grammars.
321 *
322 * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
323 * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
324 *
325 * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
326 * @param {Grammar} redef The new tokens to append.
327 * @returns {Grammar} The new language created.
328 * @public
329 * @example
330 * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
331 * // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
332 * // at its original position
333 * 'comment': { ... },
334 * // CSS doesn't have a 'color' token, so this token will be appended
335 * 'color': /\b(?:red|green|blue)\b/
336 * });
337 */
338 extend: function (id, redef) {
339 var lang = _.util.clone(_.languages[id]);
340
341 for (var key in redef) {
342 lang[key] = redef[key];
343 }
344
345 return lang;
346 },
347
348 /**
349 * Inserts tokens _before_ another token in a language definition or any other grammar.
350 *
351 * ## Usage
352 *
353 * This helper method makes it easy to modify existing languages. For example, the CSS language definition
354 * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
355 * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
356 * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
357 * this:
358 *
359 * ```js
360 * Prism.languages.markup.style = {
361 * // token
362 * };
363 * ```
364 *
365 * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
366 * before existing tokens. For the CSS example above, you would use it like this:
367 *
368 * ```js
369 * Prism.languages.insertBefore('markup', 'cdata', {
370 * 'style': {
371 * // token
372 * }
373 * });
374 * ```
375 *
376 * ## Special cases
377 *
378 * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
379 * will be ignored.
380 *
381 * This behavior can be used to insert tokens after `before`:
382 *
383 * ```js
384 * Prism.languages.insertBefore('markup', 'comment', {
385 * 'comment': Prism.languages.markup.comment,
386 * // tokens after 'comment'
387 * });
388 * ```
389 *
390 * ## Limitations
391 *
392 * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
393 * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
394 * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
395 * deleting properties which is necessary to insert at arbitrary positions.
396 *
397 * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
398 * Instead, it will create a new object and replace all references to the target object with the new one. This
399 * can be done without temporarily deleting properties, so the iteration order is well-defined.
400 *
401 * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
402 * you hold the target object in a variable, then the value of the variable will not change.
403 *
404 * ```js
405 * var oldMarkup = Prism.languages.markup;
406 * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
407 *
408 * assert(oldMarkup !== Prism.languages.markup);
409 * assert(newMarkup === Prism.languages.markup);
410 * ```
411 *
412 * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
413 * object to be modified.
414 * @param {string} before The key to insert before.
415 * @param {Grammar} insert An object containing the key-value pairs to be inserted.
416 * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
417 * object to be modified.
418 *
419 * Defaults to `Prism.languages`.
420 * @returns {Grammar} The new grammar object.
421 * @public
422 */
423 insertBefore: function (inside, before, insert, root) {
424 root = root || /** @type {any} */ (_.languages);
425 var grammar = root[inside];
426 /** @type {Grammar} */
427 var ret = {};
428
429 for (var token in grammar) {
430 if (grammar.hasOwnProperty(token)) {
431
432 if (token == before) {
433 for (var newToken in insert) {
434 if (insert.hasOwnProperty(newToken)) {
435 ret[newToken] = insert[newToken];
436 }
437 }
438 }
439
440 // Do not insert token which also occur in insert. See #1525
441 if (!insert.hasOwnProperty(token)) {
442 ret[token] = grammar[token];
443 }
444 }
445 }
446
447 var old = root[inside];
448 root[inside] = ret;
449
450 // Update references in other language definitions
451 _.languages.DFS(_.languages, function (key, value) {
452 if (value === old && key != inside) {
453 this[key] = ret;
454 }
455 });
456
457 return ret;
458 },
459
460 // Traverse a language definition with Depth First Search
461 DFS: function DFS(o, callback, type, visited) {
462 visited = visited || {};
463
464 var objId = _.util.objId;
465
466 for (var i in o) {
467 if (o.hasOwnProperty(i)) {
468 callback.call(o, i, o[i], type || i);
469
470 var property = o[i];
471 var propertyType = _.util.type(property);
472
473 if (propertyType === 'Object' && !visited[objId(property)]) {
474 visited[objId(property)] = true;
475 DFS(property, callback, null, visited);
476 } else if (propertyType === 'Array' && !visited[objId(property)]) {
477 visited[objId(property)] = true;
478 DFS(property, callback, i, visited);
479 }
480 }
481 }
482 }
483 },
484
485 plugins: {},
486
487 /**
488 * This is the most high-level function in Prism’s API.
489 * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
490 * each one of them.
491 *
492 * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
493 *
494 * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
495 * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
496 * @memberof Prism
497 * @public
498 */
499 highlightAll: function (async, callback) {
500 _.highlightAllUnder(document, async, callback);
501 },
502
503 /**
504 * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
505 * {@link Prism.highlightElement} on each one of them.
506 *
507 * The following hooks will be run:
508 * 1. `before-highlightall`
509 * 2. `before-all-elements-highlight`
510 * 3. All hooks of {@link Prism.highlightElement} for each element.
511 *
512 * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
513 * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
514 * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
515 * @memberof Prism
516 * @public
517 */
518 highlightAllUnder: function (container, async, callback) {
519 var env = {
520 callback: callback,
521 container: container,
522 selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
523 };
524
525 _.hooks.run('before-highlightall', env);
526
527 env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));
528
529 _.hooks.run('before-all-elements-highlight', env);
530
531 for (var i = 0, element; (element = env.elements[i++]);) {
532 _.highlightElement(element, async === true, env.callback);
533 }
534 },
535
536 /**
537 * Highlights the code inside a single element.
538 *
539 * The following hooks will be run:
540 * 1. `before-sanity-check`
541 * 2. `before-highlight`
542 * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
543 * 4. `before-insert`
544 * 5. `after-highlight`
545 * 6. `complete`
546 *
547 * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
548 * the element's language.
549 *
550 * @param {Element} element The element containing the code.
551 * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
552 * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
553 * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
554 * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
555 *
556 * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
557 * asynchronous highlighting to work. You can build your own bundle on the
558 * [Download page](https://prismjs.com/download.html).
559 * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
560 * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
561 * @memberof Prism
562 * @public
563 */
564 highlightElement: function (element, async, callback) {
565 // Find language
566 var language = _.util.getLanguage(element);
567 var grammar = _.languages[language];
568
569 // Set language on the element, if not present
570 _.util.setLanguage(element, language);
571
572 // Set language on the parent, for styling
573 var parent = element.parentElement;
574 if (parent && parent.nodeName.toLowerCase() === 'pre') {
575 _.util.setLanguage(parent, language);
576 }
577
578 var code = element.textContent;
579
580 var env = {
581 element: element,
582 language: language,
583 grammar: grammar,
584 code: code
585 };
586
587 function insertHighlightedCode(highlightedCode) {
588 env.highlightedCode = highlightedCode;
589
590 _.hooks.run('before-insert', env);
591
592 env.element.innerHTML = env.highlightedCode;
593
594 _.hooks.run('after-highlight', env);
595 _.hooks.run('complete', env);
596 callback && callback.call(env.element);
597 }
598
599 _.hooks.run('before-sanity-check', env);
600
601 // plugins may change/add the parent/element
602 parent = env.element.parentElement;
603 if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) {
604 parent.setAttribute('tabindex', '0');
605 }
606
607 if (!env.code) {
608 _.hooks.run('complete', env);
609 callback && callback.call(env.element);
610 return;
611 }
612
613 _.hooks.run('before-highlight', env);
614
615 if (!env.grammar) {
616 insertHighlightedCode(_.util.encode(env.code));
617 return;
618 }
619
620 if (async && _self.Worker) {
621 var worker = new Worker(_.filename);
622
623 worker.onmessage = function (evt) {
624 insertHighlightedCode(evt.data);
625 };
626
627 worker.postMessage(JSON.stringify({
628 language: env.language,
629 code: env.code,
630 immediateClose: true
631 }));
632 } else {
633 insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
634 }
635 },
636
637 /**
638 * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
639 * and the language definitions to use, and returns a string with the HTML produced.
640 *
641 * The following hooks will be run:
642 * 1. `before-tokenize`
643 * 2. `after-tokenize`
644 * 3. `wrap`: On each {@link Token}.
645 *
646 * @param {string} text A string with the code to be highlighted.
647 * @param {Grammar} grammar An object containing the tokens to use.
648 *
649 * Usually a language definition like `Prism.languages.markup`.
650 * @param {string} language The name of the language definition passed to `grammar`.
651 * @returns {string} The highlighted HTML.
652 * @memberof Prism
653 * @public
654 * @example
655 * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
656 */
657 highlight: function (text, grammar, language) {
658 var env = {
659 code: text,
660 grammar: grammar,
661 language: language
662 };
663 _.hooks.run('before-tokenize', env);
664 if (!env.grammar) {
665 throw new Error('The language "' + env.language + '" has no grammar.');
666 }
667 env.tokens = _.tokenize(env.code, env.grammar);
668 _.hooks.run('after-tokenize', env);
669 return Token.stringify(_.util.encode(env.tokens), env.language);
670 },
671
672 /**
673 * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
674 * and the language definitions to use, and returns an array with the tokenized code.
675 *
676 * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
677 *
678 * This method could be useful in other contexts as well, as a very crude parser.
679 *
680 * @param {string} text A string with the code to be highlighted.
681 * @param {Grammar} grammar An object containing the tokens to use.
682 *
683 * Usually a language definition like `Prism.languages.markup`.
684 * @returns {TokenStream} An array of strings and tokens, a token stream.
685 * @memberof Prism
686 * @public
687 * @example
688 * let code = `var foo = 0;`;
689 * let tokens = Prism.tokenize(code, Prism.languages.javascript);
690 * tokens.forEach(token => {
691 * if (token instanceof Prism.Token && token.type === 'number') {
692 * console.log(`Found numeric literal: ${token.content}`);
693 * }
694 * });
695 */
696 tokenize: function (text, grammar) {
697 var rest = grammar.rest;
698 if (rest) {
699 for (var token in rest) {
700 grammar[token] = rest[token];
701 }
702
703 delete grammar.rest;
704 }
705
706 var tokenList = new LinkedList();
707 addAfter(tokenList, tokenList.head, text);
708
709 matchGrammar(text, tokenList, grammar, tokenList.head, 0);
710
711 return toArray(tokenList);
712 },
713
714 /**
715 * @namespace
716 * @memberof Prism
717 * @public
718 */
719 hooks: {
720 all: {},
721
722 /**
723 * Adds the given callback to the list of callbacks for the given hook.
724 *
725 * The callback will be invoked when the hook it is registered for is run.
726 * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
727 *
728 * One callback function can be registered to multiple hooks and the same hook multiple times.
729 *
730 * @param {string} name The name of the hook.
731 * @param {HookCallback} callback The callback function which is given environment variables.
732 * @public
733 */
734 add: function (name, callback) {
735 var hooks = _.hooks.all;
736
737 hooks[name] = hooks[name] || [];
738
739 hooks[name].push(callback);
740 },
741
742 /**
743 * Runs a hook invoking all registered callbacks with the given environment variables.
744 *
745 * Callbacks will be invoked synchronously and in the order in which they were registered.
746 *
747 * @param {string} name The name of the hook.
748 * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
749 * @public
750 */
751 run: function (name, env) {
752 var callbacks = _.hooks.all[name];
753
754 if (!callbacks || !callbacks.length) {
755 return;
756 }
757
758 for (var i = 0, callback; (callback = callbacks[i++]);) {
759 callback(env);
760 }
761 }
762 },
763
764 Token: Token
765 };
766 _self.Prism = _;
767
768
769 // Typescript note:
770 // The following can be used to import the Token type in JSDoc:
771 //
772 // @typedef {InstanceType<import("./prism-core")["Token"]>} Token
773
774 /**
775 * Creates a new token.
776 *
777 * @param {string} type See {@link Token#type type}
778 * @param {string | TokenStream} content See {@link Token#content content}
779 * @param {string|string[]} [alias] The alias(es) of the token.
780 * @param {string} [matchedStr=""] A copy of the full string this token was created from.
781 * @class
782 * @global
783 * @public
784 */
785 function Token(type, content, alias, matchedStr) {
786 /**
787 * The type of the token.
788 *
789 * This is usually the key of a pattern in a {@link Grammar}.
790 *
791 * @type {string}
792 * @see GrammarToken
793 * @public
794 */
795 this.type = type;
796 /**
797 * The strings or tokens contained by this token.
798 *
799 * This will be a token stream if the pattern matched also defined an `inside` grammar.
800 *
801 * @type {string | TokenStream}
802 * @public
803 */
804 this.content = content;
805 /**
806 * The alias(es) of the token.
807 *
808 * @type {string|string[]}
809 * @see GrammarToken
810 * @public
811 */
812 this.alias = alias;
813 // Copy of the full string this token was created from
814 this.length = (matchedStr || '').length | 0;
815 }
816
817 /**
818 * A token stream is an array of strings and {@link Token Token} objects.
819 *
820 * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process
821 * them.
822 *
823 * 1. No adjacent strings.
824 * 2. No empty strings.
825 *
826 * The only exception here is the token stream that only contains the empty string and nothing else.
827 *
828 * @typedef {Array<string | Token>} TokenStream
829 * @global
830 * @public
831 */
832
833 /**
834 * Converts the given token or token stream to an HTML representation.
835 *
836 * The following hooks will be run:
837 * 1. `wrap`: On each {@link Token}.
838 *
839 * @param {string | Token | TokenStream} o The token or token stream to be converted.
840 * @param {string} language The name of current language.
841 * @returns {string} The HTML representation of the token or token stream.
842 * @memberof Token
843 * @static
844 */
845 Token.stringify = function stringify(o, language) {
846 if (typeof o == 'string') {
847 return o;
848 }
849 if (Array.isArray(o)) {
850 var s = '';
851 o.forEach(function (e) {
852 s += stringify(e, language);
853 });
854 return s;
855 }
856
857 var env = {
858 type: o.type,
859 content: stringify(o.content, language),
860 tag: 'span',
861 classes: ['token', o.type],
862 attributes: {},
863 language: language
864 };
865
866 var aliases = o.alias;
867 if (aliases) {
868 if (Array.isArray(aliases)) {
869 Array.prototype.push.apply(env.classes, aliases);
870 } else {
871 env.classes.push(aliases);
872 }
873 }
874
875 _.hooks.run('wrap', env);
876
877 var attributes = '';
878 for (var name in env.attributes) {
879 attributes += ' ' + name + '="' + (env.attributes[name] || '').replace(/"/g, '&quot;') + '"';
880 }
881
882 return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + attributes + '>' + env.content + '</' + env.tag + '>';
883 };
884
885 /**
886 * @param {RegExp} pattern
887 * @param {number} pos
888 * @param {string} text
889 * @param {boolean} lookbehind
890 * @returns {RegExpExecArray | null}
891 */
892 function matchPattern(pattern, pos, text, lookbehind) {
893 pattern.lastIndex = pos;
894 var match = pattern.exec(text);
895 if (match && lookbehind && match[1]) {
896 // change the match to remove the text matched by the Prism lookbehind group
897 var lookbehindLength = match[1].length;
898 match.index += lookbehindLength;
899 match[0] = match[0].slice(lookbehindLength);
900 }
901 return match;
902 }
903
904 /**
905 * @param {string} text
906 * @param {LinkedList<string | Token>} tokenList
907 * @param {any} grammar
908 * @param {LinkedListNode<string | Token>} startNode
909 * @param {number} startPos
910 * @param {RematchOptions} [rematch]
911 * @returns {void}
912 * @private
913 *
914 * @typedef RematchOptions
915 * @property {string} cause
916 * @property {number} reach
917 */
918 function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
919 for (var token in grammar) {
920 if (!grammar.hasOwnProperty(token) || !grammar[token]) {
921 continue;
922 }
923
924 var patterns = grammar[token];
925 patterns = Array.isArray(patterns) ? patterns : [patterns];
926
927 for (var j = 0; j < patterns.length; ++j) {
928 if (rematch && rematch.cause == token + ',' + j) {
929 return;
930 }
931
932 var patternObj = patterns[j];
933 var inside = patternObj.inside;
934 var lookbehind = !!patternObj.lookbehind;
935 var greedy = !!patternObj.greedy;
936 var alias = patternObj.alias;
937
938 if (greedy && !patternObj.pattern.global) {
939 // Without the global flag, lastIndex won't work
940 var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
941 patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');
942 }
943
944 /** @type {RegExp} */
945 var pattern = patternObj.pattern || patternObj;
946
947 for ( // iterate the token list and keep track of the current token/string position
948 var currentNode = startNode.next, pos = startPos;
949 currentNode !== tokenList.tail;
950 pos += currentNode.value.length, currentNode = currentNode.next
951 ) {
952
953 if (rematch && pos >= rematch.reach) {
954 break;
955 }
956
957 var str = currentNode.value;
958
959 if (tokenList.length > text.length) {
960 // Something went terribly wrong, ABORT, ABORT!
961 return;
962 }
963
964 if (str instanceof Token) {
965 continue;
966 }
967
968 var removeCount = 1; // this is the to parameter of removeBetween
969 var match;
970
971 if (greedy) {
972 match = matchPattern(pattern, pos, text, lookbehind);
973 if (!match || match.index >= text.length) {
974 break;
975 }
976
977 var from = match.index;
978 var to = match.index + match[0].length;
979 var p = pos;
980
981 // find the node that contains the match
982 p += currentNode.value.length;
983 while (from >= p) {
984 currentNode = currentNode.next;
985 p += currentNode.value.length;
986 }
987 // adjust pos (and p)
988 p -= currentNode.value.length;
989 pos = p;
990
991 // the current node is a Token, then the match starts inside another Token, which is invalid
992 if (currentNode.value instanceof Token) {
993 continue;
994 }
995
996 // find the last node which is affected by this match
997 for (
998 var k = currentNode;
999 k !== tokenList.tail && (p < to || typeof k.value === 'string');
1000 k = k.next
1001 ) {
1002 removeCount++;
1003 p += k.value.length;
1004 }
1005 removeCount--;
1006
1007 // replace with the new match
1008 str = text.slice(pos, p);
1009 match.index -= pos;
1010 } else {
1011 match = matchPattern(pattern, 0, str, lookbehind);
1012 if (!match) {
1013 continue;
1014 }
1015 }
1016
1017 // eslint-disable-next-line no-redeclare
1018 var from = match.index;
1019 var matchStr = match[0];
1020 var before = str.slice(0, from);
1021 var after = str.slice(from + matchStr.length);
1022
1023 var reach = pos + str.length;
1024 if (rematch && reach > rematch.reach) {
1025 rematch.reach = reach;
1026 }
1027
1028 var removeFrom = currentNode.prev;
1029
1030 if (before) {
1031 removeFrom = addAfter(tokenList, removeFrom, before);
1032 pos += before.length;
1033 }
1034
1035 removeRange(tokenList, removeFrom, removeCount);
1036
1037 var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
1038 currentNode = addAfter(tokenList, removeFrom, wrapped);
1039
1040 if (after) {
1041 addAfter(tokenList, currentNode, after);
1042 }
1043
1044 if (removeCount > 1) {
1045 // at least one Token object was removed, so we have to do some rematching
1046 // this can only happen if the current pattern is greedy
1047
1048 /** @type {RematchOptions} */
1049 var nestedRematch = {
1050 cause: token + ',' + j,
1051 reach: reach
1052 };
1053 matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
1054
1055 // the reach might have been extended because of the rematching
1056 if (rematch && nestedRematch.reach > rematch.reach) {
1057 rematch.reach = nestedRematch.reach;
1058 }
1059 }
1060 }
1061 }
1062 }
1063 }
1064
1065 /**
1066 * @typedef LinkedListNode
1067 * @property {T} value
1068 * @property {LinkedListNode<T> | null} prev The previous node.
1069 * @property {LinkedListNode<T> | null} next The next node.
1070 * @template T
1071 * @private
1072 */
1073
1074 /**
1075 * @template T
1076 * @private
1077 */
1078 function LinkedList() {
1079 /** @type {LinkedListNode<T>} */
1080 var head = { value: null, prev: null, next: null };
1081 /** @type {LinkedListNode<T>} */
1082 var tail = { value: null, prev: head, next: null };
1083 head.next = tail;
1084
1085 /** @type {LinkedListNode<T>} */
1086 this.head = head;
1087 /** @type {LinkedListNode<T>} */
1088 this.tail = tail;
1089 this.length = 0;
1090 }
1091
1092 /**
1093 * Adds a new node with the given value to the list.
1094 *
1095 * @param {LinkedList<T>} list
1096 * @param {LinkedListNode<T>} node
1097 * @param {T} value
1098 * @returns {LinkedListNode<T>} The added node.
1099 * @template T
1100 */
1101 function addAfter(list, node, value) {
1102 // assumes that node != list.tail && values.length >= 0
1103 var next = node.next;
1104
1105 var newNode = { value: value, prev: node, next: next };
1106 node.next = newNode;
1107 next.prev = newNode;
1108 list.length++;
1109
1110 return newNode;
1111 }
1112 /**
1113 * Removes `count` nodes after the given node. The given node will not be removed.
1114 *
1115 * @param {LinkedList<T>} list
1116 * @param {LinkedListNode<T>} node
1117 * @param {number} count
1118 * @template T
1119 */
1120 function removeRange(list, node, count) {
1121 var next = node.next;
1122 for (var i = 0; i < count && next !== list.tail; i++) {
1123 next = next.next;
1124 }
1125 node.next = next;
1126 next.prev = node;
1127 list.length -= i;
1128 }
1129 /**
1130 * @param {LinkedList<T>} list
1131 * @returns {T[]}
1132 * @template T
1133 */
1134 function toArray(list) {
1135 var array = [];
1136 var node = list.head.next;
1137 while (node !== list.tail) {
1138 array.push(node.value);
1139 node = node.next;
1140 }
1141 return array;
1142 }
1143
1144
1145 if (!_self.document) {
1146 if (!_self.addEventListener) {
1147 // in Node.js
1148 return _;
1149 }
1150
1151 if (!_.disableWorkerMessageHandler) {
1152 // In worker
1153 _self.addEventListener('message', function (evt) {
1154 var message = JSON.parse(evt.data);
1155 var lang = message.language;
1156 var code = message.code;
1157 var immediateClose = message.immediateClose;
1158
1159 _self.postMessage(_.highlight(code, _.languages[lang], lang));
1160 if (immediateClose) {
1161 _self.close();
1162 }
1163 }, false);
1164 }
1165
1166 return _;
1167 }
1168
1169 // Get current script and highlight
1170 var script = _.util.currentScript();
1171
1172 if (script) {
1173 _.filename = script.src;
1174
1175 if (script.hasAttribute('data-manual')) {
1176 _.manual = true;
1177 }
1178 }
1179
1180 function highlightAutomaticallyCallback() {
1181 if (!_.manual) {
1182 _.highlightAll();
1183 }
1184 }
1185
1186 if (!_.manual) {
1187 // If the document state is "loading", then we'll use DOMContentLoaded.
1188 // If the document state is "interactive" and the prism.js script is deferred, then we'll also use the
1189 // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they
1190 // might take longer one animation frame to execute which can create a race condition where only some plugins have
1191 // been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded.
1192 // See https://github.com/PrismJS/prism/issues/2102
1193 var readyState = document.readyState;
1194 if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
1195 document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
1196 } else {
1197 if (window.requestAnimationFrame) {
1198 window.requestAnimationFrame(highlightAutomaticallyCallback);
1199 } else {
1200 window.setTimeout(highlightAutomaticallyCallback, 16);
1201 }
1202 }
1203 }
1204
1205 return _;
1206
1207 }(_self));
1208
1209 if (typeof module !== 'undefined' && module.exports) {
1210 module.exports = Prism;
1211 }
1212
1213 // hack for components to work correctly in node.js
1214 if (typeof global !== 'undefined') {
1215 global.Prism = Prism;
1216 }
1217
1218 // some additional documentation/types
1219
1220 /**
1221 * The expansion of a simple `RegExp` literal to support additional properties.
1222 *
1223 * @typedef GrammarToken
1224 * @property {RegExp} pattern The regular expression of the token.
1225 * @property {boolean} [lookbehind=false] If `true`, then the first capturing group of `pattern` will (effectively)
1226 * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.
1227 * @property {boolean} [greedy=false] Whether the token is greedy.
1228 * @property {string|string[]} [alias] An optional alias or list of aliases.
1229 * @property {Grammar} [inside] The nested grammar of this token.
1230 *
1231 * The `inside` grammar will be used to tokenize the text value of each token of this kind.
1232 *
1233 * This can be used to make nested and even recursive language definitions.
1234 *
1235 * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into
1236 * each another.
1237 * @global
1238 * @public
1239 */
1240
1241 /**
1242 * @typedef Grammar
1243 * @type {Object<string, RegExp | GrammarToken | Array<RegExp | GrammarToken>>}
1244 * @property {Grammar} [rest] An optional grammar object that will be appended to this grammar.
1245 * @global
1246 * @public
1247 */
1248
1249 /**
1250 * A function which will invoked after an element was successfully highlighted.
1251 *
1252 * @callback HighlightCallback
1253 * @param {Element} element The element successfully highlighted.
1254 * @returns {void}
1255 * @global
1256 * @public
1257 */
1258
1259 /**
1260 * @callback HookCallback
1261 * @param {Object<string, any>} env The environment variables of the hook.
1262 * @returns {void}
1263 * @global
1264 * @public
1265 */
1266 ;
1267 Prism.languages.clike = {
1268 'comment': [
1269 {
1270 pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
1271 lookbehind: true,
1272 greedy: true
1273 },
1274 {
1275 pattern: /(^|[^\\:])\/\/.*/,
1276 lookbehind: true,
1277 greedy: true
1278 }
1279 ],
1280 'string': {
1281 pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
1282 greedy: true
1283 },
1284 'class-name': {
1285 pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
1286 lookbehind: true,
1287 inside: {
1288 'punctuation': /[.\\]/
1289 }
1290 },
1291 'keyword': /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
1292 'boolean': /\b(?:false|true)\b/,
1293 'function': /\b\w+(?=\()/,
1294 'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
1295 'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
1296 'punctuation': /[{}[\];(),.:]/
1297 };
1298
1299 (function () {
1300
1301 if (typeof Prism === 'undefined') {
1302 return;
1303 }
1304
1305
1306 var invisibles = {
1307 'tab': /\t/,
1308 'crlf': /\r\n/,
1309 'lf': /\n/,
1310 'cr': /\r/,
1311 'space': / /
1312 };
1313
1314
1315 /**
1316 * Handles the recursive calling of `addInvisibles` for one token.
1317 *
1318 * @param {Object|Array} tokens The grammar or array which contains the token.
1319 * @param {string|number} name The name or index of the token in `tokens`.
1320 */
1321 function handleToken(tokens, name) {
1322 var value = tokens[name];
1323
1324 var type = Prism.util.type(value);
1325 switch (type) {
1326 case 'RegExp':
1327 var inside = {};
1328 tokens[name] = {
1329 pattern: value,
1330 inside: inside
1331 };
1332 addInvisibles(inside);
1333 break;
1334
1335 case 'Array':
1336 for (var i = 0, l = value.length; i < l; i++) {
1337 handleToken(value, i);
1338 }
1339 break;
1340
1341 default: // 'Object'
1342 // eslint-disable-next-line no-redeclare
1343 var inside = value.inside || (value.inside = {});
1344 addInvisibles(inside);
1345 break;
1346 }
1347 }
1348
1349 /**
1350 * Recursively adds patterns to match invisible characters to the given grammar (if not added already).
1351 *
1352 * @param {Object} grammar
1353 */
1354 function addInvisibles(grammar) {
1355 if (!grammar || grammar['tab']) {
1356 return;
1357 }
1358
1359 // assign invisibles here to "mark" the grammar in case of self references
1360 for (var name in invisibles) {
1361 if (invisibles.hasOwnProperty(name)) {
1362 grammar[name] = invisibles[name];
1363 }
1364 }
1365
1366 // eslint-disable-next-line no-redeclare
1367 for (var name in grammar) {
1368 if (grammar.hasOwnProperty(name) && !invisibles[name]) {
1369 if (name === 'rest') {
1370 addInvisibles(grammar['rest']);
1371 } else {
1372 handleToken(grammar, name);
1373 }
1374 }
1375 }
1376 }
1377
1378 Prism.hooks.add('before-highlight', function (env) {
1379 addInvisibles(env.grammar);
1380 });
1381 }());
1382