var _self =
typeof window !== "undefined"
? window
: typeof WorkerGlobalScope !== "undefined" &&
self instanceof WorkerGlobalScope
? self
: {};
var Prism = (function (_self) {
var lang = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i;
var uniqueId = 0;
var plainTextGrammar = {};
var _ = {
manual: _self.Prism && _self.Prism.manual,
disableWorkerMessageHandler:
_self.Prism && _self.Prism.disableWorkerMessageHandler,
util: {
encode: function encode(tokens) {
if (tokens instanceof Token) {
return new Token(tokens.type, encode(tokens.content), tokens.alias);
} else if (Array.isArray(tokens)) {
return tokens.map(encode);
} else {
return tokens
.replace(/&/g, "&")
.replace(/</g, "<")
.replace(/\u00a0/g, " ");
}
},
type: function (o) {
return Object.prototype.toString.call(o).slice(8, -1);
},
objId: function (obj) {
if (!obj["__id"]) {
Object.defineProperty(obj, "__id", { value: ++uniqueId });
}
return obj["__id"];
},
clone: function deepClone(o, visited) {
visited = visited || {};
var clone;
var id;
switch (_.util.type(o)) {
case "Object":
id = _.util.objId(o);
if (visited[id]) {
return visited[id];
}
clone = ({});
visited[id] = clone;
for (var key in o) {
if (o.hasOwnProperty(key)) {
clone[key] = deepClone(o[key], visited);
}
}
return (clone);
case "Array":
id = _.util.objId(o);
if (visited[id]) {
return visited[id];
}
clone = [];
visited[id] = clone;
( (o)).forEach(function (
v,
i
) {
clone[i] = deepClone(v, visited);
});
return (clone);
default:
return o;
}
},
getLanguage: function (element) {
while (element) {
var m = lang.exec(element.className);
if (m) {
return m[1].toLowerCase();
}
element = element.parentElement;
}
return "none";
},
setLanguage: function (element, language) {
element.className = element.className.replace(RegExp(lang, "gi"), "");
element.classList.add("language-" + language);
},
currentScript: function () {
if (typeof document === "undefined") {
return null;
}
if (
"currentScript" in document &&
1 < 2
) {
return (document.currentScript);
}
try {
throw new Error();
} catch (err) {
var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) ||
[])[1];
if (src) {
var scripts = document.getElementsByTagName("script");
for (var i in scripts) {
if (scripts[i].src == src) {
return scripts[i];
}
}
}
return null;
}
},
isActive: function (element, className, defaultActivation) {
var no = "no-" + className;
while (element) {
var classList = element.classList;
if (classList.contains(className)) {
return true;
}
if (classList.contains(no)) {
return false;
}
element = element.parentElement;
}
return !!defaultActivation;
},
},
languages: {
plain: plainTextGrammar,
plaintext: plainTextGrammar,
text: plainTextGrammar,
txt: plainTextGrammar,
extend: function (id, redef) {
var lang = _.util.clone(_.languages[id]);
for (var key in redef) {
lang[key] = redef[key];
}
return lang;
},
insertBefore: function (inside, before, insert, root) {
root = root || (_.languages);
var grammar = root[inside];
var ret = {};
for (var token in grammar) {
if (grammar.hasOwnProperty(token)) {
if (token == before) {
for (var newToken in insert) {
if (insert.hasOwnProperty(newToken)) {
ret[newToken] = insert[newToken];
}
}
}
if (!insert.hasOwnProperty(token)) {
ret[token] = grammar[token];
}
}
}
var old = root[inside];
root[inside] = ret;
_.languages.DFS(_.languages, function (key, value) {
if (value === old && key != inside) {
this[key] = ret;
}
});
return ret;
},
DFS: function DFS(o, callback, type, visited) {
visited = visited || {};
var objId = _.util.objId;
for (var i in o) {
if (o.hasOwnProperty(i)) {
callback.call(o, i, o[i], type || i);
var property = o[i];
var propertyType = _.util.type(property);
if (propertyType === "Object" && !visited[objId(property)]) {
visited[objId(property)] = true;
DFS(property, callback, null, visited);
} else if (propertyType === "Array" && !visited[objId(property)]) {
visited[objId(property)] = true;
DFS(property, callback, i, visited);
}
}
}
},
},
plugins: {},
highlightAll: function (async, callback) {
_.highlightAllUnder(document, async, callback);
},
highlightAllUnder: function (container, async, callback) {
var env = {
callback: callback,
container: container,
selector:
'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code',
};
_.hooks.run("before-highlightall", env);
env.elements = Array.prototype.slice.apply(
env.container.querySelectorAll(env.selector)
);
_.hooks.run("before-all-elements-highlight", env);
for (var i = 0, element; (element = env.elements[i++]); ) {
_.highlightElement(element, async === true, env.callback);
}
},
highlightElement: function (element, async, callback) {
var language = _.util.getLanguage(element);
var grammar = _.languages[language];
_.util.setLanguage(element, language);
var parent = element.parentElement;
if (parent && parent.nodeName.toLowerCase() === "pre") {
_.util.setLanguage(parent, language);
}
var code = element.textContent;
var env = {
element: element,
language: language,
grammar: grammar,
code: code,
};
function insertHighlightedCode(highlightedCode) {
env.highlightedCode = highlightedCode;
_.hooks.run("before-insert", env);
env.element.innerHTML = env.highlightedCode;
_.hooks.run("after-highlight", env);
_.hooks.run("complete", env);
callback && callback.call(env.element);
}
_.hooks.run("before-sanity-check", env);
parent = env.element.parentElement;
if (
parent &&
parent.nodeName.toLowerCase() === "pre" &&
!parent.hasAttribute("tabindex")
) {
parent.setAttribute("tabindex", "0");
}
if (!env.code) {
_.hooks.run("complete", env);
callback && callback.call(env.element);
return;
}
_.hooks.run("before-highlight", env);
if (!env.grammar) {
insertHighlightedCode(_.util.encode(env.code));
return;
}
if (async && _self.Worker) {
var worker = new Worker(_.filename);
worker.onmessage = function (evt) {
insertHighlightedCode(evt.data);
};
worker.postMessage(
JSON.stringify({
language: env.language,
code: env.code,
immediateClose: true,
})
);
} else {
insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
}
},
highlight: function (text, grammar, language) {
var env = {
code: text,
grammar: grammar,
language: language,
};
_.hooks.run("before-tokenize", env);
if (!env.grammar) {
throw new Error('The language "' + env.language + '" has no grammar.');
}
env.tokens = _.tokenize(env.code, env.grammar);
_.hooks.run("after-tokenize", env);
return Token.stringify(_.util.encode(env.tokens), env.language);
},
tokenize: function (text, grammar) {
var rest = grammar.rest;
if (rest) {
for (var token in rest) {
grammar[token] = rest[token];
}
delete grammar.rest;
}
var tokenList = new LinkedList();
addAfter(tokenList, tokenList.head, text);
matchGrammar(text, tokenList, grammar, tokenList.head, 0);
return toArray(tokenList);
},
hooks: {
all: {},
add: function (name, callback) {
var hooks = _.hooks.all;
hooks[name] = hooks[name] || [];
hooks[name].push(callback);
},
run: function (name, env) {
var callbacks = _.hooks.all[name];
if (!callbacks || !callbacks.length) {
return;
}
for (var i = 0, callback; (callback = callbacks[i++]); ) {
callback(env);
}
},
},
Token: Token,
};
_self.Prism = _;
function Token(type, content, alias, matchedStr) {
this.type = type;
this.content = content;
this.alias = alias;
this.length = (matchedStr || "").length | 0;
}
Token.stringify = function stringify(o, language) {
if (typeof o == "string") {
return o;
}
if (Array.isArray(o)) {
var s = "";
o.forEach(function (e) {
s += stringify(e, language);
});
return s;
}
var env = {
type: o.type,
content: stringify(o.content, language),
tag: "span",
classes: ["token", o.type],
attributes: {},
language: language,
};
var aliases = o.alias;
if (aliases) {
if (Array.isArray(aliases)) {
Array.prototype.push.apply(env.classes, aliases);
} else {
env.classes.push(aliases);
}
}
_.hooks.run("wrap", env);
var attributes = "";
for (var name in env.attributes) {
attributes +=
" " +
name +
'="' +
(env.attributes[name] || "").replace(/"/g, """) +
'"';
}
return (
"<" +
env.tag +
' class="' +
env.classes.join(" ") +
'"' +
attributes +
">" +
env.content +
"</" +
env.tag +
">"
);
};
function matchPattern(pattern, pos, text, lookbehind) {
pattern.lastIndex = pos;
var match = pattern.exec(text);
if (match && lookbehind && match[1]) {
var lookbehindLength = match[1].length;
match.index += lookbehindLength;
match[0] = match[0].slice(lookbehindLength);
}
return match;
}
function matchGrammar(
text,
tokenList,
grammar,
startNode,
startPos,
rematch
) {
for (var token in grammar) {
if (!grammar.hasOwnProperty(token) || !grammar[token]) {
continue;
}
var patterns = grammar[token];
patterns = Array.isArray(patterns) ? patterns : [patterns];
for (var j = 0; j < patterns.length; ++j) {
if (rematch && rematch.cause == token + "," + j) {
return;
}
var patternObj = patterns[j];
var inside = patternObj.inside;
var lookbehind = !!patternObj.lookbehind;
var greedy = !!patternObj.greedy;
var alias = patternObj.alias;
if (greedy && !patternObj.pattern.global) {
var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
patternObj.pattern = RegExp(patternObj.pattern.source, flags + "g");
}
var pattern = patternObj.pattern || patternObj;
for (
var currentNode = startNode.next, pos = startPos;
currentNode !== tokenList.tail;
pos += currentNode.value.length, currentNode = currentNode.next
) {
if (rematch && pos >= rematch.reach) {
break;
}
var str = currentNode.value;
if (tokenList.length > text.length) {
return;
}
if (str instanceof Token) {
continue;
}
var removeCount = 1;
var match;
if (greedy) {
match = matchPattern(pattern, pos, text, lookbehind);
if (!match || match.index >= text.length) {
break;
}
var from = match.index;
var to = match.index + match[0].length;
var p = pos;
p += currentNode.value.length;
while (from >= p) {
currentNode = currentNode.next;
p += currentNode.value.length;
}
p -= currentNode.value.length;
pos = p;
if (currentNode.value instanceof Token) {
continue;
}
for (
var k = currentNode;
k !== tokenList.tail && (p < to || typeof k.value === "string");
k = k.next
) {
removeCount++;
p += k.value.length;
}
removeCount--;
str = text.slice(pos, p);
match.index -= pos;
} else {
match = matchPattern(pattern, 0, str, lookbehind);
if (!match) {
continue;
}
}
var from = match.index;
var matchStr = match[0];
var before = str.slice(0, from);
var after = str.slice(from + matchStr.length);
var reach = pos + str.length;
if (rematch && reach > rematch.reach) {
rematch.reach = reach;
}
var removeFrom = currentNode.prev;
if (before) {
removeFrom = addAfter(tokenList, removeFrom, before);
pos += before.length;
}
removeRange(tokenList, removeFrom, removeCount);
var wrapped = new Token(
token,
inside ? _.tokenize(matchStr, inside) : matchStr,
alias,
matchStr
);
currentNode = addAfter(tokenList, removeFrom, wrapped);
if (after) {
addAfter(tokenList, currentNode, after);
}
if (removeCount > 1) {
var nestedRematch = {
cause: token + "," + j,
reach: reach,
};
matchGrammar(
text,
tokenList,
grammar,
currentNode.prev,
pos,
nestedRematch
);
if (rematch && nestedRematch.reach > rematch.reach) {
rematch.reach = nestedRematch.reach;
}
}
}
}
}
}
function LinkedList() {
var head = { value: null, prev: null, next: null };
var tail = { value: null, prev: head, next: null };
head.next = tail;
this.head = head;
this.tail = tail;
this.length = 0;
}
function addAfter(list, node, value) {
var next = node.next;
var newNode = { value: value, prev: node, next: next };
node.next = newNode;
next.prev = newNode;
list.length++;
return newNode;
}
function removeRange(list, node, count) {
var next = node.next;
for (var i = 0; i < count && next !== list.tail; i++) {
next = next.next;
}
node.next = next;
next.prev = node;
list.length -= i;
}
function toArray(list) {
var array = [];
var node = list.head.next;
while (node !== list.tail) {
array.push(node.value);
node = node.next;
}
return array;
}
if (!_self.document) {
if (!_self.addEventListener) {
return _;
}
if (!_.disableWorkerMessageHandler) {
_self.addEventListener(
"message",
function (evt) {
var message = JSON.parse(evt.data);
var lang = message.language;
var code = message.code;
var immediateClose = message.immediateClose;
_self.postMessage(_.highlight(code, _.languages[lang], lang));
if (immediateClose) {
_self.close();
}
},
false
);
}
return _;
}
var script = _.util.currentScript();
if (script) {
_.filename = script.src;
if (script.hasAttribute("data-manual")) {
_.manual = true;
}
}
function highlightAutomaticallyCallback() {
if (!_.manual) {
_.highlightAll();
}
}
if (!_.manual) {
var readyState = document.readyState;
if (
readyState === "loading" ||
(readyState === "interactive" && script && script.defer)
) {
document.addEventListener(
"DOMContentLoaded",
highlightAutomaticallyCallback
);
} else {
if (window.requestAnimationFrame) {
window.requestAnimationFrame(highlightAutomaticallyCallback);
} else {
window.setTimeout(highlightAutomaticallyCallback, 16);
}
}
}
return _;
})(_self);
if (typeof module !== "undefined" && module.exports) {
module.exports = Prism;
}
if (typeof global !== "undefined") {
global.Prism = Prism;
}
Prism.languages.markup = {
comment: {
pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
greedy: true,
},
prolog: {
pattern: /<\?[\s\S]+?\?>/,
greedy: true,
},
doctype: {
pattern:
/<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
greedy: true,
inside: {
"internal-subset": {
pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
lookbehind: true,
greedy: true,
inside: null,
},
string: {
pattern: /"[^"]*"|'[^']*'/,
greedy: true,
},
punctuation: /^<!|>$|[[\]]/,
"doctype-tag": /^DOCTYPE/i,
name: /[^\s<>'"]+/,
},
},
cdata: {
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
greedy: true,
},
tag: {
pattern:
/<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
greedy: true,
inside: {
tag: {
pattern: /^<\/?[^\s>\/]+/,
inside: {
punctuation: /^<\/?/,
namespace: /^[^\s>\/:]+:/,
},
},
"special-attr": [],
"attr-value": {
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
inside: {
punctuation: [
{
pattern: /^=/,
alias: "attr-equals",
},
{
pattern: /^(\s*)["']|["']$/,
lookbehind: true,
},
],
},
},
punctuation: /\/?>/,
"attr-name": {
pattern: /[^\s>\/]+/,
inside: {
namespace: /^[^\s>\/:]+:/,
},
},
},
},
entity: [
{
pattern: /&[\da-z]{1,8};/i,
alias: "named-entity",
},
/&#x?[\da-f]{1,8};/i,
],
};
Prism.languages.markup["tag"].inside["attr-value"].inside["entity"] =
Prism.languages.markup["entity"];
Prism.languages.markup["doctype"].inside["internal-subset"].inside =
Prism.languages.markup;
Prism.hooks.add("wrap", function (env) {
if (env.type === "entity") {
env.attributes["title"] = env.content.replace(/&/, "&");
}
});
Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
value: function addInlined(tagName, lang) {
var includedCdataInside = {};
includedCdataInside["language-" + lang] = {
pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
lookbehind: true,
inside: Prism.languages[lang],
};
includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
var inside = {
"included-cdata": {
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
inside: includedCdataInside,
},
};
inside["language-" + lang] = {
pattern: /[\s\S]+/,
inside: Prism.languages[lang],
};
var def = {};
def[tagName] = {
pattern: RegExp(
/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
/__/g,
function () {
return tagName;
}
),
"i"
),
lookbehind: true,
greedy: true,
inside: inside,
};
Prism.languages.insertBefore("markup", "cdata", def);
},
});
Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
value: function (attrName, lang) {
Prism.languages.markup.tag.inside["special-attr"].push({
pattern: RegExp(
/(^|["'\s])/.source +
"(?:" +
attrName +
")" +
/\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
"i"
),
lookbehind: true,
inside: {
"attr-name": /^[^\s=]+/,
"attr-value": {
pattern: /=[\s\S]+/,
inside: {
value: {
pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
lookbehind: true,
alias: [lang, "language-" + lang],
inside: Prism.languages[lang],
},
punctuation: [
{
pattern: /^=/,
alias: "attr-equals",
},
/"|'/,
],
},
},
},
});
},
});
Prism.languages.html = Prism.languages.markup;
Prism.languages.mathml = Prism.languages.markup;
Prism.languages.svg = Prism.languages.markup;
Prism.languages.xml = Prism.languages.extend("markup", {});
Prism.languages.ssml = Prism.languages.xml;
Prism.languages.atom = Prism.languages.xml;
Prism.languages.rss = Prism.languages.xml;
(function (Prism) {
var string =
/(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
Prism.languages.css = {
comment: /\/\*[\s\S]*?\*\//,
atrule: {
pattern: RegExp(
"@[\\w-](?:" +
/[^;{\s"']|\s+(?!\s)/.source +
"|" +
string.source +
")*?" +
/(?:;|(?=\s*\{))/.source
),
inside: {
rule: /^@[\w-]+/,
"selector-function-argument": {
pattern:
/(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
lookbehind: true,
alias: "selector",
},
keyword: {
pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
lookbehind: true,
},
},
},
url: {
pattern: RegExp(
"\\burl\\((?:" +
string.source +
"|" +
/(?:[^\\\r\n()"']|\\[\s\S])*/.source +
")\\)",
"i"
),
greedy: true,
inside: {
function: /^url/i,
punctuation: /^\(|\)$/,
string: {
pattern: RegExp("^" + string.source + "$"),
alias: "url",
},
},
},
selector: {
pattern: RegExp(
"(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" +
string.source +
")*(?=\\s*\\{)"
),
lookbehind: true,
},
string: {
pattern: string,
greedy: true,
},
property: {
pattern:
/(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
lookbehind: true,
},
important: /!important\b/i,
function: {
pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
lookbehind: true,
},
punctuation: /[(){};:,]/,
};
Prism.languages.css["atrule"].inside.rest = Prism.languages.css;
var markup = Prism.languages.markup;
if (markup) {
markup.tag.addInlined("style", "css");
markup.tag.addAttribute("style", "css");
}
})(Prism);
Prism.languages.clike = {
comment: [
{
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
lookbehind: true,
greedy: true,
},
{
pattern: /(^|[^\\:])\/\/.*/,
lookbehind: true,
greedy: true,
},
],
string: {
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
greedy: true,
},
"class-name": {
pattern:
/(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
lookbehind: true,
inside: {
punctuation: /[.\\]/,
},
},
keyword:
/\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
boolean: /\b(?:false|true)\b/,
function: /\b\w+(?=\()/,
number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
punctuation: /[{}[\];(),.:]/,
};
Prism.languages.javascript = Prism.languages.extend("clike", {
"class-name": [
Prism.languages.clike["class-name"],
{
pattern:
/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
lookbehind: true,
},
],
keyword: [
{
pattern: /((?:^|\})\s*)catch\b/,
lookbehind: true,
},
{
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/,
lookbehind: true,
},
],
function:
/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
number: {
pattern: RegExp(
/(^|[^\w$])/.source +
"(?:" +
(/NaN|Infinity/.source +
"|" +
/0[bB][01]+(?:_[01]+)*n?/.source +
"|" +
/0[oO][0-7]+(?:_[0-7]+)*n?/.source +
"|" +
/0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source +
"|" +
/\d+(?:_\d+)*n/.source +
"|" +
/(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/
.source) +
")" +
/(?![\w$])/.source
),
lookbehind: true,
},
operator:
/--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
});
Prism.languages.javascript["class-name"][0].pattern =
/(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
Prism.languages.insertBefore("javascript", "keyword", {
regex: {
pattern: RegExp(
/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source +
/\//.source +
"(?:" +
/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/
.source +
"|" +
/(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/
.source +
")" +
/(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
),
lookbehind: true,
greedy: true,
inside: {
"regex-source": {
pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
lookbehind: true,
alias: "language-regex",
inside: Prism.languages.regex,
},
"regex-delimiter": /^\/|\/$/,
"regex-flags": /^[a-z]+$/,
},
},
"function-variable": {
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*=>))/,
alias: "function",
},
parameter: [
{
pattern:
/(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
lookbehind: true,
inside: Prism.languages.javascript,
},
{
pattern:
/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
lookbehind: true,
inside: Prism.languages.javascript,
},
{
pattern:
/(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
lookbehind: true,
inside: Prism.languages.javascript,
},
{
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*\{)/,
lookbehind: true,
inside: Prism.languages.javascript,
},
],
constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/,
});
Prism.languages.insertBefore("javascript", "string", {
hashbang: {
pattern: /^#!.*/,
greedy: true,
alias: "comment",
},
"template-string": {
pattern:
/`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
greedy: true,
inside: {
"template-punctuation": {
pattern: /^`|`$/,
alias: "string",
},
interpolation: {
pattern:
/((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
lookbehind: true,
inside: {
"interpolation-punctuation": {
pattern: /^\$\{|\}$/,
alias: "punctuation",
},
rest: Prism.languages.javascript,
},
},
string: /[\s\S]+/,
},
},
"string-property": {
pattern:
/((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
lookbehind: true,
greedy: true,
alias: "property",
},
});
Prism.languages.insertBefore("javascript", "operator", {
"literal-property": {
pattern:
/((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
lookbehind: true,
alias: "property",
},
});
if (Prism.languages.markup) {
Prism.languages.markup.tag.addInlined("script", "javascript");
Prism.languages.markup.tag.addAttribute(
/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/
.source,
"javascript"
);
}
Prism.languages.js = Prism.languages.javascript;
(function (Prism) {
Prism.languages.diff = {
coord: [
/^(?:\*{3}|-{3}|\+{3}).*$/m,
/^@@.*@@$/m,
/^\d.*$/m,
],
};
var PREFIXES = {
"deleted-sign": "-",
"deleted-arrow": "<",
"inserted-sign": "+",
"inserted-arrow": ">",
unchanged: " ",
diff: "!",
};
Object.keys(PREFIXES).forEach(function (name) {
var prefix = PREFIXES[name];
var alias = [];
if (!/^\w+$/.test(name)) {
alias.push(/\w+/.exec(name)[0]);
}
if (name === "diff") {
alias.push("bold");
}
Prism.languages.diff[name] = {
pattern: RegExp("^(?:[" + prefix + "].*(?:\r\n?|\n|(?![\\s\\S])))+", "m"),
alias: alias,
inside: {
line: {
pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
lookbehind: true,
},
prefix: {
pattern: /[\s\S]/,
alias: /\w+/.exec(name)[0],
},
},
};
});
Object.defineProperty(Prism.languages.diff, "PREFIXES", {
value: PREFIXES,
});
})(Prism);
(function () {
if (
typeof Prism === "undefined" ||
typeof document === "undefined" ||
!document.querySelector
) {
return;
}
var LINE_NUMBERS_CLASS = "line-numbers";
var LINKABLE_LINE_NUMBERS_CLASS = "linkable-line-numbers";
var NEW_LINE_EXP = /\n(?!$)/g;
function $$(selector, container) {
return Array.prototype.slice.call(
(container || document).querySelectorAll(selector)
);
}
function hasClass(element, className) {
return element.classList.contains(className);
}
function callFunction(func) {
func();
}
var isLineHeightRounded = (function () {
var res;
return function () {
if (typeof res === "undefined") {
var d = document.createElement("div");
d.style.fontSize = "13px";
d.style.lineHeight = "1.5";
d.style.padding = "0";
d.style.border = "0";
d.innerHTML = " <br /> ";
document.body.appendChild(d);
res = d.offsetHeight === 38;
document.body.removeChild(d);
}
return res;
};
})();
function getContentBoxTopOffset(parent, child) {
var parentStyle = getComputedStyle(parent);
var childStyle = getComputedStyle(child);
function pxToNumber(px) {
return +px.substr(0, px.length - 2);
}
return (
child.offsetTop +
pxToNumber(childStyle.borderTopWidth) +
pxToNumber(childStyle.paddingTop) -
pxToNumber(parentStyle.paddingTop)
);
}
`, do not call `highlightLines` for the given element.
*
* @param {HTMLElement | null | undefined} pre
* @returns {boolean}
*/
function isActiveFor(pre) {
if (!pre || !/pre/i.test(pre.nodeName)) {
return false;
}
if (pre.hasAttribute("data-line")) {
return true;
}
if (pre.id && Prism.util.isActive(pre, LINKABLE_LINE_NUMBERS_CLASS)) {
// Technically, the line numbers plugin is also necessary but this plugin doesn't control the classes of
// the line numbers plugin, so we can't assume that they are present.
return true;
}
return false;
}
var scrollIntoView = true;
Prism.plugins.lineHighlight = {
/**
* Highlights the lines of the given pre.
*
* This function is split into a DOM measuring and mutate phase to improve performance.
* The returned function mutates the DOM when called.
*
* @param {HTMLElement} pre
* @param {string | null} [lines]
* @param {string} [classes='']
* @returns {() => void}
*/
highlightLines: function highlightLines(pre, lines, classes) {
lines =
typeof lines === "string" ? lines : pre.getAttribute("data-line") || "";
var ranges = lines.replace(/\s+/g, "").split(",").filter(Boolean);
var offset = +pre.getAttribute("data-line-offset") || 0;
var parseMethod = isLineHeightRounded() ? parseInt : parseFloat;
var lineHeight = parseMethod(getComputedStyle(pre).lineHeight);
var hasLineNumbers = Prism.util.isActive(pre, LINE_NUMBERS_CLASS);
var codeElement = pre.querySelector("code");
var parentElement = hasLineNumbers ? pre : codeElement || pre;
var mutateActions = /** @type {(() => void)[]} */ ([]);
var lineBreakMatch = codeElement.textContent.match(NEW_LINE_EXP);
var numberOfLines = lineBreakMatch ? lineBreakMatch.length + 1 : 1;
/**
* The top offset between the content box of the <code> element and the content box of the parent element of
* the line highlight element (either `<pre>` or `<code>`).
*
* This offset might not be zero for some themes where the <code> element has a top margin. Some plugins
* (or users) might also add element above the <code> element. Because the line highlight is aligned relative
* to the <pre> element, we have to take this into account.
*
* This offset will be 0 if the parent element of the line highlight element is the `<code>` element.
*/
var codePreOffset =
!codeElement || parentElement == codeElement
? 0
: getContentBoxTopOffset(pre, codeElement);
ranges.forEach(function (currentRange) {
var range = currentRange.split("-");
var start = +range[0];
var end = +range[1] || start;
end = Math.min(numberOfLines + offset, end);
if (end < start) {
return;
}
/** @type {HTMLElement} */
var line =
pre.querySelector(
'.line-highlight[data-range="' + currentRange + '"]'
) || document.createElement("div");
mutateActions.push(function () {
line.setAttribute("aria-hidden", "true");
line.setAttribute("data-range", currentRange);
line.className = (classes || "") + " line-highlight";
});
// if the line-numbers plugin is enabled, then there is no reason for this plugin to display the line numbers
if (hasLineNumbers && Prism.plugins.lineNumbers) {
var startNode = Prism.plugins.lineNumbers.getLine(pre, start);
var endNode = Prism.plugins.lineNumbers.getLine(pre, end);
if (startNode) {
var top = startNode.offsetTop + codePreOffset + "px";
mutateActions.push(function () {
line.style.top = top;
});
}
if (endNode) {
var height =
endNode.offsetTop -
startNode.offsetTop +
endNode.offsetHeight +
"px";
mutateActions.push(function () {
line.style.height = height;
});
}
} else {
mutateActions.push(function () {
line.setAttribute("data-start", String(start));
if (end > start) {
line.setAttribute("data-end", String(end));
}
line.style.top =
(start - offset - 1) * lineHeight + codePreOffset + "px";
line.textContent = new Array(end - start + 2).join(" \n");
});
}
mutateActions.push(function () {
line.style.width = pre.scrollWidth + "px";
});
mutateActions.push(function () {
// allow this to play nicely with the line-numbers plugin
// need to attack to pre as when line-numbers is enabled, the code tag is relatively which screws up the positioning
parentElement.appendChild(line);
});
});
var id = pre.id;
if (
hasLineNumbers &&
Prism.util.isActive(pre, LINKABLE_LINE_NUMBERS_CLASS) &&
id
) {
// This implements linkable line numbers. Linkable line numbers use Line Highlight to create a link to a
// specific line. For this to work, the pre element has to:
// 1) have line numbers,
// 2) have the `linkable-line-numbers` class or an ascendant that has that class, and
// 3) have an id.
if (!hasClass(pre, LINKABLE_LINE_NUMBERS_CLASS)) {
// add class to pre
mutateActions.push(function () {
pre.classList.add(LINKABLE_LINE_NUMBERS_CLASS);
});
}
var start = parseInt(pre.getAttribute("data-start") || "1");
// iterate all line number spans
$$(".line-numbers-rows > span", pre).forEach(function (lineSpan, i) {
var lineNumber = i + start;
lineSpan.onclick = function () {
var hash = id + "." + lineNumber;
// this will prevent scrolling since the span is obviously in view
scrollIntoView = false;
location.hash = hash;
setTimeout(function () {
scrollIntoView = true;
}, 1);
};
});
}
return function () {
mutateActions.forEach(callFunction);
};
},
};
function applyHash() {
var hash = location.hash.slice(1);
// Remove pre-existing temporary lines
$$(".temporary.line-highlight").forEach(function (line) {
line.parentNode.removeChild(line);
});
var range = (hash.match(/\.([\d,-]+)$/) || [, ""])[1];
if (!range || document.getElementById(hash)) {
return;
}
var id = hash.slice(0, hash.lastIndexOf("."));
var pre = document.getElementById(id);
if (!pre) {
return;
}
if (!pre.hasAttribute("data-line")) {
pre.setAttribute("data-line", "");
}
var mutateDom = Prism.plugins.lineHighlight.highlightLines(
pre,
range,
"temporary "
);
mutateDom();
if (scrollIntoView) {
document.querySelector(".temporary.line-highlight").scrollIntoView();
}
}
var fakeTimer = 0; // Hack to limit the number of times applyHash() runs
Prism.hooks.add("before-sanity-check", function (env) {
var pre = env.element.parentElement;
if (!isActiveFor(pre)) {
return;
}
/*
* Cleanup for other plugins (e.g. autoloader).
*
* Sometimes <code> blocks are highlighted multiple times. It is necessary
* to cleanup any left-over tags, because the whitespace inside of the <div>
* tags change the content of the <code> tag.
*/
var num = 0;
$$(".line-highlight", pre).forEach(function (line) {
num += line.textContent.length;
line.parentNode.removeChild(line);
});
// Remove extra whitespace
if (num && /^(?: \n)+$/.test(env.code.slice(-num))) {
env.code = env.code.slice(0, -num);
}
});
Prism.hooks.add("complete", function completeHook(env) {
var pre = env.element.parentElement;
if (!isActiveFor(pre)) {
return;
}
clearTimeout(fakeTimer);
var hasLineNumbers = Prism.plugins.lineNumbers;
var isLineNumbersLoaded = env.plugins && env.plugins.lineNumbers;
if (
hasClass(pre, LINE_NUMBERS_CLASS) &&
hasLineNumbers &&
!isLineNumbersLoaded
) {
Prism.hooks.add("line-numbers", completeHook);
} else {
var mutateDom = Prism.plugins.lineHighlight.highlightLines(pre);
mutateDom();
fakeTimer = setTimeout(applyHash, 1);
}
});
window.addEventListener("hashchange", applyHash);
window.addEventListener("resize", function () {
var actions = $$("pre")
.filter(isActiveFor)
.map(function (pre) {
return Prism.plugins.lineHighlight.highlightLines(pre);
});
actions.forEach(callFunction);
});
})();
(function () {
if (typeof Prism === "undefined" || typeof document === "undefined") {
return;
}
/**
* Plugin name which is used as a class name for <pre> which is activating the plugin
*
* @type {string}
*/
var PLUGIN_NAME = "line-numbers";
/**
* Regular expression used for determining line breaks
*
* @type {RegExp}
*/
var NEW_LINE_EXP = /\n(?!$)/g;
/**
* Global exports
*/
var config = (Prism.plugins.lineNumbers = {
/**
* Get node for provided line number
*
* @param {Element} element pre element
* @param {number} number line number
* @returns {Element|undefined}
*/
getLine: function (element, number) {
if (
element.tagName !== "PRE" ||
!element.classList.contains(PLUGIN_NAME)
) {
return;
}
var lineNumberRows = element.querySelector(".line-numbers-rows");
if (!lineNumberRows) {
return;
}
var lineNumberStart =
parseInt(element.getAttribute("data-start"), 10) || 1;
var lineNumberEnd =
lineNumberStart + (lineNumberRows.children.length - 1);
if (number < lineNumberStart) {
number = lineNumberStart;
}
if (number > lineNumberEnd) {
number = lineNumberEnd;
}
var lineIndex = number - lineNumberStart;
return lineNumberRows.children[lineIndex];
},
/**
* Resizes the line numbers of the given element.
*
* This function will not add line numbers. It will only resize existing ones.
*
* @param {HTMLElement} element A `<pre>` element with line numbers.
* @returns {void}
*/
resize: function (element) {
resizeElements([element]);
},
/**
* Whether the plugin can assume that the units font sizes and margins are not depended on the size of
* the current viewport.
*
* Setting this to `true` will allow the plugin to do certain optimizations for better performance.
*
* Set this to `false` if you use any of the following CSS units: `vh`, `vw`, `vmin`, `vmax`.
*
* @type {boolean}
*/
assumeViewportIndependence: true,
});
/**
* Resizes the given elements.
*
* @param {HTMLElement[]} elements
*/
function resizeElements(elements) {
elements = elements.filter(function (e) {
var codeStyles = getStyles(e);
var whiteSpace = codeStyles["white-space"];
return whiteSpace === "pre-wrap" || whiteSpace === "pre-line";
});
if (elements.length == 0) {
return;
}
var infos = elements
.map(function (element) {
var codeElement = element.querySelector("code");
var lineNumbersWrapper = element.querySelector(".line-numbers-rows");
if (!codeElement || !lineNumbersWrapper) {
return undefined;
}
/** @type {HTMLElement} */
var lineNumberSizer = element.querySelector(".line-numbers-sizer");
var codeLines = codeElement.textContent.split(NEW_LINE_EXP);
if (!lineNumberSizer) {
lineNumberSizer = document.createElement("span");
lineNumberSizer.className = "line-numbers-sizer";
codeElement.appendChild(lineNumberSizer);
}
lineNumberSizer.innerHTML = "0";
lineNumberSizer.style.display = "block";
var oneLinerHeight = lineNumberSizer.getBoundingClientRect().height;
lineNumberSizer.innerHTML = "";
return {
element: element,
lines: codeLines,
lineHeights: [],
oneLinerHeight: oneLinerHeight,
sizer: lineNumberSizer,
};
})
.filter(Boolean);
infos.forEach(function (info) {
var lineNumberSizer = info.sizer;
var lines = info.lines;
var lineHeights = info.lineHeights;
var oneLinerHeight = info.oneLinerHeight;
lineHeights[lines.length - 1] = undefined;
lines.forEach(function (line, index) {
if (line && line.length > 1) {
var e = lineNumberSizer.appendChild(document.createElement("span"));
e.style.display = "block";
e.textContent = line;
} else {
lineHeights[index] = oneLinerHeight;
}
});
});
infos.forEach(function (info) {
var lineNumberSizer = info.sizer;
var lineHeights = info.lineHeights;
var childIndex = 0;
for (var i = 0; i < lineHeights.length; i++) {
if (lineHeights[i] === undefined) {
lineHeights[i] =
lineNumberSizer.children[
childIndex++
].getBoundingClientRect().height;
}
}
});
infos.forEach(function (info) {
var lineNumberSizer = info.sizer;
var wrapper = info.element.querySelector(".line-numbers-rows");
lineNumberSizer.style.display = "none";
lineNumberSizer.innerHTML = "";
info.lineHeights.forEach(function (height, lineNumber) {
wrapper.children[lineNumber].style.height = height + "px";
});
});
}
/**
* Returns style declarations for the element
*
* @param {Element} element
*/
function getStyles(element) {
if (!element) {
return null;
}
return window.getComputedStyle
? getComputedStyle(element)
: element.currentStyle || null;
}
var lastWidth = undefined;
window.addEventListener("resize", function () {
if (config.assumeViewportIndependence && lastWidth === window.innerWidth) {
return;
}
lastWidth = window.innerWidth;
resizeElements(
Array.prototype.slice.call(
document.querySelectorAll("pre." + PLUGIN_NAME)
)
);
});
Prism.hooks.add("complete", function (env) {
if (!env.code) {
return;
}
var code = /** @type {Element} */ (env.element);
var pre = /** @type {HTMLElement} */ (code.parentNode);
// works only for <code> wrapped inside <pre> (not inline)
if (!pre || !/pre/i.test(pre.nodeName)) {
return;
}
// Abort if line numbers already exists
if (code.querySelector(".line-numbers-rows")) {
return;
}
// only add line numbers if <code> or one of its ancestors has the `line-numbers` class
if (!Prism.util.isActive(code, PLUGIN_NAME)) {
return;
}
// Remove the class 'line-numbers' from the <code>
code.classList.remove(PLUGIN_NAME);
// Add the class 'line-numbers' to the <pre>
pre.classList.add(PLUGIN_NAME);
var match = env.code.match(NEW_LINE_EXP);
var linesNum = match ? match.length + 1 : 1;
var lineNumbersWrapper;
var lines = new Array(linesNum + 1).join("<span></span>");
lineNumbersWrapper = document.createElement("span");
lineNumbersWrapper.setAttribute("aria-hidden", "true");
lineNumbersWrapper.className = "line-numbers-rows";
lineNumbersWrapper.innerHTML = lines;
if (pre.hasAttribute("data-start")) {
pre.style.counterReset =
"linenumber " + (parseInt(pre.getAttribute("data-start"), 10) - 1);
}
env.element.appendChild(lineNumbersWrapper);
resizeElements([pre]);
Prism.hooks.run("line-numbers", env);
});
Prism.hooks.add("line-numbers", function (env) {
env.plugins = env.plugins || {};
env.plugins.lineNumbers = true;
});
})();
(function () {
if (typeof Prism === "undefined" || typeof document === "undefined") {
return;
}
/* eslint-disable */
/**
* The dependencies map is built automatically with gulp.
*
* @type {Object<string, string | string[]>}
*/
var lang_dependencies = /*dependencies_placeholder[*/ {
javascript: "clike",
actionscript: "javascript",
apex: ["clike", "sql"],
arduino: "cpp",
aspnet: ["markup", "csharp"],
birb: "clike",
bison: "c",
c: "clike",
csharp: "clike",
cpp: "c",
cfscript: "clike",
chaiscript: ["clike", "cpp"],
cilkc: "c",
cilkcpp: "cpp",
coffeescript: "javascript",
crystal: "ruby",
"css-extras": "css",
d: "clike",
dart: "clike",
django: "markup-templating",
ejs: ["javascript", "markup-templating"],
etlua: ["lua", "markup-templating"],
erb: ["ruby", "markup-templating"],
fsharp: "clike",
"firestore-security-rules": "clike",
flow: "javascript",
ftl: "markup-templating",
gml: "clike",
glsl: "c",
go: "clike",
gradle: "clike",
groovy: "clike",
haml: "ruby",
handlebars: "markup-templating",
haxe: "clike",
hlsl: "c",
idris: "haskell",
java: "clike",
javadoc: ["markup", "java", "javadoclike"],
jolie: "clike",
jsdoc: ["javascript", "javadoclike", "typescript"],
"js-extras": "javascript",
json5: "json",
jsonp: "json",
"js-templates": "javascript",
kotlin: "clike",
latte: ["clike", "markup-templating", "php"],
less: "css",
lilypond: "scheme",
liquid: "markup-templating",
markdown: "markup",
"markup-templating": "markup",
mongodb: "javascript",
n4js: "javascript",
objectivec: "c",
opencl: "c",
parser: "markup",
php: "markup-templating",
phpdoc: ["php", "javadoclike"],
"php-extras": "php",
plsql: "sql",
processing: "clike",
protobuf: "clike",
pug: ["markup", "javascript"],
purebasic: "clike",
purescript: "haskell",
qsharp: "clike",
qml: "javascript",
qore: "clike",
racket: "scheme",
cshtml: ["markup", "csharp"],
jsx: ["markup", "javascript"],
tsx: ["jsx", "typescript"],
reason: "clike",
ruby: "clike",
sass: "css",
scss: "css",
scala: "java",
"shell-session": "bash",
smarty: "markup-templating",
solidity: "clike",
soy: "markup-templating",
sparql: "turtle",
sqf: "clike",
squirrel: "clike",
stata: ["mata", "java", "python"],
"t4-cs": ["t4-templating", "csharp"],
"t4-vb": ["t4-templating", "vbnet"],
tap: "yaml",
tt2: ["clike", "markup-templating"],
textile: "markup",
twig: "markup-templating",
typescript: "javascript",
v: "clike",
vala: "clike",
vbnet: "basic",
velocity: "markup",
wiki: "markup",
xeora: "markup",
"xml-doc": "markup",
xquery: "markup",
}; /*]*/
var lang_aliases = /*aliases_placeholder[*/ {
html: "markup",
xml: "markup",
svg: "markup",
mathml: "markup",
ssml: "markup",
atom: "markup",
rss: "markup",
js: "javascript",
g4: "antlr4",
ino: "arduino",
"arm-asm": "armasm",
art: "arturo",
adoc: "asciidoc",
avs: "avisynth",
avdl: "avro-idl",
gawk: "awk",
sh: "bash",
shell: "bash",
shortcode: "bbcode",
rbnf: "bnf",
oscript: "bsl",
cs: "csharp",
dotnet: "csharp",
cfc: "cfscript",
"cilk-c": "cilkc",
"cilk-cpp": "cilkcpp",
cilk: "cilkcpp",
coffee: "coffeescript",
conc: "concurnas",
jinja2: "django",
"dns-zone": "dns-zone-file",
dockerfile: "docker",
gv: "dot",
eta: "ejs",
xlsx: "excel-formula",
xls: "excel-formula",
gamemakerlanguage: "gml",
po: "gettext",
gni: "gn",
ld: "linker-script",
"go-mod": "go-module",
hbs: "handlebars",
mustache: "handlebars",
hs: "haskell",
idr: "idris",
gitignore: "ignore",
hgignore: "ignore",
npmignore: "ignore",
webmanifest: "json",
kt: "kotlin",
kts: "kotlin",
kum: "kumir",
tex: "latex",
context: "latex",
ly: "lilypond",
emacs: "lisp",
elisp: "lisp",
"emacs-lisp": "lisp",
md: "markdown",
moon: "moonscript",
n4jsd: "n4js",
nani: "naniscript",
objc: "objectivec",
qasm: "openqasm",
objectpascal: "pascal",
px: "pcaxis",
pcode: "peoplecode",
plantuml: "plant-uml",
pq: "powerquery",
mscript: "powerquery",
pbfasm: "purebasic",
purs: "purescript",
py: "python",
qs: "qsharp",
rkt: "racket",
razor: "cshtml",
rpy: "renpy",
res: "rescript",
robot: "robotframework",
rb: "ruby",
"sh-session": "shell-session",
shellsession: "shell-session",
smlnj: "sml",
sol: "solidity",
sln: "solution-file",
rq: "sparql",
sclang: "supercollider",
t4: "t4-cs",
trickle: "tremor",
troy: "tremor",
trig: "turtle",
ts: "typescript",
tsconfig: "typoscript",
uscript: "unrealscript",
uc: "unrealscript",
url: "uri",
vb: "visual-basic",
vba: "visual-basic",
webidl: "web-idl",
mathematica: "wolfram",
nb: "wolfram",
wl: "wolfram",
xeoracube: "xeora",
yml: "yaml",
}; /*]*/
/* eslint-enable */
/**
* @typedef LangDataItem
* @property {{ success?: () => void, error?: () => void }[]} callbacks
* @property {boolean} [error]
* @property {boolean} [loading]
*/
/** @type {Object<string, LangDataItem>} */
var lang_data = {};
var ignored_language = "none";
var languages_path = "/public/assets/prism/components/";
var script = Prism.util.currentScript();
/*if (script) {
var autoloaderFile =
/\bplugins\/autoloader\/prism-autoloader\.(?:min\.)?js(?:\?[^\r\n/]*)?$/i;
var prismFile = /(^|\/)[\w-]+\.(?:min\.)?js(?:\?[^\r\n/]*)?$/i;
var autoloaderPath = script.getAttribute("data-autoloader-path");
if (autoloaderPath != null) {
// data-autoloader-path is set, so just use it
languages_path = autoloaderPath.trim().replace(/\/?$/, "/");
} else {
var src = script.src;
if (autoloaderFile.test(src)) {
// the script is the original autoloader script in the usual Prism project structure
languages_path = src.replace(autoloaderFile, "components/");
} else if (prismFile.test(src)) {
// the script is part of a bundle like a custom prism.js from the download page
languages_path = src.replace(prismFile, "$1components/");
}
}
}*/
var config = (Prism.plugins.autoloader = {
languages_path: languages_path,
use_minified: true,
loadLanguages: loadLanguages,
});
/**
* Lazily loads an external script.
*
* @param {string} src
* @param {() => void} [success]
* @param {() => void} [error]
*/
function addScript(src, success, error) {
var s = document.createElement("script");
s.src = src;
s.async = true;
s.onload = function () {
document.body.removeChild(s);
success && success();
};
s.onerror = function () {
document.body.removeChild(s);
error && error();
};
document.body.appendChild(s);
}
/**
* Returns all additional dependencies of the given element defined by the `data-dependencies` attribute.
*
* @param {Element} element
* @returns {string[]}
*/
function getDependencies(element) {
var deps = (element.getAttribute("data-dependencies") || "").trim();
if (!deps) {
var parent = element.parentElement;
if (parent && parent.tagName.toLowerCase() === "pre") {
deps = (parent.getAttribute("data-dependencies") || "").trim();
}
}
return deps ? deps.split(/\s*,\s*/g) : [];
}
function isLoaded(lang) {
if (lang.indexOf("!") >= 0) {
return false;
}
lang = lang_aliases[lang] || lang;
if (lang in Prism.languages) {
return true;
}
var data = lang_data[lang];
return data && !data.error && data.loading === false;
}
function getLanguagePath(lang) {
return (
config.languages_path +
"prism-" +
lang +
(config.use_minified ? ".min" : "") +
".js"
);
}
function loadLanguages(languages, success, error) {
if (typeof languages === "string") {
languages = [languages];
}
var total = languages.length;
var completed = 0;
var failed = false;
if (total === 0) {
if (success) {
setTimeout(success, 0);
}
return;
}
function successCallback() {
if (failed) {
return;
}
completed++;
if (completed === total) {
success && success(languages);
}
}
languages.forEach(function (lang) {
loadLanguage(lang, successCallback, function () {
if (failed) {
return;
}
failed = true;
error && error(lang);
});
});
}
function loadLanguage(lang, success, error) {
var force = lang.indexOf("!") >= 0;
lang = lang.replace("!", "");
lang = lang_aliases[lang] || lang;
function load() {
var data = lang_data[lang];
if (!data) {
data = lang_data[lang] = {
callbacks: [],
};
}
data.callbacks.push({
success: success,
error: error,
});
if (!force && isLoaded(lang)) {
languageCallback(lang, "success");
} else if (!force && data.error) {
languageCallback(lang, "error");
} else if (force || !data.loading) {
data.loading = true;
data.error = false;
addScript(
getLanguagePath(lang),
function () {
data.loading = false;
languageCallback(lang, "success");
},
function () {
data.loading = false;
data.error = true;
languageCallback(lang, "error");
}
);
}
}
var dependencies = lang_dependencies[lang];
if (dependencies && dependencies.length) {
loadLanguages(dependencies, load, error);
} else {
load();
}
}
function languageCallback(lang, type) {
if (lang_data[lang]) {
var callbacks = lang_data[lang].callbacks;
for (var i = 0, l = callbacks.length; i < l; i++) {
var callback = callbacks[i][type];
if (callback) {
setTimeout(callback, 0);
}
}
callbacks.length = 0;
}
}
Prism.hooks.add("complete", function (env) {
var element = env.element;
var language = env.language;
if (!element || !language || language === ignored_language) {
return;
}
var deps = getDependencies(element);
if (/^diff-./i.test(language)) {
deps.push("diff");
deps.push(language.substr("diff-".length));
} else {
deps.push(language);
}
if (!deps.every(isLoaded)) {
loadLanguages(deps, function () {
Prism.highlightElement(element);
});
}
});
})();
(function () {
if (typeof Prism === "undefined") {
return;
}
var assign =
Object.assign ||
function (obj1, obj2) {
for (var name in obj2) {
if (obj2.hasOwnProperty(name)) {
obj1[name] = obj2[name];
}
}
return obj1;
};
function NormalizeWhitespace(defaults) {
this.defaults = assign({}, defaults);
}
function toCamelCase(value) {
return value.replace(/-(\w)/g, function (match, firstChar) {
return firstChar.toUpperCase();
});
}
function tabLen(str) {
var res = 0;
for (var i = 0; i < str.length; ++i) {
if (str.charCodeAt(i) == "\t".charCodeAt(0)) {
res += 3;
}
}
return str.length + res;
}
var settingsConfig = {
"remove-trailing": "boolean",
"remove-indent": "boolean",
"left-trim": "boolean",
"right-trim": "boolean",
"break-lines": "number",
indent: "number",
"remove-initial-line-feed": "boolean",
"tabs-to-spaces": "number",
"spaces-to-tabs": "number",
};
NormalizeWhitespace.prototype = {
setDefaults: function (defaults) {
this.defaults = assign(this.defaults, defaults);
},
normalize: function (input, settings) {
settings = assign(this.defaults, settings);
for (var name in settings) {
var methodName = toCamelCase(name);
if (
name !== "normalize" &&
methodName !== "setDefaults" &&
settings[name] &&
this[methodName]
) {
input = this[methodName].call(this, input, settings[name]);
}
}
return input;
},
leftTrim: function (input) {
return input.replace(/^\s+/, "");
},
rightTrim: function (input) {
return input.replace(/\s+$/, "");
},
tabsToSpaces: function (input, spaces) {
spaces = spaces | 0 || 4;
return input.replace(/\t/g, new Array(++spaces).join(" "));
},
spacesToTabs: function (input, spaces) {
spaces = spaces | 0 || 4;
return input.replace(RegExp(" {" + spaces + "}", "g"), "\t");
},
removeTrailing: function (input) {
return input.replace(/\s*?$/gm, "");
},
removeInitialLineFeed: function (input) {
return input.replace(/^(?:\r?\n|\r)/, "");
},
removeIndent: function (input) {
var indents = input.match(/^[^\S\n\r]*(?=\S)/gm);
if (!indents || !indents[0].length) {
return input;
}
indents.sort(function (a, b) {
return a.length - b.length;
});
if (!indents[0].length) {
return input;
}
return input.replace(RegExp("^" + indents[0], "gm"), "");
},
indent: function (input, tabs) {
return input.replace(
/^[^\S\n\r]*(?=\S)/gm,
new Array(++tabs).join("\t") + "$&"
);
},
breakLines: function (input, characters) {
characters = characters === true ? 80 : characters | 0 || 80;
var lines = input.split("\n");
for (var i = 0; i < lines.length; ++i) {
if (tabLen(lines[i]) <= characters) {
continue;
}
var line = lines[i].split(/(\s+)/g);
var len = 0;
for (var j = 0; j < line.length; ++j) {
var tl = tabLen(line[j]);
len += tl;
if (len > characters) {
line[j] = "\n" + line[j];
len = tl;
}
}
lines[i] = line.join("");
}
return lines.join("\n");
},
};
if (typeof module !== "undefined" && module.exports) {
module.exports = NormalizeWhitespace;
}
Prism.plugins.NormalizeWhitespace = new NormalizeWhitespace({
"remove-trailing": true,
"remove-indent": true,
"left-trim": true,
"right-trim": true,
});
Prism.hooks.add("before-sanity-check", function (env) {
var Normalizer = Prism.plugins.NormalizeWhitespace;
if (env.settings && env.settings["whitespace-normalization"] === false) {
return;
}
if (!Prism.util.isActive(env.element, "whitespace-normalization", true)) {
return;
}
if ((!env.element || !env.element.parentNode) && env.code) {
env.code = Normalizer.normalize(env.code, env.settings);
return;
}
var pre = env.element.parentNode;
if (!env.code || !pre || pre.nodeName.toLowerCase() !== "pre") {
return;
}
if (env.settings == null) {
env.settings = {};
}
for (var key in settingsConfig) {
if (Object.hasOwnProperty.call(settingsConfig, key)) {
var settingType = settingsConfig[key];
if (pre.hasAttribute("data-" + key)) {
try {
var value = JSON.parse(pre.getAttribute("data-" + key) || "true");
if (typeof value === settingType) {
env.settings[key] = value;
}
} catch (_error) {
}
}
}
}
var children = pre.childNodes;
var before = "";
var after = "";
var codeFound = false;
for (var i = 0; i < children.length; ++i) {
var node = children[i];
if (node == env.element) {
codeFound = true;
} else if (node.nodeName === "#text") {
if (codeFound) {
after += node.nodeValue;
} else {
before += node.nodeValue;
}
pre.removeChild(node);
--i;
}
}
if (!env.element.children.length || !Prism.plugins.KeepMarkup) {
env.code = before + env.code + after;
env.code = Normalizer.normalize(env.code, env.settings);
} else {
var html = before + env.element.innerHTML + after;
env.element.innerHTML = Normalizer.normalize(html, env.settings);
env.code = env.element.textContent;
}
});
})();
(function () {
if (typeof Prism === "undefined") {
return;
}
var LANGUAGE_REGEX = /^diff-([\w-]+)/i;
var HTML_TAG =
/<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/g;
var HTML_LINE = RegExp(
/(?:__|[^\r\n<])*(?:\r\n?|\n|(?:__|[^\r\n<])(?![^\r\n]))/.source.replace(
/__/g,
function () {
return HTML_TAG.source;
}
),
"gi"
);
var warningLogged = false;
Prism.hooks.add("before-sanity-check", function (env) {
var lang = env.language;
if (LANGUAGE_REGEX.test(lang) && !env.grammar) {
env.grammar = Prism.languages[lang] = Prism.languages.diff;
}
});
Prism.hooks.add("before-tokenize", function (env) {
if (!warningLogged && !Prism.languages.diff && !Prism.plugins.autoloader) {
warningLogged = true;
console.warn(
"Prism's Diff Highlight plugin requires the Diff language definition (prism-diff.js)." +
"Make sure the language definition is loaded or use Prism's Autoloader plugin."
);
}
var lang = env.language;
if (LANGUAGE_REGEX.test(lang) && !Prism.languages[lang]) {
Prism.languages[lang] = Prism.languages.diff;
}
});
Prism.hooks.add("wrap", function (env) {
var diffLanguage;
var diffGrammar;
if (env.language !== "diff") {
var langMatch = LANGUAGE_REGEX.exec(env.language);
if (!langMatch) {
return;
}
diffLanguage = langMatch[1];
diffGrammar = Prism.languages[diffLanguage];
}
var PREFIXES = Prism.languages.diff && Prism.languages.diff.PREFIXES;
if (PREFIXES && env.type in PREFIXES) {
var content = env.content.replace(HTML_TAG, "");
var decoded = content.replace(/</g, "<").replace(/&/g, "&");
var code = decoded.replace(/(^|[\r\n])./g, "$1");
var highlighted;
if (diffGrammar) {
highlighted = Prism.highlight(code, diffGrammar, diffLanguage);
} else {
highlighted = Prism.util.encode(code);
}
var prefixToken = new Prism.Token("prefix", PREFIXES[env.type], [
/\w+/.exec(env.type)[0],
]);
var prefix = Prism.Token.stringify(prefixToken, env.language);
var lines = [];
var m;
HTML_LINE.lastIndex = 0;
while ((m = HTML_LINE.exec(highlighted))) {
lines.push(prefix + m[0]);
}
if (/(?:^|[\r\n]).$/.test(decoded)) {
lines.push(prefix);
}
env.content = lines.join("");
if (diffGrammar) {
env.classes.push("language-" + diffLanguage);
}
}
});
})();