ds-algo-study
Version:
Just experimenting with publishing a package
1,253 lines (1,243 loc) • 168 kB
JavaScript
/* PrismJS 1.23.0
https://prismjs.com/download.html#themes=prism-twilight&languages=markup+css+clike+javascript+bash+c+cpp+css-extras+docker+git+go+graphql+groovy+http+json+json5+jsonp+jsstacktrace+js-templates+markdown+markup-templating+matlab+mongodb+perl+php+powershell+python+racket+jsx+tsx+regex+rest+ruby+rust+sas+sass+scss+scheme+sql+typescript+xml-doc+yaml&plugins=line-highlight+line-numbers+autolinker+file-highlight+show-language+highlight-keywords+inline-color+autoloader+command-line+toolbar+copy-to-clipboard+download-button+match-braces+treeview */
var _self = "undefined" != typeof window ? window : "undefined" != typeof WorkerGlobalScope && self instanceof WorkerGlobalScope ? self : {},
Prism = function ( u ) {
var c = /\blang(?:uage)?-([\w-]+)\b/i,
n = 0,
M = {
manual: u.Prism && u.Prism.manual,
disableWorkerMessageHandler: u.Prism && u.Prism.disableWorkerMessageHandler,
util: {
encode: function e( n ) {
return n instanceof W ? new W( n.type, e( n.content ), n.alias ) : Array.isArray( n ) ? n.map( e ) : n.replace( /&/g, "&" ).replace( /</g, "<" ).replace( /\u00a0/g, " " )
},
type: function ( e ) {
return Object.prototype.toString.call( e ).slice( 8, -1 )
},
objId: function ( e ) {
return e.__id || Object.defineProperty( e, "__id", {
value: ++n
} ), e.__id
},
clone: function r( e, t ) {
var a, n;
switch ( t = t || {}, M.util.type( e ) ) {
case "Object":
if ( n = M.util.objId( e ), t[ n ] ) return t[ n ];
for ( var i in a = {}, t[ n ] = a, e ) e.hasOwnProperty( i ) && ( a[ i ] = r( e[ i ], t ) );
return a;
case "Array":
return n = M.util.objId( e ), t[ n ] ? t[ n ] : ( a = [], t[ n ] = a, e.forEach( function ( e, n ) {
a[ n ] = r( e, t )
} ), a );
default:
return e
}
},
getLanguage: function ( e ) {
for ( ; e && !c.test( e.className ); ) e = e.parentElement;
return e ? ( e.className.match( c ) || [ , "none" ] )[ 1 ].toLowerCase() : "none"
},
currentScript: function () {
if ( "undefined" == typeof document ) return null;
if ( "currentScript" in document ) return document.currentScript;
try {
throw new Error
} catch ( e ) {
var n = ( /at [^(\r\n]*\((.*):.+:.+\)$/i.exec( e.stack ) || [] )[ 1 ];
if ( n ) {
var r = document.getElementsByTagName( "script" );
for ( var t in r )
if ( r[ t ].src == n ) return r[ t ]
}
return null
}
},
isActive: function ( e, n, r ) {
for ( var t = "no-" + n; e; ) {
var a = e.classList;
if ( a.contains( n ) ) return !0;
if ( a.contains( t ) ) return !1;
e = e.parentElement
}
return !!r
}
},
languages: {
extend: function ( e, n ) {
var r = M.util.clone( M.languages[ e ] );
for ( var t in n ) r[ t ] = n[ t ];
return r
},
insertBefore: function ( r, e, n, t ) {
var a = ( t = t || M.languages )[ r ],
i = {};
for ( var l in a )
if ( a.hasOwnProperty( l ) ) {
if ( l == e )
for ( var o in n ) n.hasOwnProperty( o ) && ( i[ o ] = n[ o ] );
n.hasOwnProperty( l ) || ( i[ l ] = a[ l ] )
} var s = t[ r ];
return t[ r ] = i, M.languages.DFS( M.languages, function ( e, n ) {
n === s && e != r && ( this[ e ] = i )
} ), i
},
DFS: function e( n, r, t, a ) {
a = a || {};
var i = M.util.objId;
for ( var l in n )
if ( n.hasOwnProperty( l ) ) {
r.call( n, l, n[ l ], t || l );
var o = n[ l ],
s = M.util.type( o );
"Object" !== s || a[ i( o ) ] ? "Array" !== s || a[ i( o ) ] || ( a[ i( o ) ] = !0, e( o, r, l, a ) ) : ( a[ i( o ) ] = !0, e( o, r, null, a ) )
}
}
},
plugins: {},
highlightAll: function ( e, n ) {
M.highlightAllUnder( document, e, n )
},
highlightAllUnder: function ( e, n, r ) {
var t = {
callback: r,
container: e,
selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
};
M.hooks.run( "before-highlightall", t ), t.elements = Array.prototype.slice.apply( t.container.querySelectorAll( t.selector ) ), M.hooks.run( "before-all-elements-highlight", t );
for ( var a, i = 0; a = t.elements[ i++ ]; ) M.highlightElement( a, !0 === n, t.callback )
},
highlightElement: function ( e, n, r ) {
var t = M.util.getLanguage( e ),
a = M.languages[ t ];
e.className = e.className.replace( c, "" ).replace( /\s+/g, " " ) + " language-" + t;
var i = e.parentElement;
i && "pre" === i.nodeName.toLowerCase() && ( i.className = i.className.replace( c, "" ).replace( /\s+/g, " " ) + " language-" + t );
var l = {
element: e,
language: t,
grammar: a,
code: e.textContent
};
function o( e ) {
l.highlightedCode = e, M.hooks.run( "before-insert", l ), l.element.innerHTML = l.highlightedCode, M.hooks.run( "after-highlight", l ), M.hooks.run( "complete", l ), r && r.call( l.element )
}
if ( M.hooks.run( "before-sanity-check", l ), !l.code ) return M.hooks.run( "complete", l ), void( r && r.call( l.element ) );
if ( M.hooks.run( "before-highlight", l ), l.grammar )
if ( n && u.Worker ) {
var s = new Worker( M.filename );
s.onmessage = function ( e ) {
o( e.data )
}, s.postMessage( JSON.stringify( {
language: l.language,
code: l.code,
immediateClose: !0
} ) )
} else o( M.highlight( l.code, l.grammar, l.language ) );
else o( M.util.encode( l.code ) )
},
highlight: function ( e, n, r ) {
var t = {
code: e,
grammar: n,
language: r
};
return M.hooks.run( "before-tokenize", t ), t.tokens = M.tokenize( t.code, t.grammar ), M.hooks.run( "after-tokenize", t ), W.stringify( M.util.encode( t.tokens ), t.language )
},
tokenize: function ( e, n ) {
var r = n.rest;
if ( r ) {
for ( var t in r ) n[ t ] = r[ t ];
delete n.rest
}
var a = new i;
return I( a, a.head, e ),
function e( n, r, t, a, i, l ) {
for ( var o in t )
if ( t.hasOwnProperty( o ) && t[ o ] ) {
var s = t[ o ];
s = Array.isArray( s ) ? s : [ s ];
for ( var u = 0; u < s.length; ++u ) {
if ( l && l.cause == o + "," + u ) return;
var c = s[ u ],
g = c.inside,
f = !!c.lookbehind,
h = !!c.greedy,
d = c.alias;
if ( h && !c.pattern.global ) {
var v = c.pattern.toString().match( /[imsuy]*$/ )[ 0 ];
c.pattern = RegExp( c.pattern.source, v + "g" )
}
for ( var p = c.pattern || c, m = a.next, y = i; m !== r.tail && !( l && y >= l.reach ); y += m.value.length, m = m.next ) {
var k = m.value;
if ( r.length > n.length ) return;
if ( !( k instanceof W ) ) {
var b, x = 1;
if ( h ) {
if ( !( b = z( p, y, n, f ) ) ) break;
var w = b.index,
A = b.index + b[ 0 ].length,
P = y;
for ( P += m.value.length; P <= w; ) m = m.next, P += m.value.length;
if ( P -= m.value.length, y = P, m.value instanceof W ) continue;
for ( var S = m; S !== r.tail && ( P < A || "string" == typeof S.value ); S = S.next ) x++, P += S.value.length;
x--, k = n.slice( y, P ), b.index -= y
} else if ( !( b = z( p, 0, k, f ) ) ) continue;
var w = b.index,
E = b[ 0 ],
O = k.slice( 0, w ),
L = k.slice( w + E.length ),
N = y + k.length;
l && N > l.reach && ( l.reach = N );
var j = m.prev;
O && ( j = I( r, j, O ), y += O.length ), q( r, j, x );
var C = new W( o, g ? M.tokenize( E, g ) : E, d, E );
if ( m = I( r, j, C ), L && I( r, m, L ), 1 < x ) {
var _ = {
cause: o + "," + u,
reach: N
};
e( n, r, t, m.prev, y, _ ), l && _.reach > l.reach && ( l.reach = _.reach )
}
}
}
}
}
}( e, a, n, a.head, 0 ),
function ( e ) {
var n = [],
r = e.head.next;
for ( ; r !== e.tail; ) n.push( r.value ), r = r.next;
return n
}( a )
},
hooks: {
all: {},
add: function ( e, n ) {
var r = M.hooks.all;
r[ e ] = r[ e ] || [], r[ e ].push( n )
},
run: function ( e, n ) {
var r = M.hooks.all[ e ];
if ( r && r.length )
for ( var t, a = 0; t = r[ a++ ]; ) t( n )
}
},
Token: W
};
function W( e, n, r, t ) {
this.type = e, this.content = n, this.alias = r, this.length = 0 | ( t || "" ).length
}
function z( e, n, r, t ) {
e.lastIndex = n;
var a = e.exec( r );
if ( a && t && a[ 1 ] ) {
var i = a[ 1 ].length;
a.index += i, a[ 0 ] = a[ 0 ].slice( i )
}
return a
}
function i() {
var e = {
value: null,
prev: null,
next: null
},
n = {
value: null,
prev: e,
next: null
};
e.next = n, this.head = e, this.tail = n, this.length = 0
}
function I( e, n, r ) {
var t = n.next,
a = {
value: r,
prev: n,
next: t
};
return n.next = a, t.prev = a, e.length++, a
}
function q( e, n, r ) {
for ( var t = n.next, a = 0; a < r && t !== e.tail; a++ ) t = t.next;
( n.next = t ).prev = n, e.length -= a
}
if ( u.Prism = M, W.stringify = function n( e, r ) {
if ( "string" == typeof e ) return e;
if ( Array.isArray( e ) ) {
var t = "";
return e.forEach( function ( e ) {
t += n( e, r )
} ), t
}
var a = {
type: e.type,
content: n( e.content, r ),
tag: "span",
classes: [ "token", e.type ],
attributes: {},
language: r
},
i = e.alias;
i && ( Array.isArray( i ) ? Array.prototype.push.apply( a.classes, i ) : a.classes.push( i ) ), M.hooks.run( "wrap", a );
var l = "";
for ( var o in a.attributes ) l += " " + o + '="' + ( a.attributes[ o ] || "" ).replace( /"/g, """ ) + '"';
return "<" + a.tag + ' class="' + a.classes.join( " " ) + '"' + l + ">" + a.content + "</" + a.tag + ">"
}, !u.document ) return u.addEventListener && ( M.disableWorkerMessageHandler || u.addEventListener( "message", function ( e ) {
var n = JSON.parse( e.data ),
r = n.language,
t = n.code,
a = n.immediateClose;
u.postMessage( M.highlight( t, M.languages[ r ], r ) ), a && u.close()
}, !1 ) ), M;
var e = M.util.currentScript();
function r() {
M.manual || M.highlightAll()
}
if ( e && ( M.filename = e.src, e.hasAttribute( "data-manual" ) && ( M.manual = !0 ) ), !M.manual ) {
var t = document.readyState;
"loading" === t || "interactive" === t && e && e.defer ? document.addEventListener( "DOMContentLoaded", r ) : window.requestAnimationFrame ? window.requestAnimationFrame( r ) : window.setTimeout( r, 16 )
}
return M
}( _self );
"undefined" != typeof module && module.exports && ( module.exports = Prism ), "undefined" != typeof global && ( global.Prism = Prism );
Prism.languages.markup = {
comment: /<!--[\s\S]*?-->/,
prolog: /<\?[\s\S]+?\?>/,
doctype: {
pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
greedy: !0,
inside: {
"internal-subset": {
pattern: /(\[)[\s\S]+(?=\]>$)/,
lookbehind: !0,
greedy: !0,
inside: null
},
string: {
pattern: /"[^"]*"|'[^']*'/,
greedy: !0
},
punctuation: /^<!|>$|[[\]]/,
"doctype-tag": /^DOCTYPE/,
name: /[^\s<>'"]+/
}
},
cdata: /<!\[CDATA\[[\s\S]*?]]>/i,
tag: {
pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
greedy: !0,
inside: {
tag: {
pattern: /^<\/?[^\s>\/]+/,
inside: {
punctuation: /^<\/?/,
namespace: /^[^\s>\/:]+:/
}
},
"attr-value": {
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
inside: {
punctuation: [ {
pattern: /^=/,
alias: "attr-equals"
}, /"|'/ ]
}
},
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 ( a ) {
"entity" === a.type && ( a.attributes.title = a.content.replace( /&/, "&" ) )
} ), Object.defineProperty( Prism.languages.markup.tag, "addInlined", {
value: function ( a, e ) {
var s = {};
s[ "language-" + e ] = {
pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
lookbehind: !0,
inside: Prism.languages[ e ]
}, s.cdata = /^<!\[CDATA\[|\]\]>$/i;
var n = {
"included-cdata": {
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
inside: s
}
};
n[ "language-" + e ] = {
pattern: /[\s\S]+/,
inside: Prism.languages[ e ]
};
var t = {};
t[ a ] = {
pattern: RegExp( "(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[^])*?(?=</__>)".replace( /__/g, function () {
return a
} ), "i" ),
lookbehind: !0,
greedy: !0,
inside: n
}, Prism.languages.insertBefore( "markup", "cdata", t )
}
} ), 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 ( s ) {
var e = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
s.languages.css = {
comment: /\/\*[\s\S]*?\*\//,
atrule: {
pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
inside: {
rule: /^@[\w-]+/,
"selector-function-argument": {
pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
lookbehind: !0,
alias: "selector"
},
keyword: {
pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
lookbehind: !0
}
}
},
url: {
pattern: RegExp( "\\burl\\((?:" + e.source + "|(?:[^\\\\\r\n()\"']|\\\\[^])*)\\)", "i" ),
greedy: !0,
inside: {
function: /^url/i,
punctuation: /^\(|\)$/,
string: {
pattern: RegExp( "^" + e.source + "$" ),
alias: "url"
}
}
},
selector: RegExp( "[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" + e.source + ")*(?=\\s*\\{)" ),
string: {
pattern: e,
greedy: !0
},
property: /(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
important: /!important\b/i,
function: /[-a-z0-9]+(?=\()/i,
punctuation: /[(){};:,]/
}, s.languages.css.atrule.inside.rest = s.languages.css;
var t = s.languages.markup;
t && ( t.tag.addInlined( "style", "css" ), s.languages.insertBefore( "inside", "attr-value", {
"style-attr": {
pattern: /(^|["'\s])style\s*=\s*(?:"[^"]*"|'[^']*')/i,
lookbehind: !0,
inside: {
"attr-value": {
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
inside: {
style: {
pattern: /(["'])[\s\S]+(?=["']$)/,
lookbehind: !0,
alias: "language-css",
inside: s.languages.css
},
punctuation: [ {
pattern: /^=/,
alias: "attr-equals"
}, /"|'/ ]
}
},
"attr-name": /^style/i
}
}
}, t.tag ) )
}( Prism );
Prism.languages.clike = {
comment: [ {
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
lookbehind: !0,
greedy: !0
}, {
pattern: /(^|[^\\:])\/\/.*/,
lookbehind: !0,
greedy: !0
} ],
string: {
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
greedy: !0
},
"class-name": {
pattern: /(\b(?:class|interface|extends|implements|trait|instanceof|new)\s+|\bcatch\s+\()[\w.\\]+/i,
lookbehind: !0,
inside: {
punctuation: /[.\\]/
}
},
keyword: /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
boolean: /\b(?:true|false)\b/,
function: /\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])*(?=\.(?:prototype|constructor))/,
lookbehind: !0
} ],
keyword: [ {
pattern: /((?:^|})\s*)catch\b/,
lookbehind: !0
}, {
pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|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: !0
} ],
function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
number: /\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,
operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
} ), Prism.languages.javascript[ "class-name" ][ 0 ].pattern = /(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/, Prism.languages.insertBefore( "javascript", "keyword", {
regex: {
pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
lookbehind: !0,
greedy: !0,
inside: {
"regex-source": {
pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
lookbehind: !0,
alias: "language-regex",
inside: Prism.languages.regex
},
"regex-flags": /[a-z]+$/,
"regex-delimiter": /^\/|\/$/
}
},
"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: !0,
inside: Prism.languages.javascript
}, {
pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
inside: Prism.languages.javascript
}, {
pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
lookbehind: !0,
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: !0,
inside: Prism.languages.javascript
} ],
constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
} ), Prism.languages.insertBefore( "javascript", "string", {
"template-string": {
pattern: /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\${)[^\\`])*`/,
greedy: !0,
inside: {
"template-punctuation": {
pattern: /^`|`$/,
alias: "string"
},
interpolation: {
pattern: /((?:^|[^\\])(?:\\{2})*)\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,
lookbehind: !0,
inside: {
"interpolation-punctuation": {
pattern: /^\${|}$/,
alias: "punctuation"
},
rest: Prism.languages.javascript
}
},
string: /[\s\S]+/
}
}
} ), Prism.languages.markup && Prism.languages.markup.tag.addInlined( "script", "javascript" ), Prism.languages.js = Prism.languages.javascript;
! function ( e ) {
var t = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b",
n = {
pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
lookbehind: !0,
alias: "punctuation",
inside: null
},
a = {
bash: n,
environment: {
pattern: RegExp( "\\$" + t ),
alias: "constant"
},
variable: [ {
pattern: /\$?\(\([\s\S]+?\)\)/,
greedy: !0,
inside: {
variable: [ {
pattern: /(^\$\(\([\s\S]+)\)\)/,
lookbehind: !0
}, /^\$\(\(/ ],
number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
operator: /--?|-=|\+\+?|\+=|!=?|~|\*\*?|\*=|\/=?|%=?|<<=?|>>=?|<=?|>=?|==?|&&?|&=|\^=?|\|\|?|\|=|\?|:/,
punctuation: /\(\(?|\)\)?|,|;/
}
}, {
pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
greedy: !0,
inside: {
variable: /^\$\(|^`|\)$|`$/
}
}, {
pattern: /\$\{[^}]+\}/,
greedy: !0,
inside: {
operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
punctuation: /[\[\]]/,
environment: {
pattern: RegExp( "(\\{)" + t ),
lookbehind: !0,
alias: "constant"
}
}
}, /\$(?:\w+|[#?*!@$])/ ],
entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})/
};
e.languages.bash = {
shebang: {
pattern: /^#!\s*\/.*/,
alias: "important"
},
comment: {
pattern: /(^|[^"{\\$])#.*/,
lookbehind: !0
},
"function-name": [ {
pattern: /(\bfunction\s+)\w+(?=(?:\s*\(?:\s*\))?\s*\{)/,
lookbehind: !0,
alias: "function"
}, {
pattern: /\b\w+(?=\s*\(\s*\)\s*\{)/,
alias: "function"
} ],
"for-or-select": {
pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
alias: "variable",
lookbehind: !0
},
"assign-left": {
pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
inside: {
environment: {
pattern: RegExp( "(^|[\\s;|&]|[<>]\\()" + t ),
lookbehind: !0,
alias: "constant"
}
},
alias: "variable",
lookbehind: !0
},
string: [ {
pattern: /((?:^|[^<])<<-?\s*)(\w+?)\s[\s\S]*?(?:\r?\n|\r)\2/,
lookbehind: !0,
greedy: !0,
inside: a
}, {
pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
lookbehind: !0,
greedy: !0,
inside: {
bash: n
}
}, {
pattern: /(^|[^\\](?:\\\\)*)(["'])(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|(?!\2)[^\\`$])*\2/,
lookbehind: !0,
greedy: !0,
inside: a
} ],
environment: {
pattern: RegExp( "\\$?" + t ),
alias: "constant"
},
variable: a.variable,
function: {
pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|aptitude|apt-cache|apt-get|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
lookbehind: !0
},
keyword: {
pattern: /(^|[\s;|&]|[<>]\()(?:if|then|else|elif|fi|for|while|in|case|esac|function|select|do|done|until)(?=$|[)\s;|&])/,
lookbehind: !0
},
builtin: {
pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|break|cd|continue|eval|exec|exit|export|getopts|hash|pwd|readonly|return|shift|test|times|trap|umask|unset|alias|bind|builtin|caller|command|declare|echo|enable|help|let|local|logout|mapfile|printf|read|readarray|source|type|typeset|ulimit|unalias|set|shopt)(?=$|[)\s;|&])/,
lookbehind: !0,
alias: "class-name"
},
boolean: {
pattern: /(^|[\s;|&]|[<>]\()(?:true|false)(?=$|[)\s;|&])/,
lookbehind: !0
},
"file-descriptor": {
pattern: /\B&\d\b/,
alias: "important"
},
operator: {
pattern: /\d?<>|>\||\+=|==?|!=?|=~|<<[<-]?|[&\d]?>>|\d?[<>]&?|&[>&]?|\|[&|]?|<=?|>=?/,
inside: {
"file-descriptor": {
pattern: /^\d/,
alias: "important"
}
}
},
punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
number: {
pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
lookbehind: !0
}
}, n.inside = e.languages.bash;
for ( var s = [ "comment", "function-name", "for-or-select", "assign-left", "string", "environment", "function", "keyword", "builtin", "boolean", "file-descriptor", "operator", "punctuation", "number" ], i = a.variable[ 1 ].inside, o = 0; o < s.length; o++ ) i[ s[ o ] ] = e.languages.bash[ s[ o ] ];
e.languages.shell = e.languages.bash
}( Prism );
Prism.languages.c = Prism.languages.extend( "clike", {
comment: {
pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
greedy: !0
},
"class-name": {
pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
lookbehind: !0
},
keyword: /\b(?:__attribute__|_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)\b/,
function: /[a-z_]\w*(?=\s*\()/i,
number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
} ), Prism.languages.insertBefore( "c", "string", {
macro: {
pattern: /(^\s*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
lookbehind: !0,
greedy: !0,
alias: "property",
inside: {
string: [ {
pattern: /^(#\s*include\s*)<[^>]+>/,
lookbehind: !0
}, Prism.languages.c.string ],
comment: Prism.languages.c.comment,
"macro-name": [ {
pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
lookbehind: !0
}, {
pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
lookbehind: !0,
alias: "function"
} ],
directive: {
pattern: /^(#\s*)[a-z]+/,
lookbehind: !0,
alias: "keyword"
},
"directive-hash": /^#/,
punctuation: /##|\\(?=[\r\n])/,
expression: {
pattern: /\S[\s\S]*/,
inside: Prism.languages.c
}
}
},
constant: /\b(?:__FILE__|__LINE__|__DATE__|__TIME__|__TIMESTAMP__|__func__|EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|stdin|stdout|stderr)\b/
} ), delete Prism.languages.c.boolean;
! function ( e ) {
var t = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char8_t|char16_t|char32_t|class|compl|concept|const|consteval|constexpr|constinit|const_cast|continue|co_await|co_return|co_yield|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
e.languages.cpp = e.languages.extend( "c", {
"class-name": [ {
pattern: RegExp( "(\\b(?:class|concept|enum|struct|typename)\\s+)(?!<keyword>)\\w+".replace( /<keyword>/g, function () {
return t.source
} ) ),
lookbehind: !0
}, /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, /\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/ ],
keyword: t,
number: {
pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
greedy: !0
},
operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
boolean: /\b(?:true|false)\b/
} ), e.languages.insertBefore( "cpp", "string", {
"raw-string": {
pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
alias: "string",
greedy: !0
}
} ), e.languages.insertBefore( "cpp", "class-name", {
"base-clause": {
pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
lookbehind: !0,
greedy: !0,
inside: e.languages.extend( "cpp", {} )
}
} ), e.languages.insertBefore( "inside", "operator", {
"class-name": /\b[a-z_]\w*\b(?!\s*::)/i
}, e.languages.cpp[ "base-clause" ] )
}( Prism );
! function ( e ) {
var a, n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
e.languages.css.selector = {
pattern: e.languages.css.selector,
inside: a = {
"pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
"pseudo-class": /:[-\w]+/,
class: /\.[-\w]+/,
id: /#[-\w]+/,
attribute: {
pattern: RegExp( "\\[(?:[^[\\]\"']|" + n.source + ")*\\]" ),
greedy: !0,
inside: {
punctuation: /^\[|\]$/,
"case-sensitivity": {
pattern: /(\s)[si]$/i,
lookbehind: !0,
alias: "keyword"
},
namespace: {
pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
lookbehind: !0,
inside: {
punctuation: /\|$/
}
},
"attr-name": {
pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
lookbehind: !0
},
"attr-value": [ n, {
pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
lookbehind: !0
} ],
operator: /[|~*^$]?=/
}
},
"n-th": [ {
pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
lookbehind: !0,
inside: {
number: /[\dn]+/,
operator: /[+-]/
}
}, {
pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
lookbehind: !0
} ],
combinator: />|\+|~|\|\|/,
punctuation: /[(),]/
}
}, e.languages.css.atrule.inside[ "selector-function-argument" ].inside = a, e.languages.insertBefore( "css", "property", {
variable: {
pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
lookbehind: !0
}
} );
var r = {
pattern: /(\b\d+)(?:%|[a-z]+\b)/,
lookbehind: !0
},
i = {
pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
lookbehind: !0
};
e.languages.insertBefore( "css", "function", {
operator: {
pattern: /(\s)[+\-*\/](?=\s)/,
lookbehind: !0
},
hexcode: {
pattern: /\B#(?:[\da-f]{1,2}){3,4}\b/i,
alias: "color"
},
color: [ /\b(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)\b/i, {
pattern: /\b(?:rgb|hsl)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:rgb|hsl)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
inside: {
unit: r,
number: i,
function: /[\w-]+(?=\()/,
punctuation: /[(),]/
}
} ],
entity: /\\[\da-f]{1,8}/i,
unit: r,
number: i
} )
}( Prism );
! function ( e ) {
var r = "(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)".replace( /<SP_BS>/g, function () {
return "\\\\[\r\n](?:\\s|\\\\[\r\n]|#.*(?!.))*(?![\\s#]|\\\\[\r\n])"
} ),
n = "\"(?:[^\"\\\\\r\n]|\\\\(?:\r\n|[^]))*\"|'(?:[^'\\\\\r\n]|\\\\(?:\r\n|[^]))*'",
t = "--[\\w-]+=(?:<STR>|(?![\"'])(?:[^\\s\\\\]|\\\\.)+)".replace( /<STR>/g, function () {
return n
} ),
o = {
pattern: RegExp( n ),
greedy: !0
},
i = {
pattern: /(^[ \t]*)#.*/m,
lookbehind: !0,
greedy: !0
};
function a( e, n ) {
return e = e.replace( /<OPT>/g, function () {
return t
} ).replace( /<SP>/g, function () {
return r
} ), RegExp( e, n )
}
e.languages.docker = {
instruction: {
pattern: /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,
lookbehind: !0,
greedy: !0,
inside: {
options: {
pattern: a( "(^(?:ONBUILD<SP>)?\\w+<SP>)<OPT>(?:<SP><OPT>)*", "i" ),
lookbehind: !0,
greedy: !0,
inside: {
property: {
pattern: /(^|\s)--[\w-]+/,
lookbehind: !0
},
string: [ o, {
pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
lookbehind: !0
} ],
operator: /\\$/m,
punctuation: /=/
}
},
keyword: [ {
pattern: a( "(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\\b", "i" ),
lookbehind: !0,
greedy: !0
}, {
pattern: a( "(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\\\]+<SP>)AS", "i" ),
lookbehind: !0,
greedy: !0
}, {
pattern: a( "(^ONBUILD<SP>)\\w+", "i" ),
lookbehind: !0,
greedy: !0
}, {
pattern: /^\w+/,
greedy: !0
} ],
comment: i,
string: o,
variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
operator: /\\$/m
}
},
comment: i
}, e.languages.dockerfile = e.languages.docker
}( Prism );
Prism.languages.git = {
comment: /^#.*/m,
deleted: /^[-–].*/m,
inserted: /^\+.*/m,
string: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/m,
command: {
pattern: /^.*\$ git .*$/m,
inside: {
parameter: /\s--?\w+/m
}
},
coord: /^@@.*@@$/m,
"commit-sha1": /^commit \w{40}$/m
};
Prism.languages.go = Prism.languages.extend( "clike", {
string: {
pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
greedy: !0
},
keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
boolean: /\b(?:_|iota|nil|true|false)\b/,
number: /(?:\b0x[a-f\d]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[-+]?\d+)?)i?/i,
operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
builtin: /\b(?:bool|byte|complex(?:64|128)|error|float(?:32|64)|rune|string|u?int(?:8|16|32|64)?|uintptr|append|cap|close|complex|copy|delete|imag|len|make|new|panic|print(?:ln)?|real|recover)\b/
} ), delete Prism.languages.go[ "class-name" ];
Prism.languages.graphql = {
comment: /#.*/,
description: {
pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
greedy: !0,
alias: "string",
inside: {
"language-markdown": {
pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
lookbehind: !0,
inside: Prism.languages.markdown
}
}
},
string: {
pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
greedy: !0
},
number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
boolean: /\b(?:true|false)\b/,
variable: /\$[a-z_]\w*/i,
directive: {
pattern: /@[a-z_]\w*/i,
alias: "function"
},
"attr-name": {
pattern: /[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
greedy: !0
},
"class-name": {
pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*)[a-zA-Z_]\w*/,
lookbehind: !0
},
fragment: {
pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
lookbehind: !0,
alias: "function"
},
keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
operator: /[!=|&]|\.{3}/,
punctuation: /[!(){}\[\]:=,]/,
constant: /\b(?!ID\b)[A-Z][A-Z_\d]*\b/
};
Prism.languages.groovy = Prism.languages.extend( "clike", {
string: [ {
pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
greedy: !0
}, {
pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
greedy: !0
} ],
keyword: /\b(?:as|def|in|abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?[\d]+)?)[glidf]?\b/i,
operator: {
pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
lookbehind: !0
},
punctuation: /\.+|[{}[\];(),:$]/
} ), Prism.languages.insertBefore( "groovy", "string", {
shebang: {
pattern: /#!.+/,
alias: "comment"
}
} ), Prism.languages.insertBefore( "groovy", "punctuation", {
"spock-block": /\b(?:setup|given|when|then|and|cleanup|expect|where):/
} ), Prism.languages.insertBefore( "groovy", "function", {
annotation: {
pattern: /(^|[^.])@\w+/,
lookbehind: !0,
alias: "punctuation"
}
} ), Prism.hooks.add( "wrap", function ( e ) {
if ( "groovy" === e.language && "string" === e.type ) {
var t = e.content[ 0 ];
if ( "'" != t ) {
var n = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
"$" === t && ( n = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/ ), e.content = e.content.replace( /</g, "<" ).replace( /&/g, "&" ), e.content = Prism.highlight( e.content, {
expression: {
pattern: n,
lookbehind: !0,
inside: Prism.languages.groovy
}
} ), e.classes.push( "/" === t ? "regex" : "gstring" )
}
}
} );
! function ( t ) {
t.languages.http = {
"request-line": {
pattern: /^(?:GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH|PRI|SEARCH)\s(?:https?:\/\/|\/)\S*\sHTTP\/[0-9.]+/m,
inside: {
method: {
pattern: /^[A-Z]+\b/,
alias: "property"
},
"request-target": {
pattern: /^(\s)(?:https?:\/\/|\/)\S*(?=\s)/,
lookbehind: !0,
alias: "url",
inside: t.languages.uri
},
"http-version": {
pattern: /^(\s)HTTP\/[0-9.]+/,
lookbehind: !0,
alias: "property"
}
}
},
"response-status": {
pattern: /^HTTP\/[0-9.]+ \d+ .+/m,
inside: {
"http-version": {
pattern: /^HTTP\/[0-9.]+/,
alias: "property"
},
"status-code": {
pattern: /^(\s)\d+(?=\s)/,
lookbehind: !0,
alias: "number"
},
"reason-phrase": {
pattern: /^(\s).+/,
lookbehind: !0,
alias: "string"
}
}
},
"header-name": {
pattern: /^[\w-]+:(?=.)/m,
alias: "keyword"
}
};
var a, e, s, n = t.languages,
r = {
"application/javascript": n.javascript,
"application/json": n.json || n.javascript,
"application/xml": n.xml,
"text/xml": n.xml,
"text/html": n.html,
"text/css": n.css
},
i = {
"application/json": !0,
"application/xml": !0
};
for ( var p in r )
if ( r[ p ] ) {
a = a || {};
var o = i[ p ] ? ( void 0, s = ( e = p ).replace( /^[a-z]+\//, "" ), "(?:" + e + "|\\w+/(?:[\\w.-]+\\+)+" + s + "(?![+\\w.-]))" ) : p;
a[ p.replace( /\//g, "-" ) ] = {
pattern: RegExp( "(content-type:\\s*" + o + "(?:(?:\\r\\n?|\\n).+)*)(?:\\r?\\n|\\r){2}[\\s\\S]*", "i" ),
lookbehind: !0,
inside: r[ p ]
}
} a && t.languages.insertBefore( "http", "header-name", a )
}( Prism );
Prism.languages.json = {
property: {
pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
lookbehind: !0,
greedy: !0
},
string: {
pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
lookbehind: !0,
greedy: !0
},
comment: {
pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
greedy: !0
},
number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
punctuation: /[{}[\],]/,
operator: /:/,
boolean: /\b(?:true|false)\b/,
null: {
pattern: /\bnull\b/,
alias: "keyword"
}
}, Prism.languages.webmanifest = Prism.languages.json;
! function ( n ) {
var e = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
n.languages.json5 = n.languages.extend( "json", {
property: [ {
pattern: RegExp( e.source + "(?=\\s*:)" ),
greedy: !0
}, {
pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
alias: "unquoted"
} ],
string: {
pattern: e,
greedy: !0
},
number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
} )
}( Prism );
Prism.languages.jsonp = Prism.languages.extend( "json", {
punctuation: /[{}[\]();,.]/
} ), Prism.languages.insertBefore( "jsonp", "punctuation", {
function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/
} );
Prism.languages.jsstacktrace = {
"error-message": {
pattern: /^\S.*/m,
alias: "string"
},
"stack-frame": {
pattern: /^[ \t]+at[ \t].*/m,
inside: {
"not-my-code": {
pattern: /[ \t]+at[ \t]+(?!\s)(?:node\.js|\<unknown\>|.*(?:node_modules|\(\<anonymous\>\)|\(\<unknown\>|\<anonymous\>$|\(internal\/|\(node\.js)).*/m,
alias: "comment"
},
filename: {
pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
lookbehind: !0,
alias: "url"
},
function: {
pattern: /(at\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
lookbehind: !0,
inside: {
punctuation: /\./
}
},
punctuation: /[()]/,
keyword: /\b(?:at|new)\b/,
alias: {
pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
alias: "variable"
},
"line-number": {
pattern: /:[0-9]+(?::[0-9]+)?\b/,
alias: "number",
inside: {
punctuation: /:/
}
}
}
}
};
! function ( u ) {
var e = u.languages.javascript[ "template-string" ],
n = e.pattern.source,
a = e.inside.interpolation,
i = a.inside[ "interpolation-punctuation" ],
r = a.pattern.source;
function t( e, t ) {
if ( u.languages[ e ] ) return {
pattern: RegExp( "((?:" + t + ")\\s*)" + n ),
lookbehind: !0,
greedy: !0,
inside: {
"template-punctuation": {
pattern: /^`|`$/,
alias: "string"
},
"embedded-code": {
pattern: /[\s\S]+/,
alias: e
}
}
}
}
function o( e, t, n ) {
var r = {
code: e,
grammar: t,
language: n
};
return u.hooks.run( "before-tokenize", r ), r.tokens = u.tokenize( r.code, r.grammar