https://avi.nyc/assets/lexxy-a1b1695e.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
1999(function (Prism) {
2000
2001	Prism.languages.diff = {
2002		'coord': [
2003			// Match all kinds of coord lines (prefixed by "+++", "---" or "***").
2004			/^(?:\*{3}|-{3}|\+{3}).*$/m,
2005			// Match "@@ ... @@" coord lines in unified diff.
2006			/^@@.*@@$/m,
2007			// Match coord lines in normal diff (starts with a number).
2008			/^\d.*$/m
2009		]
2010
2011		// deleted, inserted, unchanged, diff
2012	};
2013
2014	/**
2015	 * A map from the name of a block to its line prefix.
2016	 *
2017	 * @type {Object<string, string>}
2018	 */
2019	var PREFIXES = {
2020		'deleted-sign': '-',
2021		'deleted-arrow': '<',
2022		'inserted-sign': '+',
2023		'inserted-arrow': '>',
2024		'unchanged': ' ',
2025		'diff': '!',
2026	};
2027
2028	// add a token for each prefix
2029	Object.keys(PREFIXES).forEach(function (name) {
2030		var prefix = PREFIXES[name];
2031
2032		var alias = [];
2033		if (!/^\w+$/.test(name)) { // "deleted-sign" -> "deleted"
2034			alias.push(/\w+/.exec(name)[0]);
2035		}
2036		if (name === 'diff') {
2037			alias.push('bold');
2038		}
2039
2040		Prism.languages.diff[name] = {
2041			pattern: RegExp('^(?:[' + prefix + '].*(?:\r\n?|\n|(?![\\s\\S])))+', 'm'),
2042			alias: alias,
2043			inside: {
2044				'line': {
2045					pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
2046					lookbehind: true
2047				},
2048				'prefix': {
2049					pattern: /[\s\S]/,
2050					alias: /\w+/.exec(name)[0]
2051				}
2052			}
2053		};
2054
2055	});
2056
2057	// make prefixes available to Diff plugin
2058	Object.defineProperty(Prism.languages.diff, 'PREFIXES', {
2059		value: PREFIXES
2060	});
2061
2062}(Prism$1));
2063
2064Prism$1.languages.javascript = Prism$1.languages.extend('clike', {
2065	'class-name': [
2066		Prism$1.languages.clike['class-name'],
2067		{
2068			pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
2069			lookbehind: true
2070		}
2071	],
2072	'keyword': [
2073		{
2074			pattern: /((?:^|\})\s*)catch\b/,
2075			lookbehind: true
2076		},
2077		{
2078			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/,
2079			lookbehind: true
2080		},
2081	],
2082	// Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
2083	'function': /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
2084	'number': {
2085		pattern: RegExp(
2086			/(^|[^\w$])/.source +
2087			'(?:' +
2088			(
2089				// constant
2090				/NaN|Infinity/.source +
2091				'|' +
2092				// binary integer
2093				/0[bB][01]+(?:_[01]+)*n?/.source +
2094				'|' +
2095				// octal integer
2096				/0[oO][0-7]+(?:_[0-7]+)*n?/.source +
2097				'|' +
2098				// hexadecimal integer
2099				/0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source +
2100				'|' +
2101				// decimal bigint
2102				/\d+(?:_\d+)*n/.source +
2103				'|' +
2104				// decimal number (integer or float) but no bigint

2105				/(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source
2106			) +
2107			')' +
2108			/(?![\w$])/.source
2109		),
2110		lookbehind: true
2111	},
2112	'operator': /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
2113});
2114
2115Prism$1.languages.javascript['class-name'][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
2116
2117Prism$1.languages.insertBefore('javascript', 'keyword', {
2118	'regex': {
2119		pattern: RegExp(
2120			// lookbehind
2121			// eslint-disable-next-line regexp/no-dupe-characters-character-class
2122			/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source +
2123			// Regex pattern:
2124			// There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
2125			// classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
2126			// with the only syntax, so we have to define 2 different regex patterns.
2127			/\//.source +
2128			'(?:' +
2129			/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source +
2130			'|' +
2131			// `v` flag syntax. This supports 3 levels of nested character classes.
2132			/(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source +
2133			')' +
2134			// lookahead
2135			/(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
2136		),
2137		lookbehind: true,
2138		greedy: true,
2139		inside: {
2140			'regex-source': {
2141				pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
2142				lookbehind: true,
2143				alias: 'language-regex',
2144				inside: Prism$1.languages.regex
2145			},
2146			'regex-delimiter': /^\/|\/$/,
2147			'regex-flags': /^[a-z]+$/,
2148		}
2149	},
2150	// This must be declared before keyword because we use "function" inside the look-forward
2151	'function-variable': {
2152		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*=>))/,
2153		alias: 'function'
2154	},
2155	'parameter': [
2156		{
2157			pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
2158			lookbehind: true,
2159			inside: Prism$1.languages.javascript
2160		},
2161		{
2162			pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
2163			lookbehind: true,
2164			inside: Prism$1.languages.javascript
2165		},
2166		{
2167			pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
2168			lookbehind: true,
2169			inside: Prism$1.languages.javascript
2170		},
2171		{
2172			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*\{)/,
2173			lookbehind: true,
2174			inside: Prism$1.languages.javascript
2175		}
2176	],
2177	'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/
2178});
2179
2180Prism$1.languages.insertBefore('javascript', 'string', {
2181	'hashbang': {
2182		pattern: /^#!.*/,
2183		greedy: true,
2184		alias: 'comment'
2185	},
2186	'template-string': {
2187		pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
2188		greedy: true,
2189		inside: {
2190			'template-punctuation': {
2191				pattern: /^`|`$/,
2192				alias: 'string'
2193			},
2194			'interpolation': {
2195				pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
2196				lookbehind: true,
2197				inside: {
2198					'interpolation-punctuation': {
2199						pattern: /^\$\{|\}$/,
2200						alias: 'punctuation'
2201					},
2202					rest: Prism$1.languages.javascript
2203				}
2204			},
2205			'string': /[\s\S]+/
2206		}
2207	},
2208	'string-property': {
2209		pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
2210		lookbehind: true,
2211		greedy: true,
2212		alias: 'property'
2213	}
2214});
2215
2216Prism$1.languages.insertBefore('javascript', 'operator', {
2217	'literal-property': {
2218		pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
2219		lookbehind: true,
2220		alias: 'property'
2221	},
2222});
2223
2224if (Prism$1.languages.markup) {
2225	Prism$1.languages.markup.tag.addInlined('script', 'javascript');
2226
2227	// add attribute support for all DOM events.
2228	// https://developer.mozilla.org/en-US/docs/Web/Events#Standard_events
2229	Prism$1.languages.markup.tag.addAttribute(
2230		/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?

2230:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
2231		'javascript'
2232	);
2233}
2234
2235Prism$1.languages.js = Prism$1.languages.javascript;
2236
2237Prism$1.languages.markup = {
2238	'comment': {
2239		pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
2240		greedy: true
2241	},
2242	'prolog': {
2243		pattern: /<\?[\s\S]+?\?>/,
2244		greedy: true
2245	},
2246	'doctype': {
2247		// https://www.w3.org/TR/xml/#NT-doctypedecl
2248		pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
2249		greedy: true,
2250		inside: {
2251			'internal-subset': {
2252				pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
2253				lookbehind: true,
2254				greedy: true,
2255				inside: null // see below
2256			},
2257			'string': {
2258				pattern: /"[^"]*"|'[^']*'/,
2259				greedy: true
2260			},
2261			'punctuation': /^<!|>$|[[\]]/,
2262			'doctype-tag': /^DOCTYPE/i,
2263			'name': /[^\s<>'"]+/
2264		}
2265	},
2266	'cdata': {
2267		pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
2268		greedy: true
2269	},
2270	'tag': {
2271		pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
2272		greedy: true,
2273		inside: {
2274			'tag': {
2275				pattern: /^<\/?[^\s>\/]+/,
2276				inside: {
2277					'punctuation': /^<\/?/,
2278					'namespace': /^[^\s>\/:]+:/
2279				}
2280			},
2281			'special-attr': [],
2282			'attr-value': {
2283				pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
2284				inside: {
2285					'punctuation': [
2286						{
2287							pattern: /^=/,
2288							alias: 'attr-equals'
2289						},
2290						{
2291							pattern: /^(\s*)["']|["']$/,
2292							lookbehind: true
2293						}
2294					]
2295				}
2296			},
2297			'punctuation': /\/?>/,
2298			'attr-name': {
2299				pattern: /[^\s>\/]+/,
2300				inside: {
2301					'namespace': /^[^\s>\/:]+:/
2302				}
2303			}
2304
2305		}
2306	},
2307	'entity': [
2308		{
2309			pattern: /&[\da-z]{1,8};/i,
2310			alias: 'named-entity'
2311		},
2312		/&#x?[\da-f]{1,8};/i
2313	]
2314};
2315
2316Prism$1.languages.markup['tag'].inside['attr-value'].inside['entity'] =
2317	Prism$1.languages.markup['entity'];
2318Prism$1.languages.markup['doctype'].inside['internal-subset'].inside = Prism$1.languages.markup;
2319
2320// Plugin to make entity title show the real entity, idea by Roman Komarov
2321Prism$1.hooks.add('wrap', function (env) {
2322
2323	if (env.type === 'entity') {
2324		env.attributes['title'] = env.content.replace(/&amp;/, '&');
2325	}
2326});
2327
2328Object.defineProperty(Prism$1.languages.markup.tag, 'addInlined', {
2329	/**
2330	 * Adds an inlined language to markup.
2331	 *
2332	 * An example of an inlined language is CSS with `<style>` tags.
2333	 *
2334	 * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
2335	 * case insensitive.
2336	 * @param {string} lang The language key.
2337	 * @example
2338	 * addInlined('style', 'css');
2339	 */
2340	value: function addInlined(tagName, lang) {
2341		var includedCdataInside = {};
2342		includedCdataInside['language-' + lang] = {
2343			pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
2344			lookbehind: true,
2345			inside: Prism$1.languages[lang]
2346		};
2347		includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
2348
2349		var inside = {
2350			'included-cdata': {
2351				pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
2352				inside: includedCdataInside
2353			}
2354		};
2355		inside['language-' + lang] = {
2356			pattern: /[\s\S]+/,
2357			inside: Prism$1.languages[lang]
2358		};
2359
2360		var def = {};
2361		def[tagName] = {
2362			pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () { return tagName; }), 'i'),
2363			lookbehind: true,
2364			greedy: true,
2365			inside: inside
2366		};
2367
2368		Prism$1.languages.insertBefore('markup', 'cdata', def);
2369	}
2370});
2371Object.defineProperty(Prism$1.languages.markup.tag, 'addAttribute', {
2372	/**
2373	 * Adds an pattern to highlight languages embedded in HTML attributes.
2374	 *
2375	 * An example of an inlined language is CSS with `style` attributes.
2376	 *
2377	 * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
2378	 * case insensitive.
2379	 * @param {string} lang The language key.
2380	 * @example
2381	 * addAttribute('style', 'css');
2382	 */
2383	value: function (attrName, lang) {
2384		Prism$1.languages.markup.tag.inside['special-attr'].push({
2385			pattern: RegExp(
2386				/(^|["'\s])/.source + '(?:' + attrName + ')' + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\

2386s'">=]+(?=[\s>]))/.source,
2387				'i'
2388			),
2389			lookbehind: true,
2390			inside: {
2391				'attr-name': /^[^\s=]+/,
2392				'attr-value': {
2393					pattern: /=[\s\S]+/,
2394					inside: {
2395						'value': {
2396							pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
2397							lookbehind: true,
2398							alias: [lang, 'language-' + lang],
2399							inside: Prism$1.languages[lang]
2400						},
2401						'punctuation': [
2402							{
2403								pattern: /^=/,
2404								alias: 'attr-equals'
2405							},
2406							/"|'/
2407						]
2408					}
2409				}
2410			}
2411		});
2412	}
2413});
2414
2415Prism$1.languages.html = Prism$1.languages.markup;
2416Prism$1.languages.mathml = Prism$1.languages.markup;
2417Prism$1.languages.svg = Prism$1.languages.markup;
2418
2419Prism$1.languages.xml = Prism$1.languages.extend('markup', {});
2420Prism$1.languages.ssml = Prism$1.languages.xml;
2421Prism$1.languages.atom = Prism$1.languages.xml;
2422Prism$1.languages.rss = Prism$1.languages.xml;
2423
2424(function (Prism) {
2425
2426	// Allow only one line break
2427	var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
2428
2429	/**
2430	 * This function is intended for the creation of the bold or italic pattern.
2431	 *
2432	 * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.
2433	 *
2434	 * _Note:_ Keep in mind that this adds a capturing group.
2435	 *
2436	 * @param {string} pattern
2437	 * @returns {RegExp}
2438	 */
2439	function createInline(pattern) {
2440		pattern = pattern.replace(/<inner>/g, function () { return inner; });
2441		return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + '(?:' + pattern + ')');
2442	}
2443
2444
2445	var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source;
2446	var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function () { return tableCell; });
2447	var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
2448
2449
2450	Prism.languages.markdown = Prism.languages.extend('markup', {});
2451	Prism.languages.insertBefore('markdown', 'prolog', {
2452		'front-matter-block': {
2453			pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
2454			lookbehind: true,
2455			greedy: true,
2456			inside: {
2457				'punctuation': /^---|---$/,
2458				'front-matter': {
2459					pattern: /\S+(?:\s+\S+)*/,
2460					alias: ['yaml', 'language-yaml'],
2461					inside: Prism.languages.yaml
2462				}
2463			}
2464		},
2465		'blockquote': {
2466			// > ...
2467			pattern: /^>(?:[\t ]*>)*/m,
2468			alias: 'punctuation'
2469		},
2470		'table': {
2471			pattern: RegExp('^' + tableRow + tableLine + '(?:' + tableRow + ')*', 'm'),
2472			inside: {
2473				'table-data-rows': {
2474					pattern: RegExp('^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$'),
2475					lookbehind: true,
2476					inside: {
2477						'table-data': {
2478							pattern: RegExp(tableCell),
2479							inside: Prism.languages.markdown
2480						},
2481						'punctuation': /\|/
2482					}
2483				},
2484				'table-line': {
2485					pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'),
2486					lookbehind: true,
2487					inside: {
2488						'punctuation': /\||:?-{3,}:?/
2489					}
2490				},
2491				'table-header-row': {
2492					pattern: RegExp('^' + tableRow + '$'),
2493					inside: {
2494						'table-header': {
2495							pattern: RegExp(tableCell),
2496							alias: 'important',
2497							inside: Prism.languages.markdown
2498						},
2499						'punctuation': /\|/
2500					}
2501				}
2502			}
2503		},
2504		'code': [
2505			{
2506				// Prefixed by 4 spaces or 1 tab and preceded by an empty line
2507				pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
2508				lookbehind: true,
2509				alias: 'keyword'
2510			},
2511			{
2512				// ```optional language
2513				// code block
2514				// ```
2515				pattern: /^```[\s\S]*?^```$/m,
2516				greedy: true,
2517				inside: {
2518					'code-block': {
2519						pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
2520						lookbehind: true
2521					},
2522					'code-language': {
2523						pattern: /^(```).+/,
2524						lookbehind: true
2525					},
2526					'punctuation': /```/
2527				}
2528			}
2529		],
2530		'title': [
2531			{
2532				// title 1
2533				// =======
2534
2535				// title 2
2536				// -------
2537				pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
2538				alias: 'important',
2539				inside: {
2540					punctuation: /==+$|--+$/
2541				}
2542			},
2543			{
2544				// # title 1
2545				// ###### title 6
2546				pattern: /(^\s*)#.+/m,
2547				lookbehind: true,
2548				alias: 'important',
2549				inside: {
2550					punctuation: /^#+|#+$/
2551				}
2552			}
2553		],
2554		'hr': {
2555			// ***
2556			// ---
2557			// * * *
2558			// -----------
2559			pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
2560			lookbehind: true,
2561			alias: 'punctuation'
2562		},
2563		'list': {
2564			// * item
2565			// + item
2566			// - item
2567			// 1. item
2568			pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
2569			lookbehind: true,
2570			alias: 'punctuation'
2571		},
2572		'url-reference': {
2573			// [id]: http://example.com "Optional title"
2574			// [id]: http://example.com 'Optional title'
2575			// [id]: http://example.com (Optional title)
2576			// [id]: <http://example.com> "Optional title"
2577			pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
2578			inside: {
2579				'variable': {
2580					pattern: /^(!?\[)[^\]]+/,
2581					lookbehind: true
2582				},
2583				'string': /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
2584				'punctuation': /^[\[\]!:]|[<>]/
2585			},
2586			alias: 'url'
2587		},
2588		'bold': {
2589			// **strong**
2590			// __strong__
2591
2592			// allow one nested instance of italic text using the same delimiter
2593			pattern: createInline(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
2594			lookbehind: true,
2595			greedy: true,
2596			inside: {
2597				'content': {
2598					pattern: /(^..)[\s\S]+(?=..$)/,
2599					lookbehind: true,
2600					inside: {} // see below
2601				},
2602				'punctuation': /\*\*|__/
2603			}
2604		},
2605		'italic': {
2606			// *em*
2607			// _em_
2608
2609			// allow one nested instance of bold text using the same delimiter
2610			pattern: createInline(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
2611			lookbehind: true,
2612			greedy: true,
2613			inside: {
2614				'content': {
2615					pattern: /(^.)[\s\S]+(?=.$)/,
2616					lookbehind: true,
2617					inside: {} // see below
2618				},
2619				'punctuation': /[*_]/
2620			}
2621		},
2622		'strike': {
2623			// ~~strike through~~
2624			// ~strike~
2625			// eslint-disable-next-line regexp/strict
2626			pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
2627			lookbehind: true,
2628			greedy: true,
2629			inside: {
2630				'content': {
2631					pattern: /(^~~?)[\s\S]+(?=\1$)/,
2632					lookbehind: true,
2633					inside: {} // see below
2634				},
2635				'punctuation': /~~?/
2636			}
2637		},
2638		'code-snippet': {
2639			// `code`
2640			// ``code``
2641			pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
2642			lookbehind: true,
2643			greedy: true,
2644			alias: ['code', 'keyword']
2645		},
2646		'url': {
2647			// [example](http://example.com "Optional title")
2648			// [example][id]
2649			// [example] [id]
2650			pattern: createInline(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
2651			lookbehind: true,
2652			greedy: true,
2653			inside: {
2654				'operator': /^!/,
2655				'content': {
2656					pattern: /(^\[)[^\]]+(?=\])/,
2657					lookbehind: true,
2658					inside: {} // see below
2659				},
2660				'variable': {
2661					pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
2662					lookbehind: true
2663				},
2664				'url': {
2665					pattern: /(^\]\()[^\s)]+/,
2666					lookbehind: true
2667				},
2668				'string': {
2669					pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
2670					lookbehind: true
2671				}
2672			}
2673		}
2674	});
2675
2676	['url', 'bold', 'italic', 'strike'].forEach(function (token) {
2677		['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach(function (inside) {
2678			if (token !== inside) {
2679				Prism.languages.markdown[token].inside.content.inside[inside] = Prism.languages.markdown[inside];
2680			}
2681		});
2682	});
2683
2684	Prism.hooks.add('after-tokenize', function (env) {
2685		if (env.language !== 'markdown' && env.language !== 'md') {
2686			return;
2687		}
2688
2689		function walkTokens(tokens) {
2690			if (!tokens || typeof tokens === 'string') {
2691				return;
2692			}
2693
2694			for (var i = 0, l = tokens.length; i < l; i++) {
2695				var token = tokens[i];
2696
2697				if (token.type !== 'code') {
2698					walkTokens(token.content);
2699					continue;
2700				}
2701
2702				/*
2703				 * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token
2704				 * is optional. But the grammar is defined so that there is only one case we have to handle:
2705				 *
2706				 * token.content = [
2707				 *     <span class="punctuation">```</span>,
2708				 *     <span class="code-language">xxxx</span>,
2709				 *     '\n', // exactly one new lines (\r or \n or \r\n)
2710				 *     <span class="code-block">...</span>,
2711				 *     '\n', // exactly one new lines again
2712				 *     <span class="punctuation">```</span>
2713				 * ];
2714				 */
2715
2716				var codeLang = token.content[1];
2717				var codeBlock = token.content[3];
2718
2719				if (codeLang && codeBlock &&
2720					codeLang.type === 'code-language' && codeBlock.type === 'code-block' &&
2721					typeof codeLang.content === 'string') {
2722
2723					// this might be a language that Prism does not support
2724
2725					// do some replacements to support C++, C#, and F#
2726					var lang = codeLang.content.replace(/\b#/g, 'sharp').replace(/\b\+\+/g, 'pp');
2727					// only use the first word
2728					lang = (/[a-z][\w-]*/i.exec(lang) || [''])[0].toLowerCase();
2729					var alias = 'language-' + lang;
2730
2731					// add alias
2732					if (!codeBlock.alias) {
2733						codeBlock.alias = [alias];
2734					} else if (typeof codeBlock.alias === 'string') {
2735						codeBlock.alias = [codeBlock.alias, alias];
2736					} else {
2737						codeBlock.alias.push(alias);
2738					}
2739				}
2740			}
2741		}
2742
2743		walkTokens(env.tokens);
2744	});
2745
2746	Prism.hooks.add('wrap', function (env) {
2747		if (env.type !== 'code-block') {
2748			return;
2749		}
2750
2751		var codeLang = '';
2752		for (var i = 0, l = env.classes.length; i < l; i++) {
2753			var cls = env.classes[i];
2754			var match = /language-(.+)/.exec(cls);
2755			if (match) {
2756				codeLang = match[1];
2757				break;
2758			}
2759		}
2760
2761		var grammar = Prism.languages[codeLang];
2762
2763		if (!grammar) {
2764			if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) {
2765				var id = 'md-' + new Date().valueOf() + '-' + Math.floor(Math.random() * 1e16);
2766				env.attributes['id'] = id;
2767
2768				Prism.plugins.autoloader.loadLanguages(codeLang, function () {
2769					var ele = document.getElementById(id);
2770					if (ele) {
2771						ele.innerHTML = Prism.highlight(ele.textContent, Prism.languages[codeLang], codeLang);
2772					}
2773				});
2774			}
2775		} else {
2776			env.content = Prism.highlight(textContent(env.content), grammar, codeLang);
2777		}
2778	});
2779
2780	var tagPattern = RegExp(Prism.languages.markup.tag.pattern.source, 'gi');
2781
2782	/**
2783	 * A list of known entity names.
2784	 *
2785	 * This will always be incomplete to save space. The current list is the one used by lowdash's unescape function.
2786	 *
2787	 * @see {@link https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/unescape.js#L2}
2788	 */
2789	var KNOWN_ENTITY_NAMES = {
2790		'amp': '&',
2791		'lt': '<',
2792		'gt': '>',
2793		'quot': '"',
2794	};
2795
2796	// IE 11 doesn't support `String.fromCodePoint`
2797	var fromCodePoint = String.fromCodePoint || String.fromCharCode;
2798
2799	/**
2800	 * Returns the text content of a given HTML source code string.
2801	 *
2802	 * @param {string} html
2803	 * @returns {string}
2804	 */
2805	function textContent(html) {
2806		// remove all tags
2807		var text = html.replace(tagPattern, '');
2808
2809		// decode known entities
2810		text = text.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function (m, code) {
2811			code = code.toLowerCase();
2812
2813			if (code[0] === '#') {
2814				var value;
2815				if (code[1] === 'x') {
2816					value = parseInt(code.slice(2), 16);
2817				} else {
2818					value = Number(code.slice(1));
2819				}
2820
2821				return fromCodePoint(value);
2822			} else {
2823				var known = KNOWN_ENTITY_NAMES[code];
2824				if (known) {
2825					return known;
2826				}
2827
2828				// unable to decode
2829				return m;
2830			}
2831		});
2832
2833		return text;
2834	}
2835
2836	Prism.languages.md = Prism.languages.markdown;
2837
2838}(Prism$1));
2839
2840Prism$1.languages.c = Prism$1.languages.extend('clike', {
2841	'comment': {
2842		pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
2843		greedy: true
2844	},
2845	'string': {
2846		// https://en.cppreference.com/w/c/language/string_literal
2847		pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
2848		greedy: true
2849	},
2850	'class-name': {
2851		pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
2852		lookbehind: true
2853	},
2854	'keyword': /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
2855	'function': /\b[a-z_]\w*(?=\s*\()/i,
2856	'number': /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
2857	'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
2858});
2859
2860Prism$1.languages.insertBefore('c', 'string', {
2861	'char': {
2862		// https://en.cppreference.com/w/c/language/character_constant
2863		pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
2864		greedy: true
2865	}
2866});
2867
2868Prism$1.languages.insertBefore('c', 'string', {
2869	'macro': {
2870		// allow for multiline macro definitions
2871		// spaces after the # character compile fine with gcc
2872		pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
2873		lookbehind: true,
2874		greedy: true,
2875		alias: 'property',
2876		inside: {
2877			'string': [
2878				{
2879					// highlight the path of the include statement as a string
2880					pattern: /^(#\s*include\s*)<[^>]+>/,
2881					lookbehind: true
2882				},
2883				Prism$1.languages.c['string']
2884			],
2885			'char': Prism$1.languages.c['char'],
2886			'comment': Prism$1.languages.c['comment'],
2887			'macro-name': [
2888				{
2889					pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
2890					lookbehind: true
2891				},
2892				{
2893					pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
2894					lookbehind: true,