https://carawards.org/assets/lexxy-18fab1b7.js

1var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
2
3function getDefaultExportFromCjs (x) {
4	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
5}
6
7var prism = {exports: {}};
8
9var hasRequiredPrism;
10
11function requirePrism () {
12	if (hasRequiredPrism) return prism.exports;
13	hasRequiredPrism = 1;
14	(function (module) {
15		/* **********************************************
16		     Begin prism-core.js
17		********************************************** */
18
19		/// <reference lib="WebWorker"/>
20
21		var _self = (typeof window !== 'undefined')
22			? window   // if in browser
23			: (
24				(typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
25					? self // if in worker
26					: {}   // if in node js
27			);
28
29		/**
30		 * Prism: Lightweight, robust, elegant syntax highlighting
31		 *
32		 * @license MIT <https://opensource.org/licenses/MIT>
33		 * @author Lea Verou <https://lea.verou.me>
34		 * @namespace
35		 * @public
36		 */
37		var Prism = (function (_self) {
38
39			// Private helper vars
40			var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
41			var uniqueId = 0;
42
43			// The grammar object for plaintext
44			var plainTextGrammar = {};
45
46
47			var _ = {
48				/**
49				 * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
50				 * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
51				 * additional languages or plugins yourself.
52				 *
53				 * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
54				 *
55				 * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
56				 * empty Prism object into the global scope before loading the Prism script like this:
57				 *
58				 * ```js
59				 * window.Prism = window.Prism || {};
60				 * Prism.manual = true;
61				 * // add a new <script> to load Prism's script
62				 * ```
63				 *
64				 * @default false
65				 * @type {boolean}
66				 * @memberof Prism
67				 * @public
68				 */
69				manual: _self.Prism && _self.Prism.manual,
70				/**
71				 * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
72				 * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
73				 * own worker, you don't want it to do this.
74				 *
75				 * By setting this value to `true`, Prism will not add its own listeners to the worker.
76				 *
77				 * You obviously have to change this value before Prism executes. To do this, you can add an
78				 * empty Prism object into the global scope before loading the Prism script like this:
79				 *
80				 * ```js
81				 * window.Prism = window.Prism || {};
82				 * Prism.disableWorkerMessageHandler = true;
83				 * // Load Prism's script
84				 * ```
85				 *
86				 * @default false
87				 * @type {boolean}
88				 * @memberof Prism
89				 * @public
90				 */
91				disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
92
93				/**
94				 * A namespace for utility methods.
95				 *
96				 * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
97				 * change or disappear at any time.
98				 *
99				 * @namespace
100				 * @memberof Prism
101				 */
102				util: {
103					encode: function encode(tokens) {
104						if (tokens instanceof Token) {
105							return new Token(tokens.type, encode(tokens.content), tokens.alias);
106						} else if (Array.isArray(tokens)) {
107							return tokens.map(encode);
108						} else {
109							return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ');
110						}
111					},
112
113					/**
114					 * Returns the name of the type of the given value.
115					 *
116					 * @param {any} o
117					 * @returns {string}
118					 * @example
119					 * type(null)      === 'Null'
120					 * type(undefined) === 'Undefined'
121					 * type(123)       === 'Number'
122					 * type('foo')     === 'String'
123					 * type(true)      === 'Boolean'
124					 * type([1, 2])    === 'Array'
125					 * type({})        === 'Object'
126					 * type(String)    === 'Function'
127					 * type(/abc+/)    === 'RegExp'
128					 */
129					type: function (o) {
130						return Object.prototype.toString.call(o).slice(8, -1);
131					},
132
133					/**
134					 * Returns a unique number for the given object. Later calls will still return the same number.
135					 *
136					 * @param {Object} obj
137					 * @returns {number}
138					 */
139					objId: function (obj) {
140						if (!obj['__id']) {
141							Object.defineProperty(obj, '__id', { value: ++uniqueId });
142						}
143						return obj['__id'];
144					},
145
146					/**
147					 * Creates a deep clone of the given object.
148					 *
149					 * The main intended use of this function is to clone language definitions.
150					 *
151					 * @param {T} o
152					 * @param {Record<number, any>} [visited]
153					 * @returns {T}
154					 * @template T
155					 */
156					clone: function deepClone(o, visited) {
157						visited = visited || {};
158
159						var clone; var id;
160						switch (_.util.type(o)) {
161							case 'Object':
162								id = _.util.objId(o);
163								if (visited[id]) {
164									return visited[id];
165								}
166								clone = /** @type {Record<string, any>} */ ({});
167								visited[id] = clone;
168
169								for (var key in o) {
170									if (o.hasOwnProperty(key)) {
171										clone[key] = deepClone(o[key], visited);
172									}
173								}
174
175								return /** @type {any} */ (clone);
176
177							case 'Array':
178								id = _.util.objId(o);
179								if (visited[id]) {
180									return visited[id];
181								}
182								clone = [];
183								visited[id] = clone;
184
185								(/** @type {Array} */(/** @type {any}

185 */(o))).forEach(function (v, i) {
186									clone[i] = deepClone(v, visited);
187								});
188
189								return /** @type {any} */ (clone);
190
191							default:
192								return o;
193						}
194					},
195
196					/**
197					 * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
198					 *
199					 * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
200					 *
201					 * @param {Element} element
202					 * @returns {string}
203					 */
204					getLanguage: function (element) {
205						while (element) {
206							var m = lang.exec(element.className);
207							if (m) {
208								return m[1].toLowerCase();
209							}
210							element = element.parentElement;
211						}
212						return 'none';
213					},
214
215					/**
216					 * Sets the Prism `language-xxxx` class of the given element.
217					 *
218					 * @param {Element} element
219					 * @param {string} language
220					 * @returns {void}
221					 */
222					setLanguage: function (element, language) {
223						// remove all `language-xxxx` classes
224						// (this might leave behind a leading space)
225						element.className = element.className.replace(RegExp(lang, 'gi'), '');
226
227						// add the new `language-xxxx` class
228						// (using `classList` will automatically clean up spaces for us)
229						element.classList.add('language-' + language);
230					},
231
232					/**
233					 * Returns the script element that is currently executing.
234					 *
235					 * This does __not__ work for line script element.
236					 *
237					 * @returns {HTMLScriptElement | null}
238					 */
239					currentScript: function () {
240						if (typeof document === 'undefined') {
241							return null;
242						}
243						if (document.currentScript && document.currentScript.tagName === 'SCRIPT' && 1 < 2 /* hack to trip TS' flow analysis */) {
244							return /** @type {any} */ (document.currentScript);
245						}
246
247						// IE11 workaround
248						// we'll get the src of the current script by parsing IE11's error stack trace
249						// this will not work for inline scripts
250
251						try {
252							throw new Error();
253						} catch (err) {
254							// Get file src url from stack. Specifically works with the format of stack traces in IE.
255							// A stack will look like this:
256							//
257							// Error
258							//    at _.util.currentScript (http://localhost/components/prism-core.js:119:5)
259							//    at Global code (http://localhost/components/prism-core.js:606:1)
260
261							var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) || [])[1];
262							if (src) {
263								var scripts = document.getElementsByTagName('script');
264								for (var i in scripts) {
265									if (scripts[i].src == src) {
266										return scripts[i];
267									}
268								}
269							}
270							return null;
271						}
272					},
273
274					/**
275					 * Returns whether a given class is active for `element`.
276					 *
277					 * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
278					 * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
279					 * given class is just the given class with a `no-` prefix.
280					 *
281					 * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
282					 * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
283					 * ancestors have the given class or the negated version of it, then the default activation will be returned.
284					 *
285					 * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
286					 * version of it, the class is considered active.
287					 *
288					 * @param {Element} element
289					 * @param {string} className
290					 * @param {boolean} [defaultActivation=false]
291					 * @returns {boolean}
292					 */
293					isActive: function (element, className, defaultActivation) {
294						var no = 'no-' + className;
295
296						while (element) {
297							var classList = element.classList;
298							if (classList.contains(className)) {
299								return true;
300							}
301							if (classList.contains(no)) {
302								return false;
303							}
304							element = element.parentElement;
305						}
306						return !!defaultActivation;
307					}
308				},
309
310				/**
311				 * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
312				 *
313				 * @namespace
314				 * @memberof Prism
315				 * @public
316				 */
317				languages: {
318					/**
319					 * The grammar for plain, unformatted text.
320					 */
321					plain: plainTextGrammar,
322					plaintext: plainTextGrammar,
323					text: plainTextGrammar,
324					txt: plainTextGrammar,
325
326					/**
327					 * Creates a deep copy of the language with the given id and appends the given tokens.
328					 *
329					 * If a token in `redef` also appears in the copied language, then the existing token in the copied language
330					 * will be overwritten at its original position.
331					 *
332					 * ## Best practices
333					 *
334					 * Since the position of overwriting tokens (token in `redef` that over

431 insert An object containing the key-value pairs to be inserted.
432					 * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
433					 * object to be modified.
434					 *
435					 * Defaults to `Prism.languages`.
436					 * @returns {Grammar} The new grammar object.
437					 * @public
438					 */
439					insertBefore: function (inside, before, insert, root) {
440						root = root || /** @type {any} */ (_.languages);
441						var grammar = root[inside];
442						/** @type {Grammar} */
443						var ret = {};
444
445						for (var token in grammar) {
446							if (grammar.hasOwnProperty(token)) {
447
448								if (token == before) {
449									for (var newToken in insert) {
450										if (insert.hasOwnProperty(newToken)) {
451											ret[newToken] = insert[newToken];
452										}
453									}
454								}
455
456								// Do not insert token which also occur in insert. See #1525
457								if (!insert.hasOwnProperty(token)) {
458									ret[token] = grammar[token];
459								}
460							}
461						}
462
463						var old = root[inside];
464						root[inside] = ret;
465
466						// Update references in other language definitions
467						_.languages.DFS(_.languages, function (key, value) {
468							if (value === old && key != inside) {
469								this[key] = ret;
470							}
471						});
472
473						return ret;
474					},
475
476					// Traverse a language definition with Depth First Search
477					DFS: function DFS(o, callback, type, visited) {
478						visited = visited || {};
479
480						var objId = _.util.objId;
481
482						for (var i in o) {
483							if (o.hasOwnProperty(i)) {
484								callback.call(o, i, o[i], type || i);
485
486								var property = o[i];
487								var propertyType = _.util.type(property);
488
489								if (propertyType === 'Object' && !visited[objId(property)]) {
490									visited[objId(property)] = true;
491									DFS(property, callback, null, visited);
492								} else if (propertyType === 'Array' && !visited[objId(property)]) {
493									visited[objId(property)] = true;
494									DFS(property, callback, i, visited);
495								}
496							}
497						}
498					}
499				},
500
501				plugins: {},
502
503				/**
504				 * This is the most high-level function in Prism’s API.
505				 * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
506				 * each one of them.
507				 *
508				 * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
509				 *
510				 * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
511				 * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
512				 * @memberof Prism
513				 * @public
514				 */
515				highlightAll: function (async, callback) {
516					_.highlightAllUnder(document, async, callback);
517				},
518
519				/**
520				 * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
521				 * {@link Prism.highlightElement} on each one of them.
522				 *
523				 * The following hooks will be run:
524				 * 1. `before-highlightall`
525				 * 2. `before-all-elements-highlight`
526				 * 3. All hooks of {@link Prism.highlightElement} for each element.
527				 *
528				 * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
529				 * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
530				 * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
531				 * @memberof Prism
532				 * @public
533				 */
534				highlightAllUnder: function (container, async, callback) {
535					var env = {
536						callback: callback,
537						container: container,
538						selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
539					};
540
541					_.hooks.run('before-highlightall', env);
542
543					env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));
544
545					_.hooks.run('before-all-elements-highlight', env);
546
547					for (var i = 0, element; (element = env.elements[i++]);) {
548						_.highlightElement(element, async === true, env.callback);
549					}
550				},
551
552				/**
553				 * Highlights the code inside a single element.
554				 *
555				 * The following hooks will be run:
556				 * 1. `before-sanity-check`
557				 * 2. `before-highlight`
558				 * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
559				 * 4. `before-insert`
560				 * 5. `after-highlight`
561				 * 6. `complete`
562				 *
563				 * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
564				 * the element's language.
565				 *
566				 * @param {Element} element The element containing the code.
567				 * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
568				 * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
569				 * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
570				 * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
571				 *
572				 * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
573				 * asynchronous highlighting to work. You can build your own bundle on the
574				 * [Download page](https://prismjs.com/download.html).
575				 * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
576				 * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
577				 * @memberof Prism
578				 * @public
579				 */
580				highlightElement: function (element, async, callback) {
581					// Find language
582					var language = _.util.getLanguage(element);
583					var grammar = _.languages[language];
584
585					// Set language on the element, if not present
586					_.util.setLanguage(element, language);
587
588					// Set language on the parent, for styling
589					var parent = element.parentElement;
590					if (parent && parent.nodeName.toLowerCase() === 'pre') {
591						_.util.setLanguage(parent, language);
592					}
593
594					var code = element.textContent;
595
596					var env = {
597						element: element,
598						language: language,
599						grammar: grammar,
600						code: code
601					};
602
603					function insertHighlightedCode(highlightedCode) {
604						env.highlightedCode = highlightedCode;
605
606						_.hooks.run('before-insert', env);
607
608						env.element.innerHTML = env.highlightedCode;
609
610						_.hooks.run('after-highlight', env);
611						_.hooks.run('complete', env);
612						callback && callback.call(env.element);
613					}
614
615					_.hooks.run('before-sanity-check', env);
616
617					// plugins may change/add the parent/element
618					parent = env.element.parentElement;
619					if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) {
620						parent.setAttribute('tabindex', '0');
621					}
622
623					if (!env.code) {
624						_.hooks.run('complete', env);
625						callback && callback.call(env.element);
626						return;
627					}
628
629					_.hooks.run('before-highlight', env);
630
631					if (!env.grammar) {
632						insertHighlightedCode(_.util.encode(env.code));
633						return;
634					}
635
636					if (async && _self.Worker) {
637						var worker = new Worker(_.filename);
638
639						worker.onmessage = function (evt) {
640							insertHighlightedCode(evt.data);
641						};
642
643						worker.postMessage(JSON.stringify({
644							language: env.language,
645							code: env.code,
646							immediateClose: true
647						}));
648					} else {
649						insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
650					}
651				},
652
653				/**

834			 * A token stream is an array of strings and {@link Token Token} objects.
835			 *
836			 * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process
837			 * them.
838			 *
839			 * 1. No adjacent strings.
840			 * 2. No empty strings.
841			 *
842			 *    The only exception here is the token stream that only contains the empty string and nothing else.
843			 *
844			 * @typedef {Array<string | Token>} TokenStream
845			 * @global
846			 * @public
847			 */
848
849			/**
850			 * Converts the given token or token stream to an HTML representation.
851			 *
852			 * The following hooks will be run:
853			 * 1. `wrap`: On each {@link Token}.
854			 *
855			 * @param {string | Token | TokenStream} o The token or token stream to be converted.
856			 * @param {string} language The name of current language.
857			 * @returns {string} The HTML representation of the token or token stream.
858			 * @memberof Token
859			 * @static
860			 */
861			Token.stringify = function stringify(o, language) {
862				if (typeof o == 'string') {
863					return o;
864				}
865				if (Array.isArray(o)) {
866					var s = '';
867					o.forEach(function (e) {
868						s += stringify(e, language);
869					});
870					return s;
871				}
872
873				var env = {
874					type: o.type,
875					content: stringify(o.content, language),
876					tag: 'span',
877					classes: ['token', o.type],
878					attributes: {},
879					language: language
880				};
881
882				var aliases = o.alias;
883				if (aliases) {
884					if (Array.isArray(aliases)) {
885						Array.prototype.push.apply(env.classes, aliases);
886					} else {
887						env.classes.push(aliases);
888					}
889				}
890
891				_.hooks.run('wrap', env);
892
893				var attributes = '';
894				for (var name in env.attributes) {
895					attributes += ' ' + name + '="' + (env.attributes[name] || '').replace(/"/g, '&quot;') + '"';
896				}
897
898				return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + attributes + '>' + env.content + '</' + env.tag + '>';
899			};
900
901			/**
902			 * @param {RegExp} pattern
903			 * @param {number} pos
904			 * @param {string} text
905			 * @param {boolean} lookbehind
906			 * @returns {RegExpExecArray | null}
907			 */
908			function matchPattern(pattern, pos, text, lookbehind) {
909				pattern.lastIndex = pos;
910				var match = pattern.exec(text);
911				if (match && lookbehind && match[1]) {
912					// change the match to remove the text matched by the Prism lookbehind group
913					var lookbehindLength = match[1].length;
914					match.index += lookbehindLength;
915					match[0] = match[0].slice(lookbehindLength);
916				}
917				return match;
918			}
919
920			/**
921			 * @param {string} text
922			 * @param {LinkedList<string | Token>} tokenList
923			 * @param {any} grammar
924			 * @param {LinkedListNode<string | Token>} startNode
925			 * @param {number} startPos
926			 * @param {RematchOptions} [rematch]
927			 * @returns {void}
928			 * @private
929			 *
930			 * @typedef RematchOptions
931			 * @property {string} cause
932			 * @property {number} reach
933			 */
934			function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
935				for (var token in grammar) {
936					if (!grammar.hasOwnProperty(token) || !grammar[token]) {
937						continue;
938					}
939
940					var patterns = grammar[token];
941					patterns = Array.isArray(patterns) ? patterns : [patterns];
942
943					for (var j = 0; j < patterns.length; ++j) {
944						if (rematch && rematch.cause == token + ',' + j) {
945							return;
946						}
947
948						var patternObj = patterns[j];
949						var inside = patternObj.inside;
950						var lookbehind = !!patternObj.lookbehind;
951						var greedy = !!patternObj.greedy;
952						var alias = patternObj.alias;
953
954						if (greedy && !patternObj.pattern.global) {
955							// Without the global flag, lastIndex won't work
956							var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
957							patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');
958						}
959
960						/** @type {RegExp} */
961						var pattern = patternObj.pattern || patternObj;
962
963						for ( // iterate the token list and keep track of the current token/string position
964							var currentNode = startNode.next, pos = startPos;
965							currentNode !== tokenList.tail;
966							pos += currentNode.value.length, currentNode = currentNode.next
967						) {
968
969							if (rematch && pos >= rematch.reach) {
970								break;
971							}
972
973							var str = currentNode.value;
974
975							if (tokenList.length > text.length) {
976								// Something went terribly wrong, ABORT, ABORT!
977								return;
978							}
979
980							if (str instanceof Token) {
981								continue;
982							}
983
984							var removeCount = 1; // this is the to parameter of removeBetween
985							var match;
986
987							if (greedy) {
988								match = matchPattern(pattern, pos, text, lookbehind);
989								if (!match || match.index >= text.length) {
990									break;
991								}
992
993								var from = match.index;
994								var to = match.index + match[0].length;
995								var p = pos;
996

997								// find the node that contains the match
998								p += currentNode.value.length;
999								while (from >= p) {
1000									currentNode = currentNode.next;
1001									p += currentNode.value.length;
1002								}
1003								// adjust pos (and p)
1004								p -= currentNode.value.length;
1005								pos = p;
1006
1007								// the current node is a Token, then the match starts inside another Token, which is invalid
1008								if (currentNode.value instanceof Token) {
1009									continue;
1010								}
1011
1012								// find the last node which is affected by this match
1013								for (
1014									var k = currentNode;
1015									k !== tokenList.tail && (p < to || typeof k.value === 'string');
1016									k = k.next
1017								) {
1018									removeCount++;
1019									p += k.value.length;
1020								}
1021								removeCount--;
1022
1023								// replace with the new match
1024								str = text.slice(pos, p);
1025								match.index -= pos;
1026							} else {
1027								match = matchPattern(pattern, 0, str, lookbehind);
1028								if (!match) {
1029									continue;
1030								}
1031							}
1032
1033							// eslint-disable-next-line no-redeclare
1034							var from = match.index;
1035							var matchStr = match[0];
1036							var before = str.slice(0, from);
1037							var after = str.slice(from + matchStr.length);
1038
1039							var reach = pos + str.length;
1040							if (rematch && reach > rematch.reach) {
1041								rematch.reach = reach;
1042							}
1043
1044							var removeFrom = currentNode.prev;
1045
1046							if (before) {
1047								removeFrom = addAfter(tokenList, removeFrom, before);
1048								pos += before.length;
1049							}
1050
1051							removeRange(tokenList, removeFrom, removeCount);
1052
1053							var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
1054							currentNode = addAfter(tokenList, removeFrom, wrapped);
1055
1056							if (after) {
1057								addAfter(tokenList, currentNode, after);
1058							}
1059
1060							if (removeCount > 1) {
1061								// at least one Token object was removed, so we have to do some rematching
1062								// this can only happen if the current pattern is greedy
1063
1064								/** @type {RematchOptions} */
1065								var nestedRematch = {
1066									cause: token + ',' + j,
1067									reach: reach
1068								};
1069								matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);
1070
1071								// the reach might have been extended because of the rematching
1072								if (rematch && nestedRematch.reach > rematch.reach) {
1073									rematch.reach = nestedRematch.reach;
1074								}
1075							}
1076						}
1077					}
1078				}
1079			}
1080
1081			/**
1082			 * @typedef LinkedListNode
1083			 * @property {T} value
1084			 * @property {LinkedListNode<T> | null} prev The previous node.
1085			 * @property {LinkedListNode<T> | null} next The next node.
1086			 * @template T
1087			 * @private
1088			 */
1089
1090			/**
1091			 * @template T
1092			 * @private
1093			 */
1094			function LinkedList() {
1095				/** @type {LinkedListNode<T>} */
1096				var head = { value: null, prev: null, next: null };
1097				/** @type {LinkedListNode<T>} */
1098				var tail = { value: null, prev: head, next: null };
1099				head.next = tail;
1100
1101				/** @type {LinkedListNode<T>} */
1102				this.head = head;
1103				/** @type {LinkedListNode<T>} */
1104				this.tail = tail;
1105				this.length = 0;
1106			}
1107
1108			/**
1109			 * Adds a new node with the given value to the list.
1110			 *
1111			 * @param {LinkedList<T>} list
1112			 * @param {LinkedListNode<T>} node
1113			 * @param {T} value
1114			 * @returns {LinkedListNode<T>} The added node.
1115			 * @template T
1116			 */
1117			function addAfter(list, node, value) {
1118				// assumes that node != list.tail && values.length >= 0
1119				var next = node.next;
1120
1121				var newNode = { value: value, prev: node, next: next };
1122				node.next = newNode;
1123				next.prev = newNode;
1124				list.length++;
1125
1126				return newNode;
1127			}
1128			/**
1129			 * Removes `count` nodes after the given node. The given node will not be removed.
1130			 *
1131			 * @param {LinkedList<T>} list
1132			 * @param {LinkedListNode<T>} node
1133			 * @param {number} count
1134			 * @template T
1135			 */
1136			function removeRange(list, node, count) {
1137				var next = node.next;
1138				for (var i = 0; i < count && next !== list.tail; i++) {
1139					next = next.next;
1140				}
1141				node.next = next;
1142				next.prev = node;
1143				list.length -= i;
1144			}
1145			/**
1146			 * @param {LinkedList<T>} list
1147			 * @returns {T[]}
1148			 * @template T
1149			 */
1150			function toArray(list) {
1151				var array = [];
1152				var node = list.head.next;
1153				while (node !== list.tail) {
1154					array.push(node.value);
1155					node = node.next;
1156				}
1157				return array;
1158			}
1159
1160
1161			if (!_self.document) {
1162				if (!_self.addEventListener) {
1163					// in Node.js
1164					return _;
1165				}
1166
1167				if (!_.disableWorkerMessageHandler) {
1168					// In worker
1169					_self.addEventListener('message', function (evt) {
1170						var message = JSON.parse(evt.data);
1171						var lang = message.language;
1172						var code = message.code;
1173						var immediateClose = message.immediateClose;
1174
1175						_self.postMessage(_.highlight(code, _.languages[lang], lang));
1176						if (immediateClose) {
1177							_self.close();
1178						}
1179					}, false);
1180				}
1181
1182				return _;
1183			}
1184
1185			// Get current script and highlight
1186			var script = _.util.currentScript();
1187
1188			if (script) {
1189				_.filename = script.src;
1190
1191				if (script.hasAttribute('data-manual')) {
1192					_.manual = true;
1193				}
1194			}
1195
1196			function highlightAutomaticallyCallback() {
1197				if (!_.manual) {
1198					_.highlightAll();
1199				}
1200			}
1201
1202			if (!_.manual) {
1203				// If the document state is "loading", then we'll use DOMContentLoaded.
1204				// If the document state is "interactive" and the prism.js script is deferred, then we'll also use the
1205				// DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they
1206				// might take longer one animation frame to execute which can create a race condition where only some plugins have
1207				// been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded.
1208				// See https://github.com/PrismJS/prism/issues/2102
1209				var readyState = document.readyState;
1210				if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
1211					document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
1212				} else {
1213					if (window.requestAnimationFrame) {
1214						window.requestAnimationFrame(highlightAutomaticallyCallback);
1215					} else {
1216						window.setTimeout(highlightAutomaticallyCallback, 16);
1217					}
1218				}
1219			}
1220
1221			return _;
1222
1223		}(_self));
1224
1225		if (module.exports) {
1226			module.exports = Prism;
1227		}
1228
1229		// hack for components to work correctly in node.js
1230		if (typeof commonjsGlobal !== 'undefined') {
1231			commonjsGlobal.Prism = Prism;
1232		}
1233
1234		// some additional documentation/types
1235
1236		/**

1393				includedCdataInside['language-' + lang] = {
1394					pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
1395					lookbehind: true,
1396					inside: Prism.languages[lang]
1397				};
1398				includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
1399
1400				var inside = {
1401					'included-cdata': {
1402						pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
1403						inside: includedCdataInside
1404					}
1405				};
1406				inside['language-' + lang] = {
1407					pattern: /[\s\S]+/,
1408					inside: Prism.languages[lang]
1409				};
1410
1411				var def = {};
1412				def[tagName] = {
1413					pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () { return tagName; }), 'i'),
1414					lookbehind: true,
1415					greedy: true,
1416					inside: inside
1417				};
1418
1419				Prism.languages.insertBefore('markup', 'cdata', def);
1420			}
1421		});
1422		Object.defineProperty(Prism.languages.markup.tag, 'addAttribute', {
1423			/**
1424			 * Adds an pattern to highlight languages embedded in HTML attributes.
1425			 *
1426			 * An example of an inlined language is CSS with `style` attributes.
1427			 *
1428			 * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
1429			 * case insensitive.
1430			 * @param {string} lang The language key.
1431			 * @example
1432			 * addAttribute('style', 'css');
1433			 */
1434			value: function (attrName, lang) {
1435				Prism.languages.markup.tag.inside['special-attr'].push({
1436					pattern: RegExp(
1437						/(^|["'\s])/.source + '(?:' + attrName + ')' + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
1438						'i'
1439					),
1440					lookbehind: true,
1441					inside: {
1442						'attr-name': /^[^\s=]+/,
1443						'attr-value': {
1444							pattern: /=[\s\S]+/,
1445							inside: {
1446								'value': {
1447									pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
1448									lookbehind: true,
1449									alias: [lang, 'language-' + lang],
1450									inside: Prism.languages[lang]
1451								},
1452								'punctuation': [
1453									{
1454										pattern: /^=/,
1455										alias: 'attr-equals'
1456									},
1457									/"|'/
1458								]
1459							}
1460						}
1461					}
1462				});
1463			}
1464		});
1465
1466		Prism.languages.html = Prism.languages.markup;
1467		Prism.languages.mathml = Prism.languages.markup;
1468		Prism.languages.svg = Prism.languages.markup;
1469
1470		Prism.languages.xml = Prism.languages.extend('markup', {});
1471		Prism.languages.ssml = Prism.languages.xml;
1472		Prism.languages.atom = Prism.languages.xml;
1473		Prism.languages.rss = Prism.languages.xml;
1474
1475
1476		/* **********************************************
1477		     Begin prism-css.js
1478		********************************************** */
1479
1480		(function (Prism) {
1481
1482			var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
1483
1484			Prism.languages.css = {
1485				'comment': /\/\*[\s\S]*?\*\//,
1486				'atrule': {
1487					pattern: RegExp('@[\\w-](?:' + /[^;{\s"']|\s+(?!\s)/.source + '|' + string.source + ')*?' + /(?:;|(?=\s*\{))/.source),
1488					inside: {
1489						'rule': /^@[\w-]+/,
1490						'selector-function-argument': {
1491							pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
1492							lookbehind: true,
1493							alias: 'selector'
1494						},
1495						'keyword': {
1496							pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
1497							lookbehind: true
1498						}
1499						// See rest below
1500					}
1501				},
1502				'url': {
1503					// https://drafts.csswg.org/css-values-3/#urls
1504					pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'),
1505					greedy: true,
1506					inside: {
1507						'function': /^url/i,
1508						'punctuation': /^\(|\)$/,
1509						'string': {
1510							pattern: RegExp('^' + string.source + '$'),
1511							alias: 'url'
1512						}
1513					}
1514				},
1515				'selector': {
1516					pattern: RegExp('(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'),
1517					lookbehind: true
1518				},
1519				'string': {
1520					pattern: string,
1521					greedy: true
1522				},
1523				'property': {
1524					pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
1525					lookbehind: true
1526				},
1527				'important': /!important\b/i,
1528				'function': {
1529					pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
1530					lookbehind: true
1531				},
1532				'punctuation': /[(){};:,]/
1533			};
1534
1535			Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
1536
1537			var markup = Prism.languages.markup;
1538			if (markup) {
1539				markup.tag.addInlined('style', 'css');
1540				markup.tag.addAttribute('style', 'css');
1541			}
1542
1543		}(Prism));
1544
1545
1546		/* **********************************************
1547		     Begin prism-clike.js
1548		********************************************** */
1549
1550		Prism.languages.clike = {
1551			'comment': [
1552				{
1553					pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
1554					lookbehind: true,
1555					greedy: true
1556				},
1557				{
1558					pattern: /(^|[^\\:])\/\/.*/,
1559					lookbehind: true,
1560					greedy: true
1561				}
1562			],
1563			'string': {
1564				pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
1565				greedy: true
1566			},
1567			'class-name': {
1568				pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
1569				lookbehind: true,
1570				inside: {
1571					'punctuation': /[.\\]/
1572				}
1573			},
1574			'keyword': /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
1575			'boolean': /\b(?:false|true)\b/,
1576			'function': /\b\w+(?=\()/,
1577			'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
1578			'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
1579			'punctuation': /[{}[\];(),.:]/
1580		};
1581
1582
1583		/* **********************************************
1584		     Begin prism-javascript.js
1585		********************************************** */
1586
1587		Prism.languages.javascript = Prism.languages.extend('clike', {
1588			'class-name': [
1589				Prism.languages.clike['class-name'],
1590				{
1591					pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
1592					lookbehind: true
1593				}
1594			],
1595			'keyword': [
1596				{
1597					pattern: /((?:^|\})\s*)catch\b/,
1598					lookbehind: true
1599				},
1600				{
1601					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/,
1602					lookbehind: true
1603				},
1604			],
1605			// Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
1606			'function': /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
1607			'number': {
1608				pattern: RegExp(
1609					/(^|[^\w$])/.source +
1610					'(?:' +
1611					(
1612						// constant
1613						/NaN|Infinity/.source +
1614						'|' +
1615						// binary integer
1616						/0[bB][01]+(?:_[01]+)*n?/.source +
1617						'|' +
1618						// octal integer
1619						/0[oO][0-7]+(?:_[0-7]+)*n?/.source +
1620						'|' +
1621						// hexadecimal integer
1622						/0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source +
1623						'|' +
1624						// decimal bigint
1625						/\d+(?:_\d+)*n/.source +
1626						'|' +
1627						// decimal number (integer or float) but no bigint
1628						/(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source
1629					) +
1630					')' +
1631					/(?![\w$])/.source
1632				),
1633				lookbehind: true
1634			},
1635			'operator': /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
1636		});
1637
1638		Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
1639
1640		Prism.languages.insertBefore('javascript', 'keyword', {
1641			'regex': {
1642				pattern: RegExp(
1643					// lookbehind
1644					// eslint-disable-next-line regexp/no-dupe-characters-character-class
1645					/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source +
1646					// Regex pattern:
1647					// There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
1648					// classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
1649					// with the only syntax, so we have to define 2 different regex patterns.
1650					/\//.source +
1651					'(?:' +
1652					/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source +
1653					'|' +
1654					// `v` flag syntax. This supports 3 levels of nested character classes.
1655					/(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source +
1656					')' +
1657					// lookahead
1658					/(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
1659				),
1660				lookbehind: true,
1661				greedy: true,
1662				inside: {
1663					'regex-source': {
1664						pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
1665						lookbehind: true,
1666						alias: 'language-regex',
1667						inside: Prism.languages.regex
1668					},
1669					'regex-delimiter': /^\/|\/$/,
1670					'regex-flags': /^[a-z]+$/,
1671				}
1672			},
1673			// This must be declared before keyword because we use "function" inside the look-forward
1674			'function-variable': {
1675				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*=>))/,
1676				alias: 'function'
1677			},
1678			'parameter': [
1679				{
1680					pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
1681					lookbehind: true,
1682					inside: Prism.languages.javascript
1683				},
1684				{
1685					pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
1686					lookbehind: true,
1687					inside: Prism.languages.javascript
1688				},
1689				{
1690					pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
1691					lookbehind: true,
1692					inside: Prism.languages.javascript
1693				},
1694				{
1695					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*\{)/,
1696					lookbehind: true,
1697					inside: Prism.languages.javascript
1698				}
1699			],
1700			'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/
1701		});
1702
1703		Prism.languages.insertBefore('javascript', 'string', {
1704			'hashbang': {
1705				pattern: /^#!.*/,
1706				greedy: true,
1707				alias: 'comment'
1708			},
1709			'template-string': {
1710				pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
1711				greedy: true,
1712				inside: {
1713					'template-punctuation': {
1714						pattern: /^`|`$/,
1715						alias: 'string'
1716					},
1717					'interpolation': {
1718						pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
1719						lookbehind: true,
1720						inside: {
1721							'interpolation-punctuation': {
1722								pattern: /^\$\{|\}$/,
1723								alias: 'punctuation'
1724							},
1725							rest: Prism.languages.javascript
1726						}
1727					},
1728					'string': /[\s\S]+/
1729				}
1730			},
1731			'string-property': {
1732				pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
1733				lookbehind: true,
1734				greedy: true,
1735				alias: 'property'
1736			}
1737		});
1738
1739		Prism.languages.insertBefore('javascript', 'operator', {
1740			'literal-property': {
1741				pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
1742				lookbehind: true,
1743				alias: 'property'
1744			},
1745		});
1746
1747		if (Prism.languages.markup) {
1748			Prism.languages.markup.tag.addInlined('script', 'javascript');
1749
1750			// add attribute support for all DOM events.
1751			// https://developer.mozilla.org/en-US/docs/Web/Events#Standard_events
1752			Prism.languages.markup.tag.addAttribute(
1753				/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,
1754				'javascript'
1755			);
1756		}
1757
1758		Prism.languages.js = Prism.languages.javascript;
1759
1760
1761		/* **********************************************
1762		     Begin prism-file-highlight.js
1763		********************************************** */
1764
1765		(function () {
1766
1767			if (typeof Prism === 'undefined' || typeof document === 'undefined') {
1768				return;
1769			}
1770
1771			// https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill
1772			if (!Element.prototype.matches) {
1773				Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
1774			}
1775
1776			var LOADING_MESSAGE = 'Loading…';
1777			var FAILURE_MESSAGE = function (status, message) {
1778				return '✖ Error ' + status + ' while fetching file: ' + message;
1779			};
1780			var FAILURE_EMPTY_MESSAGE = '✖ Error: File does not exist or is empty';
1781
1782			var EXTENSIONS = {
1783				'js': 'javascript',
1784				'py': 'python',
1785				'rb': 'ruby',
1786				'ps1': 'powershell',
1787				'psm1': 'powershell',
1788				'sh': 'bash',
1789				'bat': 'batch',
1790				'h': 'c',
1791				'tex': 'latex'
1792			};
1793
1794			var STATUS_ATTR = 'data-src-status';
1795			var STATUS_LOADING = 'loading';
1796			var STATUS_LOADED = 'loaded';
1797			var STATUS_FAILED = 'failed';
1798
1799			var SELECTOR = 'pre[data-src]:not([' + STATUS_ATTR + '="' + STATUS_LOADED + '"])'
1800				+ ':not([' + STATUS_ATTR + '="' + STATUS_LOADING + '"])';
1801
1802			/**
1803			 * Loads the given file.
1804			 *
1805			 * @param {string} src The URL or path of the source file to load.
1806			 * @param {(result: string) => void} success
1807			 * @param {(reason: string) => void} error
1808			 */
1809			function loadFile(src, success, error) {
1810				var xhr = new XMLHttpRequest();
1811				xhr.open('GET', src, true);
1812				xhr.onreadystatechange = function () {
1813					if (xhr.readyState == 4) {
1814						if (xhr.status < 400 && xhr.responseText) {
1815							success(xhr.responseText);
1816						} else {
1817							if (xhr.status >= 400) {
1818								error(FAILURE_MESSAGE(xhr.status, xhr.statusText));
1819							} else {
1820								error(FAILURE_EMPTY_MESSAGE);
1821							}
1822						}
1823					}
1824				};
1825				xhr.send(null);
1826			}
1827
1828			/**
1829			 * Parses the given range.
1830			 *
1831			 * This returns a range with inclusive ends.
1832			 *
1833			 * @param {string | null | undefined} range
1834			 * @returns {[number, number | undefined] | undefined}
1835			 */
1836			function parseRange(range) {
1837				var m = /^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec(range || '');
1838				if (m) {
1839					var start = Number(m[1]);
1840					var comma = m[2];
1841					var end = m[3];
1842
1843					if (!comma) {
1844						return [start, start];
1845					}
1846					if (!end) {
1847						return [start, undefined];
1848					}
1849					return [start, Number(end)];
1850				}
1851				return undefined;
1852			}
1853
1854			Prism.hooks.add('before-highlightall', function (env) {
1855				env.selector += ', ' + SELECTOR;
1856			});
1857
1858			Prism.hooks.add('before-sanity-check', function (env) {
1859				var pre = /** @type {HTMLPreElement} */ (env.element);
1860				if (pre.matches(SELECTOR)) {
1861					env.code = ''; // fast-path the whole thing and go to complete
1862
1863					pre.setAttribute(STATUS_ATTR, STATUS_LOADING); // mark as loading
1864
1865					// add code element with loading message
1866					var code = pre.appendChild(document.createElement('CODE'));
1867					code.textContent = LOADING_MESSAGE;
1868
1869					var src = pre.getAttribute('data-src');
1870
1871					var language = env.language;
1872					if (language === 'none') {
1873						// the language might be 'none' because there is no language set;
1874						// in this case, we want to use the extension as the language
1875						var extension = (/\.(\w+)$/.exec(src) || [, 'none'])[1];
1876						language = EXTENSIONS[extension] || extension;
1877					}
1878
1879					// set language classes
1880					Prism.util.setLanguage(code, language);
1881					Prism.util.setLanguage(pre, language);
1882
1883					// preload the language
1884					var autoloader = Prism.plugins.autoloader;
1885					if (autoloader) {
1886						autoloader.loadLanguages(language);
1887					}
1888
1889					// load file
1890					loadFile(
1891						src,
1892						function (text) {
1893							// mark as loaded
1894							pre.setAttribute(STATUS_ATTR, STATUS_LOADED);
1895
1896							// handle data-range
1897							var range = parseRange(pre.getAttribute('data-range'));
1898							if (range) {
1899								var lines = text.split(/\r\n?|\n/g);
1900
1901								// the range is one-based and inclusive on both ends
1902								var start = range[0];
1903								var end = range[1] == null ? lines.length : range[1];
1904
1905								if (start < 0) { start += lines.length; }
1906								start = Math.max(0, Math.min(start - 1, lines.length));
1907								if (end < 0) { end += lines.length; }
1908								end = Math.max(0, Math.min(end, lines.length));
1909
1910								text = lines.slice(start, end).join('\n');
1911
1912								// add data-start for line numbers
1913								if (!pre.hasAttribute('data-start')) {
1914									pre.setAttribute('data-start', String(start + 1));
1915								}
1916							}
1917
1918							// highlight code
1919							code.textContent = text;
1920							Prism.highlightElement(code);
1921						},
1922						function (error) {
1923							// mark as failed
1924							pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
1925
1926							code.textContent = error;
1927						}
1928					);
1929				}
1930			});
1931
1932			Prism.plugins.fileHighlight = {
1933				/**
1934				 * Executes the File Highlight plugin for all matching `pre` elements under the given container.
1935				 *
1936				 * Note: Elements which are already loaded or currently loading will not be touched by this method.
1937				 *
1938				 * @param {ParentNode} [container=document]
1939				 */
1940				highlight: function highlight(container) {
1941					var elements = (container || document).querySelectorAll(SELECTOR);
1942
1943					for (var i = 0, element; (element = elements[i++]);) {
1944						Prism.highlightElement(element);
1945					}
1946				}
1947			};
1948
1949			var logged = false;

1950			/** @deprecated Use `Prism.plugins.fileHighlight.highlight` instead. */
1951			Prism.fileHighlight = function () {
1952				if (!logged) {
1953					console.warn('Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead.');
1954					logged = true;
1955				}
1956				Prism.plugins.fileHighlight.highlight.apply(this, arguments);
1957			};
1958
1959		}()); 
1960	} (prism));
1961	return prism.exports;
1962}
1963
1964var prismExports = requirePrism();
1965var Prism$1 = /*@__PURE__*/getDefaultExportFromCjs(prismExports);
1966
1967Prism$1.languages.clike = {
1968	'comment': [
1969		{
1970			pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
1971			lookbehind: true,
1972			greedy: true
1973		},
1974		{
1975			pattern: /(^|[^\\:])\/\/.*/,
1976			lookbehind: true,
1977			greedy: true
1978		}
1979	],
1980	'string': {
1981		pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
1982		greedy: true
1983	},
1984	'class-name': {
1985		pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
1986		lookbehind: true,
1987		inside: {
1988			'punctuation': /[.\\]/
1989		}
1990	},
1991	'keyword': /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
1992	'boolean': /\b(?:false|true)\b/,
1993	'function': /\b\w+(?=\()/,
1994	'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
1995	'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
1996	'punctuation': /[{}[\];(),.:]/
1997};
1998
1999Prism$1.languages.markup = {
2000	'comment': {
2001		pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
2002		greedy: true
2003	},
2004	'prolog': {
2005		pattern: /<\?[\s\S]+?\?>/,
2006		greedy: true
2007	},
2008	'doctype': {
2009		// https://www.w3.org/TR/xml/#NT-doctypedecl
2010		pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
2011		greedy: true,
2012		inside: {
2013			'internal-subset': {
2014				pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
2015				lookbehind: true,
2016				greedy: true,
2017				inside: null // see below
2018			},
2019			'string': {
2020				pattern: /"[^"]*"|'[^']*'/,
2021				greedy: true
2022			},
2023			'punctuation': /^<!|>$|[[\]]/,
2024			'doctype-tag': /^DOCTYPE/i,
2025			'name': /[^\s<>'"]+/
2026		}
2027	},
2028	'cdata': {
2029		pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
2030		greedy: true
2031	},
2032	'tag': {
2033		pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
2034		greedy: true,
2035		inside: {
2036			'tag': {
2037				pattern: /^<\/?[^\s>\/]+/,
2038				inside: {
2039					'punctuation': /^<\/?/,
2040					'namespace': /^[^\s>\/:]+:/
2041				}
2042			},
2043			'special-attr': [],
2044			'attr-value': {
2045				pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
2046				inside: {
2047					'punctuation': [
2048						{
2049							pattern: /^=/,
2050							alias: 'attr-equals'
2051						},
2052						{
2053							pattern: /^(\s*)["']|["']$/,
2054							lookbehind: true
2055						}
2056					]
2057				}
2058			},
2059			'punctuation': /\/?>/,
2060			'attr-name': {
2061				pattern: /[^\s>\/]+/,
2062				inside: {
2063					'namespace': /^[^\s>\/:]+:/
2064				}
2065			}
2066
2067		}
2068	},
2069	'entity': [
2070		{
2071			pattern: /&[\da-z]{1,8};/i,
2072			alias: 'named-entity'
2073		},
2074		/&#x?[\da-f]{1,8};/i
2075	]
2076};
2077
2078Prism$1.languages.markup['tag'].inside['attr-value'].inside['entity'] =
2079	Prism$1.languages.markup['entity'];
2080Prism$1.languages.markup['doctype'].inside['internal-subset'].inside = Prism$1.languages.markup;
2081
2082// Plugin to make entity title show the real entity, idea by Roman Komarov
2083Prism$1.hooks.add('wrap', function (env) {
2084
2085	if (env.type === 'entity') {
2086		env.attributes['title'] = env.content.replace(/&amp;/, '&');
2087	}
2088});
2089
2090Object.defineProperty(Prism$1.languages.markup.tag, 'addInlined', {
2091	/**
2092	 * Adds an inlined language to markup.
2093	 *
2094	 * An example of an inlined language is CSS with `<style>` tags.
2095	 *
2096	 * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
2097	 * case insensitive.
2098	 * @param {string} lang The language key.
2099	 * @example
2100	 * addInlined('style', 'css');
2101	 */
2102	value: function addInlined(tagName, lang) {
2103		var includedCdataInside = {};
2104		includedCdataInside['language-' + lang] = {
2105			pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
2106			lookbehind: true,
2107			inside: Prism$1.languages[lang]
2108		};
2109		includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
2110
2111		var inside = {
2112			'included-cdata': {
2113				pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
2114				inside: includedCdataInside
2115			}
2116		};

2117		inside['language-' + lang] = {
2118			pattern: /[\s\S]+/,
2119			inside: Prism$1.languages[lang]
2120		};
2121
2122		var def = {};
2123		def[tagName] = {
2124			pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () { return tagName; }), 'i'),
2125			lookbehind: true,
2126			greedy: true,
2127			inside: inside
2128		};
2129
2130		Prism$1.languages.insertBefore('markup', 'cdata', def);
2131	}
2132});
2133Object.defineProperty(Prism$1.languages.markup.tag, 'addAttribute', {
2134	/**
2135	 * Adds an pattern to highlight languages embedded in HTML attributes.
2136	 *
2137	 * An example of an inlined language is CSS with `style` attributes.
2138	 *
2139	 * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
2140	 * case insensitive.
2141	 * @param {string} lang The language key.
2142	 * @example
2143	 * addAttribute('style', 'css');
2144	 */
2145	value: function (attrName, lang) {
2146		Prism$1.languages.markup.tag.inside['special-attr'].push({
2147			pattern: RegExp(
2148				/(^|["'\s])/.source + '(?:' + attrName + ')' + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
2149				'i'
2150			),
2151			lookbehind: true,
2152			inside: {
2153				'attr-name': /^[^\s=]+/,
2154				'attr-value': {
2155					pattern: /=[\s\S]+/,
2156					inside: {
2157						'value': {
2158							pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
2159							lookbehind: true,
2160							alias: [lang, 'language-' + lang],
2161							inside: Prism$1.languages[lang]
2162						},
2163						'punctuation': [
2164							{
2165								pattern: /^=/,
2166								alias: 'attr-equals'
2167							},
2168							/"|'/
2169						]
2170					}
2171				}
2172			}
2173		});
2174	}
2175});
2176
2177Prism$1.languages.html = Prism$1.languages.markup;
2178Prism$1.languages.mathml = Prism$1.languages.markup;
2179Prism$1.languages.svg = Prism$1.languages.markup;
2180
2181Prism$1.languages.xml = Prism$1.languages.extend('markup', {});
2182Prism$1.languages.ssml = Prism$1.languages.xml;
2183Prism$1.languages.atom = Prism$1.languages.xml;
2184Prism$1.languages.rss = Prism$1.languages.xml;
2185
2186(function (Prism) {
2187
2188	/**
2189	 * Returns the placeholder for the given language id and index.
2190	 *
2191	 * @param {string} language
2192	 * @param {string|number} index
2193	 * @returns {string}
2194	 */
2195	function getPlaceholder(language, index) {
2196		return '___' + language.toUpperCase() + index + '___';
2197	}
2198
2199	Object.defineProperties(Prism.languages['markup-templating'] = {}, {
2200		buildPlaceholders: {
2201			/**
2202			 * Tokenize all inline templating expressions matching `placeholderPattern`.
2203			 *
2204			 * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
2205			 * `true` will be replaced.
2206			 *
2207			 * @param {object} env The environment of the `before-tokenize` hook.
2208			 * @param {string} language The language id.
2209			 * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
2210			 * @param {(match: string) => boolean} [replaceFilter]
2211			 */
2212			value: function (env, language, placeholderPattern, replaceFilter) {
2213				if (env.language !== language) {
2214					return;
2215				}
2216
2217				var tokenStack = env.tokenStack = [];
2218
2219				env.code = env.code.replace(placeholderPattern, function (match) {
2220					if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
2221						return match;
2222					}
2223					var i = tokenStack.length;
2224					var placeholder;
2225
2226					// Check for existing strings
2227					while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {
2228						++i;
2229					}
2230
2231					// Create a sparse array
2232					tokenStack[i] = match;
2233
2234					return placeholder;
2235				});
2236
2237				// Switch the grammar to markup
2238				env.grammar = Prism.languages.markup;
2239			}
2240		},
2241		tokenizePlaceholders: {
2242			/**
2243			 * Replace placeholders with proper tokens after tokenizing.
2244			 *
2245			 * @param {object} env The environment of the `after-tokenize` hook.
2246			 * @param {string} language The language id.
2247			 */
2248			value: function (env, language) {
2249				if (env.language !== language || !env.tokenStack) {
2250					return;
2251				}
2252
2253				// Switch the grammar back
2254				env.grammar = Prism.languages[language];
2255
2256				var j = 0;
2257				var keys = Object.keys(env.tokenStack);
2258
2259				function walkTokens(tokens) {
2260					for (var i = 0; i < tokens.length; i++) {
2261						// all placeholders are replaced already
2262						if (j >= keys.length) {
2263							break;
2264						}
2265
2266						var token = tokens[i];
2267						if (typeof token === 'string' || (token.content && typeof token.content === 'string')) {
2268							var k = keys[j];
2269							var t = env.tokenStack[k];
2270							var s = typeof token === 'string' ? token : token.content;
2271							var placeholder = getPlaceholder(language, k);
2272
2273							var index = s.indexOf(placeholder);
2274							if (index > -1) {
2275								++j;
2276
2277								var before = s.substring(0, index);
2278								var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);
2279								var after = s.substring(index + placeholder.length);
2280
2281								var replacement = [];
2282								if (before) {
2283									replacement.push.apply(replacement, walkTokens([before]));
2284								}
2285								replacement.push(middle);
2286								if (after) {
2287									replacement.push.apply(replacement, walkTokens([after]));
2288								}
2289
2290								if (typeof token === 'string') {
2291									tokens.splice.apply(tokens, [i, 1].concat(replacement));
2292								} else {
2293									token.content = replacement;
2294								}
2295							}
2296						} else if (token.content /* && typeof token.content !== 'string' */) {
2297							walkTokens(token.content);
2298						}
2299					}
2300
2301					return tokens;
2302				}
2303
2304				walkTokens(env.tokens);
2305			}
2306		}
2307	});
2308
2309}(Prism$1));
2310
2311var prismRuby = {};
2312
2313var hasRequiredPrismRuby;
2314
2315function requirePrismRuby () {
2316	if (hasRequiredPrismRuby) return prismRuby;
2317	hasRequiredPrismRuby = 1;
2318	(function (Prism) {
2319		Prism.languages.ruby = Prism.languages.extend('clike', {
2320			'comment': {
2321				pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
2322				greedy: true
2323			},
2324			'class-name': {
2325				pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
2326				lookbehind: true,
2327				inside: {
2328					'punctuation': /[.\\]/
2329				}
2330			},
2331			'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/,
2332			'operator': /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
2333			'punctuation': /[(){}[\].,;]/,
2334		});
2335
2336		Prism.languages.insertBefore('ruby', 'operator', {
2337			'double-colon': {
2338				pattern: /::/,
2339				alias: 'punctuation'
2340			},
2341		});
2342
2343		var interpolation = {
2344			pattern: /((?:^|[^\\])(?:\\{2}

2540				alias: 'important'
2541			},
2542			'comment': comment,
2543			'variable': /\$+(?:\w+\b|(?=\{))/,
2544			'package': {
2545				pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
2546				lookbehind: true,
2547				inside: {
2548					'punctuation': /\\/
2549				}
2550			},
2551			'class-name-definition': {
2552				pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
2553				lookbehind: true,
2554				alias: 'class-name'
2555			},
2556			'function-definition': {
2557				pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
2558				lookbehind: true,
2559				alias: 'function'
2560			},
2561			'keyword': [
2562				{
2563					pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
2564					alias: 'type-casting',
2565					greedy: true,
2566					lookbehind: true
2567				},
2568				{
2569					pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
2570					alias: 'type-hint',
2571					greedy: true,
2572					lookbehind: true
2573				},
2574				{
2575					pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i,
2576					alias: 'return-type',
2577					greedy: true,
2578					lookbehind: true
2579				},
2580				{
2581					pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
2582					alias: 'type-declaration',
2583					greedy: true
2584				},
2585				{
2586					pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
2587					alias: 'type-declaration',
2588					greedy: true,
2589					lookbehind: true
2590				},
2591				{
2592					pattern: /\b(?:parent|self|static)(?=\s*::)/i,
2593					alias: 'static-context',
2594					greedy: true
2595				},
2596				{
2597					// yield from
2598					pattern: /(\byield\s+)from\b/i,
2599					lookbehind: true
2600				},
2601				// `class` is always a keyword unlike other keywords
2602				/\bclass\b/i,
2603				{
2604					// https://www.php.net/manual/en/reserved.keywords.php
2605					//
2606					// keywords cannot be preceded by "->"
2607					// the complex lookbehind means `(?<!(?:->|::)\s*)`
2608					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,
2609					lookbehind: true
2610				}
2611			],
2612			'argument-name': {
2613				pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
2614				lookbehind: true
2615			},
2616			'class-name': [
2617				{
2618					pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
2619					greedy: true,
2620					lookbehind: true
2621				},
2622				{
2623					pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
2624					greedy: true,
2625					lookbehind: true
2626				},
2627				{
2628					pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
2629					greedy: true
2630				},
2631				{
2632					pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
2633					alias: 'class-name-fully-qualified',
2634					greedy: true,
2635					lookbehind: true,
2636					inside: {
2637						'punctuation': /\\/
2638					}
2639				},
2640				{
2641					pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
2642					alias: 'class-name-fully-qualified',
2643					greedy: true,
2644					inside: {
2645						'punctuation': /\\/
2646					}
2647				},
2648				{
2649					pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
2650					alias: 'class-name-fully-qualified',
2651					greedy: true,
2652					lookbehind: true,
2653					inside: {
2654						'punctuation': /\\/
2655					}
2656				},
2657				{
2658					pattern: /\b[a-z_]\w*(?=\s*\$)/i,
2659					alias: 'type-declaration',
2660					greedy: true
2661				},
2662				{
2663					pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
2664					alias: ['class-name-fully-qualified', 'type-declaration'],
2665					greedy: true,
2666					inside: {
2667						'punctuation': /\\/
2668					}
2669				},
2670				{
2671					pattern: /\b[a-z_]\w*(?=\s*::)/i,
2672					alias: 'static-context',
2673					greedy: true
2674				},
2675				{
2676					pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
2677					alias: ['class-name-fully-qualified', 'static-context'],
2678					greedy: true,
2679					inside: {
2680						'punctuation': /\\/
2681					}
2682				},
2683				{
2684					pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
2685					alias: 'type-hint',
2686					greedy: true,
2687					lookbehind: true
2688				},
2689				{
2690					pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
2691					alias: ['class-name-fully-qualified', 'type-hint'],
2692					greedy: true,
2693					lookbehind: true,
2694					inside: {
2695						'punctuation': /\\/
2696					}
2697				},
2698				{
2699					pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
2700					alias: 'return-type',
2701					greedy: true,
2702					lookbehind: true
2703				},
2704				{
2705					pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
2706					alias: ['class-name-fully-qualified', 'return-type'],
2707					greedy: true,
2708					lookbehind: true,
2709					inside: {
2710						'punctuation': /\\/
2711					}
2712				}
2713			],
2714			'constant': constant,
2715			'function': {
2716				pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
2717				lookbehind: true,
2718				inside: {
2719					'punctuation': /\\/
2720				}
2721			},
2722			'property': {
2723				pattern: /(->\s*)\w+/,
2724				lookbehind: true
2725			},
2726			'number': number,
2727			'operator': operator,
2728			'punctuation': punctuation
2729		};
2730
2731		var string_interpolation = {
2732			pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
2733			lookbehind: true,
2734			inside: Prism.languages.php
2735		};
2736
2737		var string = [
2738			{
2739				pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
2740				alias: 'nowdoc-string',
2741				greedy: true,
2742				inside: {
2743					'delimiter': {
2744						pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
2745						alias: 'symbol',
2746						inside: {
2747							'punctuation': /^<<<'?|[';]$/
2748						}
2749					}
2750				}
2751			},
2752			{
2753				pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
2754				alias: 'heredoc-string',
2755				greedy: true,
2756				inside: {
2757					'delimiter': {
2758						pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
2759						alias: 'symbol',
2760						inside: {
2761							'punctuation': /^<<<"?|[";]$/
2762						}
2763					},
2764					'interpolation': string_interpolation
2765				}
2766			},
2767			{
2768				pattern: /`(?:\\[\s\S]|[^\\`])*`/,
2769				alias: 'backtick-quoted-string',
2770				greedy: true
2771			},
2772			{
2773				pattern: /'(?:\\[\s\S]|[^\\'])*'/,
2774				alias: 'single-quoted-string',
2775				greedy: true
2776			},
2777			{
2778				pattern: /"(?:\\[\s\S]|[^\\"])*"/,
2779				alias: 'double-quoted-string',
2780				greedy: true,
2781				inside: {
2782					'interpolation': string_interpolation
2783				}
2784			}
2785		];
2786
2787		Prism.languages.insertBefore('php', 'variable', {
2788			'string': string,
2789			'attribute': {
2790				pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
2791				greedy: true,
2792				inside: {
2793					'attribute-content': {
2794						pattern: /^(#\[)[\s\S]+(?=\]$)/,
2795						lookbehind: true,
2796						// inside can appear subset of php
2797						inside: {
2798							'comment': comment,
2799							'string': string,
2800							'attribute-class-name': [
2801								{
2802									pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
2803									alias: 'class-name',
2804									greedy: true,
2805									lookbehind: true
2806								},
2807								{
2808									pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
2809									alias: [
2810										'class-name',
2811										'class-name-fully-qualified'
2812									],
2813									greedy: true,
2814									lookbehind: true,
2815									inside: {
2816										'punctuation': /\\/
2817									}
2818								}
2819							],
2820							'constant': constant,
2821							'number': number,
2822							'operator': operator,
2823							'punctuation': punctuation
2824						}
2825					},
2826					'delimiter': {
2827						pattern: /^#\[|\]$/,
2828						alias: 'punctuation'
2829					}
2830				}
2831			},
2832		});
2833
2834		Prism.hooks.add('before-tokenize', function (env) {
2835			if (!/<\?/.test(env.code)) {
2836				return;
2837			}
2838
2839			var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
2840			Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern);
2841		});
2842
2843		Prism.hooks.add('after-tokenize', function (env) {
2844			Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php');
2845		});
2846
2847	}(Prism$1));
2848	return prismPhp;
2849}
2850
2851requirePrismPhp();
2852
2853Prism$1.languages.go = Prism$1.languages.extend('clike', {
2854	'string': {
2855		pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
2856		lookbehind: true,
2857		greedy: true
2858	},
2859	'keyword': /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
2860	'boolean': /\b(?:_|false|iota|nil|true)\b/,
2861	'number': [
2862		// binary and octal integers
2863		/\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
2864		// hexadecimal integers and floats
2865		/\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
2866		// decimal integers and floats
2867		/(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
2868	],
2869	'operator': /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
2870	'builtin': /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
2871});
2872
2873Prism$1.languages.insertBefore('go', 'string', {
2874	'char': {
2875		pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
2876		greedy: true
2877	}
2878});
2879
2880delete Prism$1.languages.go['class-name'];
2881
2882(function (Prism) {
2883	// $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\n' '|'
2884	// + LC_ALL, RANDOM, REPLY, SECONDS.
2885	// + make sure PS1..4 are here as they are not always set,
2886	// - some useless things.
2887	var envVars = '\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_