/** * TinyMCE version 6.0.3 (2022-05-25) */ (function () { 'use strict'; var global$2 = tinymce.util.Tools.resolve('tinymce.PluginManager'); const isNullable = a => a === null || a === undefined; const isNonNullable = a => !isNullable(a); const constant = value => { return () => { return value; }; }; class Optional { constructor(tag, value) { this.tag = tag; this.value = value; } static some(value) { return new Optional(true, value); } static none() { return Optional.singletonNone; } fold(onNone, onSome) { if (this.tag) { return onSome(this.value); } else { return onNone(); } } isSome() { return this.tag; } isNone() { return !this.tag; } map(mapper) { if (this.tag) { return Optional.some(mapper(this.value)); } else { return Optional.none(); } } bind(binder) { if (this.tag) { return binder(this.value); } else { return Optional.none(); } } exists(predicate) { return this.tag && predicate(this.value); } forall(predicate) { return !this.tag || predicate(this.value); } filter(predicate) { if (!this.tag || predicate(this.value)) { return this; } else { return Optional.none(); } } getOr(replacement) { return this.tag ? this.value : replacement; } or(replacement) { return this.tag ? this : replacement; } getOrThunk(thunk) { return this.tag ? this.value : thunk(); } orThunk(thunk) { return this.tag ? this : thunk(); } getOrDie(message) { if (!this.tag) { throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None'); } else { return this.value; } } static from(value) { return isNonNullable(value) ? Optional.some(value) : Optional.none(); } getOrNull() { return this.tag ? this.value : null; } getOrUndefined() { return this.value; } each(worker) { if (this.tag) { worker(this.value); } } toArray() { return this.tag ? [this.value] : []; } toString() { return this.tag ? `some(${ this.value })` : 'none()'; } } Optional.singletonNone = new Optional(false); const get$1 = (xs, i) => i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none(); const head = xs => get$1(xs, 0); const someIf = (b, a) => b ? Optional.some(a) : Optional.none(); var global$1 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils'); const Global = typeof window !== 'undefined' ? window : Function('return this;')(); const prismjs = function (global, module, exports) { const oldprism = window.Prism; window.Prism = { manual: true }; 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(/' + env.content + ''; }; 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.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': /[{}[\];(),.:]/ }; (function (Prism) { function getPlaceholder(language, index) { return '___' + language.toUpperCase() + index + '___'; } Object.defineProperties(Prism.languages['markup-templating'] = {}, { buildPlaceholders: { value: function (env, language, placeholderPattern, replaceFilter) { if (env.language !== language) { return; } var tokenStack = env.tokenStack = []; env.code = env.code.replace(placeholderPattern, function (match) { if (typeof replaceFilter === 'function' && !replaceFilter(match)) { return match; } var i = tokenStack.length; var placeholder; while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) { ++i; } tokenStack[i] = match; return placeholder; }); env.grammar = Prism.languages.markup; } }, tokenizePlaceholders: { value: function (env, language) { if (env.language !== language || !env.tokenStack) { return; } env.grammar = Prism.languages[language]; var j = 0; var keys = Object.keys(env.tokenStack); function walkTokens(tokens) { for (var i = 0; i < tokens.length; i++) { if (j >= keys.length) { break; } var token = tokens[i]; if (typeof token === 'string' || token.content && typeof token.content === 'string') { var k = keys[j]; var t = env.tokenStack[k]; var s = typeof token === 'string' ? token : token.content; var placeholder = getPlaceholder(language, k); var index = s.indexOf(placeholder); if (index > -1) { ++j; var before = s.substring(0, index); var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t); var after = s.substring(index + placeholder.length); var replacement = []; if (before) { replacement.push.apply(replacement, walkTokens([before])); } replacement.push(middle); if (after) { replacement.push.apply(replacement, walkTokens([after])); } if (typeof token === 'string') { tokens.splice.apply(tokens, [ i, 1 ].concat(replacement)); } else { token.content = replacement; } } } else if (token.content) { walkTokens(token.content); } } return tokens; } walkTokens(env.tokens); } } }); }(Prism)); Prism.languages.c = Prism.languages.extend('clike', { 'comment': { pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: true }, 'string': { pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: true }, 'class-name': { pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/, lookbehind: true }, 'keyword': /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/, 'function': /\b[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', { 'char': { pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/, greedy: true } }); Prism.languages.insertBefore('c', 'string', { 'macro': { pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im, lookbehind: true, greedy: true, alias: 'property', inside: { 'string': [ { pattern: /^(#\s*include\s*)<[^>]+>/, lookbehind: true }, Prism.languages.c['string'] ], 'char': Prism.languages.c['char'], 'comment': Prism.languages.c['comment'], 'macro-name': [ { pattern: /(^#\s*define\s+)\w+\b(?!\()/i, lookbehind: true }, { pattern: /(^#\s*define\s+)\w+\b(?=\()/i, lookbehind: true, alias: 'function' } ], 'directive': { pattern: /^(#\s*)[a-z]+/, lookbehind: true, alias: 'keyword' }, 'directive-hash': /^#/, 'punctuation': /##|\\(?=[\r\n])/, 'expression': { pattern: /\S[\s\S]*/, inside: Prism.languages.c } } } }); Prism.languages.insertBefore('c', 'function', { 'constant': /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }); delete Prism.languages.c['boolean']; (function (Prism) { var keyword = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|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|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/; var modName = /\b(?!)\w+(?:\s*\.\s*\w+)*\b/.source.replace(//g, function () { return keyword.source; }); Prism.languages.cpp = Prism.languages.extend('c', { 'class-name': [ { pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!)\w+/.source.replace(//g, function () { return keyword.source; })), lookbehind: true }, /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/ ], 'keyword': keyword, '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: true }, 'operator': />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/, 'boolean': /\b(?:false|true)\b/ }); Prism.languages.insertBefore('cpp', 'string', { 'module': { pattern: RegExp(/(\b(?:import|module)\s+)/.source + '(?:' + /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + '|' + /(?:\s*:\s*)?|:\s*/.source.replace(//g, function () { return modName; }) + ')'), lookbehind: true, greedy: true, inside: { 'string': /^[<"][\s\S]+/, 'operator': /:/, 'punctuation': /\./ } }, 'raw-string': { pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/, alias: 'string', greedy: true } }); Prism.languages.insertBefore('cpp', 'keyword', { 'generic-function': { pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i, inside: { 'function': /^\w+/, 'generic': { pattern: /<[\s\S]+/, alias: 'class-name', inside: Prism.languages.cpp } } } }); Prism.languages.insertBefore('cpp', 'operator', { 'double-colon': { pattern: /::/, alias: 'punctuation' } }); Prism.languages.insertBefore('cpp', 'class-name', { 'base-clause': { pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/, lookbehind: true, greedy: true, inside: Prism.languages.extend('cpp', {}) } }); Prism.languages.insertBefore('inside', 'double-colon', { 'class-name': /\b[a-z_]\w*\b(?!\s*::)/i }, Prism.languages.cpp['base-clause']); }(Prism)); (function (Prism) { function replace(pattern, replacements) { return pattern.replace(/<<(\d+)>>/g, function (m, index) { return '(?:' + replacements[+index] + ')'; }); } function re(pattern, replacements, flags) { return RegExp(replace(pattern, replacements), flags || ''); } function nested(pattern, depthLog2) { for (var i = 0; i < depthLog2; i++) { pattern = pattern.replace(/<>/g, function () { return '(?:' + pattern + ')'; }); } return pattern.replace(/<>/g, '[^\\s\\S]'); } var keywordKinds = { type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void', typeDeclaration: 'class enum interface record struct', contextual: 'add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)', other: 'abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield' }; function keywordsToPattern(words) { return '\\b(?:' + words.trim().replace(/ /g, '|') + ')\\b'; } var typeDeclarationKeywords = keywordsToPattern(keywordKinds.typeDeclaration); var keywords = RegExp(keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other)); var nonTypeKeywords = keywordsToPattern(keywordKinds.typeDeclaration + ' ' + keywordKinds.contextual + ' ' + keywordKinds.other); var nonContextualKeywords = keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.typeDeclaration + ' ' + keywordKinds.other); var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<>)*>/.source, 2); var nestedRound = nested(/\((?:[^()]|<>)*\)/.source, 2); var name = /@?\b[A-Za-z_]\w*\b/.source; var genericName = replace(/<<0>>(?:\s*<<1>>)?/.source, [ name, generic ]); var identifier = replace(/(?!<<0>>)<<1>>(?:\s*\.\s*<<1>>)*/.source, [ nonTypeKeywords, genericName ]); var array = /\[\s*(?:,\s*)*\]/.source; var typeExpressionWithoutTuple = replace(/<<0>>(?:\s*(?:\?\s*)?<<1>>)*(?:\s*\?)?/.source, [ identifier, array ]); var tupleElement = replace(/[^,()<>[\];=+\-*/%&|^]|<<0>>|<<1>>|<<2>>/.source, [ generic, nestedRound, array ]); var tuple = replace(/\(<<0>>+(?:,<<0>>+)+\)/.source, [tupleElement]); var typeExpression = replace(/(?:<<0>>|<<1>>)(?:\s*(?:\?\s*)?<<2>>)*(?:\s*\?)?/.source, [ tuple, identifier, array ]); var typeInside = { 'keyword': keywords, 'punctuation': /[<>()?,.:[\]]/ }; var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source; var regularString = /"(?:\\.|[^\\"\r\n])*"/.source; var verbatimString = /@"(?:""|\\[\s\S]|[^\\"])*"(?!")/.source; Prism.languages.csharp = Prism.languages.extend('clike', { 'string': [ { pattern: re(/(^|[^$\\])<<0>>/.source, [verbatimString]), lookbehind: true, greedy: true }, { pattern: re(/(^|[^@$\\])<<0>>/.source, [regularString]), lookbehind: true, greedy: true } ], 'class-name': [ { pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [identifier]), lookbehind: true, inside: typeInside }, { pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [ name, typeExpression ]), lookbehind: true, inside: typeInside }, { pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]), lookbehind: true }, { pattern: re(/(\b<<0>>\s+)<<1>>/.source, [ typeDeclarationKeywords, genericName ]), lookbehind: true, inside: typeInside }, { pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]), lookbehind: true, inside: typeInside }, { pattern: re(/(\bwhere\s+)<<0>>/.source, [name]), lookbehind: true }, { pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [typeExpressionWithoutTuple]), lookbehind: true, inside: typeInside }, { pattern: re(/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/.source, [ typeExpression, nonContextualKeywords, name ]), inside: typeInside } ], 'keyword': keywords, 'number': /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i, 'operator': />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/, 'punctuation': /\?\.?|::|[{}[\];(),.:]/ }); Prism.languages.insertBefore('csharp', 'number', { 'range': { pattern: /\.\./, alias: 'operator' } }); Prism.languages.insertBefore('csharp', 'punctuation', { 'named-parameter': { pattern: re(/([(,]\s*)<<0>>(?=\s*:)/.source, [name]), lookbehind: true, alias: 'punctuation' } }); Prism.languages.insertBefore('csharp', 'class-name', { 'namespace': { pattern: re(/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source, [name]), lookbehind: true, inside: { 'punctuation': /\./ } }, 'type-expression': { pattern: re(/(\b(?:default|sizeof|typeof)\s*\(\s*(?!\s))(?:[^()\s]|\s(?!\s)|<<0>>)*(?=\s*\))/.source, [nestedRound]), lookbehind: true, alias: 'class-name', inside: typeInside }, 'return-type': { pattern: re(/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source, [ typeExpression, identifier ]), inside: typeInside, alias: 'class-name' }, 'constructor-invocation': { pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]), lookbehind: true, inside: typeInside, alias: 'class-name' }, 'generic-method': { pattern: re(/<<0>>\s*<<1>>(?=\s*\()/.source, [ name, generic ]), inside: { 'function': re(/^<<0>>/.source, [name]), 'generic': { pattern: RegExp(generic), alias: 'class-name', inside: typeInside } } }, 'type-list': { pattern: re(/\b((?:<<0>>\s+<<1>>|record\s+<<1>>\s*<<5>>|where\s+<<2>>)\s*:\s*)(?:<<3>>|<<4>>|<<1>>\s*<<5>>|<<6>>)(?:\s*,\s*(?:<<3>>|<<4>>|<<6>>))*(?=\s*(?:where|[{;]|=>|$))/.source, [ typeDeclarationKeywords, genericName, name, typeExpression, keywords.source, nestedRound, /\bnew\s*\(\s*\)/.source ]), lookbehind: true, inside: { 'record-arguments': { pattern: re(/(^(?!new\s*\()<<0>>\s*)<<1>>/.source, [ genericName, nestedRound ]), lookbehind: true, greedy: true, inside: Prism.languages.csharp }, 'keyword': keywords, 'class-name': { pattern: RegExp(typeExpression), greedy: true, inside: typeInside }, 'punctuation': /[,()]/ } }, 'preprocessor': { pattern: /(^[\t ]*)#.*/m, lookbehind: true, alias: 'property', inside: { 'directive': { pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/, lookbehind: true, alias: 'keyword' } } } }); var regularStringOrCharacter = regularString + '|' + character; var regularStringCharacterOrComment = replace(/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source, [regularStringOrCharacter]); var roundExpression = nested(replace(/[^"'/()]|<<0>>|\(<>*\)/.source, [regularStringCharacterOrComment]), 2); var attrTarget = /\b(?:assembly|event|field|method|module|param|property|return|type)\b/.source; var attr = replace(/<<0>>(?:\s*\(<<1>>*\))?/.source, [ identifier, roundExpression ]); Prism.languages.insertBefore('csharp', 'class-name', { 'attribute': { pattern: re(/((?:^|[^\s\w>)?])\s*\[\s*)(?:<<0>>\s*:\s*)?<<1>>(?:\s*,\s*<<1>>)*(?=\s*\])/.source, [ attrTarget, attr ]), lookbehind: true, greedy: true, inside: { 'target': { pattern: re(/^<<0>>(?=\s*:)/.source, [attrTarget]), alias: 'keyword' }, 'attribute-arguments': { pattern: re(/\(<<0>>*\)/.source, [roundExpression]), inside: Prism.languages.csharp }, 'class-name': { pattern: RegExp(identifier), inside: { 'punctuation': /\./ } }, 'punctuation': /[:,]/ } } }); var formatString = /:[^}\r\n]+/.source; var mInterpolationRound = nested(replace(/[^"'/()]|<<0>>|\(<>*\)/.source, [regularStringCharacterOrComment]), 2); var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [ mInterpolationRound, formatString ]); var sInterpolationRound = nested(replace(/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<>*\)/.source, [regularStringOrCharacter]), 2); var sInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [ sInterpolationRound, formatString ]); function createInterpolationInside(interpolation, interpolationRound) { return { 'interpolation': { pattern: re(/((?:^|[^{])(?:\{\{)*)<<0>>/.source, [interpolation]), lookbehind: true, inside: { 'format-string': { pattern: re(/(^\{(?:(?![}:])<<0>>)*)<<1>>(?=\}$)/.source, [ interpolationRound, formatString ]), lookbehind: true, inside: { 'punctuation': /^:/ } }, 'punctuation': /^\{|\}$/, 'expression': { pattern: /[\s\S]+/, alias: 'language-csharp', inside: Prism.languages.csharp } } }, 'string': /[\s\S]+/ }; } Prism.languages.insertBefore('csharp', 'string', { 'interpolation-string': [ { pattern: re(/(^|[^\\])(?:\$@|@\$)"(?:""|\\[\s\S]|\{\{|<<0>>|[^\\{"])*"/.source, [mInterpolation]), lookbehind: true, greedy: true, inside: createInterpolationInside(mInterpolation, mInterpolationRound) }, { pattern: re(/(^|[^@\\])\$"(?:\\.|\{\{|<<0>>|[^\\"{])*"/.source, [sInterpolation]), lookbehind: true, greedy: true, inside: createInterpolationInside(sInterpolation, sInterpolationRound) } ], 'char': { pattern: RegExp(character), greedy: true } }); Prism.languages.dotnet = Prism.languages.cs = Prism.languages.csharp; }(Prism)); (function (Prism) { var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/; Prism.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: 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)); (function (Prism) { var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/; var classNamePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source; var className = { pattern: RegExp(classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source), lookbehind: true, inside: { 'namespace': { pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/, inside: { 'punctuation': /\./ } }, 'punctuation': /\./ } }; Prism.languages.java = Prism.languages.extend('clike', { 'string': { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/, lookbehind: true, greedy: true }, 'class-name': [ className, { pattern: RegExp(classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source), lookbehind: true, inside: className.inside } ], 'keyword': keywords, 'function': [ Prism.languages.clike.function, { pattern: /(::\s*)[a-z_]\w*/, lookbehind: true } ], 'number': /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i, 'operator': { pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m, lookbehind: true } }); Prism.languages.insertBefore('java', 'string', { 'triple-quoted-string': { pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/, greedy: true, alias: 'string' }, 'char': { pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/, greedy: true } }); Prism.languages.insertBefore('java', 'class-name', { 'annotation': { pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/, lookbehind: true, alias: 'punctuation' }, 'generics': { pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/, inside: { 'class-name': className, 'keyword': keywords, 'punctuation': /[<>(),.:]/, 'operator': /[?&|]/ } }, 'namespace': { pattern: RegExp(/(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(//g, function () { return keywords.source; })), lookbehind: true, inside: { 'punctuation': /\./ } } }); }(Prism)); 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: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/, 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; Prism.languages.markup = { 'comment': { pattern: //, greedy: true }, 'prolog': { pattern: /<\?[\s\S]+?\?>/, greedy: true }, 'doctype': { pattern: /"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|)*\]\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: //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' }, /"|'/ ] } }, '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: /(^$)/i, lookbehind: true, inside: Prism.languages[lang] }; includedCdataInside['cdata'] = /^$/i; var inside = { 'included-cdata': { pattern: //i, inside: includedCdataInside } }; inside['language-' + lang] = { pattern: /[\s\S]+/, inside: Prism.languages[lang] }; var def = {}; def[tagName] = { pattern: RegExp(/(<__[^>]*>)(?:))*\]\]>|(?!)/.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 comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/; var constant = [ { pattern: /\b(?:false|true)\b/i, alias: 'boolean' }, { pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i, greedy: true, lookbehind: true }, { pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i, greedy: true, lookbehind: true }, /\b(?:null)\b/i, /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/ ]; var number = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i; var operator = /|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/; var punctuation = /[{}\[\](),:;]/; Prism.languages.php = { 'delimiter': { pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i, alias: 'important' }, 'comment': comment, 'variable': /\$+(?:\w+\b|(?=\{))/, 'package': { pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, lookbehind: true, inside: { 'punctuation': /\\/ } }, 'class-name-definition': { pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i, lookbehind: true, alias: 'class-name' }, 'function-definition': { pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i, lookbehind: true, alias: 'function' }, 'keyword': [ { pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i, alias: 'type-casting', greedy: true, lookbehind: true }, { pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i, alias: 'type-hint', greedy: true, lookbehind: true }, { pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string|void)\b/i, alias: 'return-type', greedy: true, lookbehind: true }, { pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i, alias: 'type-declaration', greedy: true }, { pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i, alias: 'type-declaration', greedy: true, lookbehind: true }, { pattern: /\b(?:parent|self|static)(?=\s*::)/i, alias: 'static-context', greedy: true }, { pattern: /(\byield\s+)from\b/i, lookbehind: true }, /\bclass\b/i, { pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|new|or|parent|print|private|protected|public|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i, lookbehind: true } ], 'argument-name': { pattern: /([(,]\s+)\b[a-z_]\w*(?=\s*:(?!:))/i, lookbehind: true }, 'class-name': [ { pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i, greedy: true, lookbehind: true }, { pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i, greedy: true, lookbehind: true }, { pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i, greedy: true }, { pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i, alias: 'class-name-fully-qualified', greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } }, { pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i, alias: 'class-name-fully-qualified', greedy: true, inside: { 'punctuation': /\\/ } }, { pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, alias: 'class-name-fully-qualified', greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } }, { pattern: /\b[a-z_]\w*(?=\s*\$)/i, alias: 'type-declaration', greedy: true }, { pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i, alias: [ 'class-name-fully-qualified', 'type-declaration' ], greedy: true, inside: { 'punctuation': /\\/ } }, { pattern: /\b[a-z_]\w*(?=\s*::)/i, alias: 'static-context', greedy: true }, { pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i, alias: [ 'class-name-fully-qualified', 'static-context' ], greedy: true, inside: { 'punctuation': /\\/ } }, { pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i, alias: 'type-hint', greedy: true, lookbehind: true }, { pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i, alias: [ 'class-name-fully-qualified', 'type-hint' ], greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } }, { pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i, alias: 'return-type', greedy: true, lookbehind: true }, { pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, alias: [ 'class-name-fully-qualified', 'return-type' ], greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } } ], 'constant': constant, 'function': { pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i, lookbehind: true, inside: { 'punctuation': /\\/ } }, 'property': { pattern: /(->\s*)\w+/, lookbehind: true }, 'number': number, 'operator': operator, 'punctuation': punctuation }; var string_interpolation = { pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/, lookbehind: true, inside: Prism.languages.php }; var string = [ { pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/, alias: 'nowdoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<<'[^']+'|[a-z_]\w*;$/i, alias: 'symbol', inside: { 'punctuation': /^<<<'?|[';]$/ } } } }, { pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i, alias: 'heredoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i, alias: 'symbol', inside: { 'punctuation': /^<<<"?|[";]$/ } }, 'interpolation': string_interpolation } }, { pattern: /`(?:\\[\s\S]|[^\\`])*`/, alias: 'backtick-quoted-string', greedy: true }, { pattern: /'(?:\\[\s\S]|[^\\'])*'/, alias: 'single-quoted-string', greedy: true }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, alias: 'double-quoted-string', greedy: true, inside: { 'interpolation': string_interpolation } } ]; Prism.languages.insertBefore('php', 'variable', { 'string': string, 'attribute': { pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im, greedy: true, inside: { 'attribute-content': { pattern: /^(#\[)[\s\S]+(?=\]$)/, lookbehind: true, inside: { 'comment': comment, 'string': string, 'attribute-class-name': [ { pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i, alias: 'class-name', greedy: true, lookbehind: true }, { pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i, alias: [ 'class-name', 'class-name-fully-qualified' ], greedy: true, lookbehind: true, inside: { 'punctuation': /\\/ } } ], 'constant': constant, 'number': number, 'operator': operator, 'punctuation': punctuation } }, 'delimiter': { pattern: /^#\[|\]$/, alias: 'punctuation' } } } }); Prism.hooks.add('before-tokenize', function (env) { if (!/<\?/.test(env.code)) { return; } var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g; Prism.languages['markup-templating'].buildPlaceholders(env, 'php', phpPattern); }); Prism.hooks.add('after-tokenize', function (env) { Prism.languages['markup-templating'].tokenizePlaceholders(env, 'php'); }); }(Prism)); Prism.languages.python = { 'comment': { pattern: /(^|[^\\])#.*/, lookbehind: true, greedy: true }, 'string-interpolation': { pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i, greedy: true, inside: { 'interpolation': { pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/, lookbehind: true, inside: { 'format-spec': { pattern: /(:)[^:(){}]+(?=\}$)/, lookbehind: true }, 'conversion-option': { pattern: /![sra](?=[:}]$)/, alias: 'punctuation' }, rest: null } }, 'string': /[\s\S]+/ } }, 'triple-quoted-string': { pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i, greedy: true, alias: 'string' }, 'string': { pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i, greedy: true }, 'function': { pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g, lookbehind: true }, 'class-name': { pattern: /(\bclass\s+)\w+/i, lookbehind: true }, 'decorator': { pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m, lookbehind: true, alias: [ 'annotation', 'punctuation' ], inside: { 'punctuation': /\./ } }, 'keyword': /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/, 'builtin': /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/, 'boolean': /\b(?:False|None|True)\b/, 'number': /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i, 'operator': /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/, 'punctuation': /[{}[\];(),.:]/ }; Prism.languages.python['string-interpolation'].inside['interpolation'].inside.rest = Prism.languages.python; Prism.languages.py = Prism.languages.python; (function (Prism) { Prism.languages.ruby = Prism.languages.extend('clike', { 'comment': { pattern: /#.*|^=begin\s[\s\S]*?^=end/m, greedy: true }, 'class-name': { pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/, lookbehind: true, inside: { 'punctuation': /[.\\]/ } }, 'keyword': /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/, 'operator': /\.{2,3}|&\.|===||[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/, 'punctuation': /[(){}[\].,;]/ }); Prism.languages.insertBefore('ruby', 'operator', { 'double-colon': { pattern: /::/, alias: 'punctuation' } }); var interpolation = { pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/, lookbehind: true, inside: { 'content': { pattern: /^(#\{)[\s\S]+(?=\}$)/, lookbehind: true, inside: Prism.languages.ruby }, 'delimiter': { pattern: /^#\{|\}$/, alias: 'punctuation' } } }; delete Prism.languages.ruby.function; var percentExpression = '(?:' + [ /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source, /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source, /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source, /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source, /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source ].join('|') + ')'; var symbolName = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source; Prism.languages.insertBefore('ruby', 'keyword', { 'regex-literal': [ { pattern: RegExp(/%r/.source + percentExpression + /[egimnosux]{0,6}/.source), greedy: true, inside: { 'interpolation': interpolation, 'regex': /[\s\S]+/ } }, { pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/, lookbehind: true, greedy: true, inside: { 'interpolation': interpolation, 'regex': /[\s\S]+/ } } ], 'variable': /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/, 'symbol': [ { pattern: RegExp(/(^|[^:]):/.source + symbolName), lookbehind: true, greedy: true }, { pattern: RegExp(/([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source), lookbehind: true, greedy: true } ], 'method-definition': { pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/, lookbehind: true, inside: { 'function': /\b\w+$/, 'keyword': /^self\b/, 'class-name': /^\w+/, 'punctuation': /\./ } } }); Prism.languages.insertBefore('ruby', 'string', { 'string-literal': [ { pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression), greedy: true, inside: { 'interpolation': interpolation, 'string': /[\s\S]+/ } }, { pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/, greedy: true, inside: { 'interpolation': interpolation, 'string': /[\s\S]+/ } }, { pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i, alias: 'heredoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i, inside: { 'symbol': /\b\w+/, 'punctuation': /^<<[-~]?/ } }, 'interpolation': interpolation, 'string': /[\s\S]+/ } }, { pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i, alias: 'heredoc-string', greedy: true, inside: { 'delimiter': { pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i, inside: { 'symbol': /\b\w+/, 'punctuation': /^<<[-~]?'|'$/ } }, 'string': /[\s\S]+/ } } ], 'command-literal': [ { pattern: RegExp(/%x/.source + percentExpression), greedy: true, inside: { 'interpolation': interpolation, 'command': { pattern: /[\s\S]+/, alias: 'string' } } }, { pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/, greedy: true, inside: { 'interpolation': interpolation, 'command': { pattern: /[\s\S]+/, alias: 'string' } } } ] }); delete Prism.languages.ruby.string; Prism.languages.insertBefore('ruby', 'number', { 'builtin': /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/, 'constant': /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/ }); Prism.languages.rb = Prism.languages.ruby; }(Prism)); window.Prism = oldprism; return Prism; }(undefined, undefined); const option = name => editor => editor.options.get(name); const register$2 = editor => { const registerOption = editor.options.register; registerOption('codesample_languages', { processor: 'object[]' }); registerOption('codesample_global_prismjs', { processor: 'boolean', default: false }); }; const getLanguages$1 = option('codesample_languages'); const useGlobalPrismJS = option('codesample_global_prismjs'); const get = editor => Global.Prism && useGlobalPrismJS(editor) ? Global.Prism : prismjs; const isCodeSample = elm => { return elm && elm.nodeName === 'PRE' && elm.className.indexOf('language-') !== -1; }; const getSelectedCodeSample = editor => { const node = editor.selection ? editor.selection.getNode() : null; return someIf(isCodeSample(node), node); }; const insertCodeSample = (editor, language, code) => { const dom = editor.dom; editor.undoManager.transact(() => { const node = getSelectedCodeSample(editor); code = global$1.DOM.encode(code); return node.fold(() => { editor.insertContent('
' + code + '
'); const newPre = dom.select('#__new')[0]; dom.setAttrib(newPre, 'id', null); editor.selection.select(newPre); }, n => { dom.setAttrib(n, 'class', 'language-' + language); n.innerHTML = code; get(editor).highlightElement(n); editor.selection.select(n); }); }); }; const getCurrentCode = editor => { const node = getSelectedCodeSample(editor); return node.fold(constant(''), n => n.textContent); }; const getLanguages = editor => { const defaultLanguages = [ { text: 'HTML/XML', value: 'markup' }, { text: 'JavaScript', value: 'javascript' }, { text: 'CSS', value: 'css' }, { text: 'PHP', value: 'php' }, { text: 'Ruby', value: 'ruby' }, { text: 'Python', value: 'python' }, { text: 'Java', value: 'java' }, { text: 'C', value: 'c' }, { text: 'C#', value: 'csharp' }, { text: 'C++', value: 'cpp' } ]; const customLanguages = getLanguages$1(editor); return customLanguages ? customLanguages : defaultLanguages; }; const getCurrentLanguage = (editor, fallback) => { const node = getSelectedCodeSample(editor); return node.fold(() => fallback, n => { const matches = n.className.match(/language-(\w+)/); return matches ? matches[1] : fallback; }); }; const open = editor => { const languages = getLanguages(editor); const defaultLanguage = head(languages).fold(constant(''), l => l.value); const currentLanguage = getCurrentLanguage(editor, defaultLanguage); const currentCode = getCurrentCode(editor); editor.windowManager.open({ title: 'Insert/Edit Code Sample', size: 'large', body: { type: 'panel', items: [ { type: 'selectbox', name: 'language', label: 'Language', items: languages }, { type: 'textarea', name: 'code', label: 'Code view' } ] }, buttons: [ { type: 'cancel', name: 'cancel', text: 'Cancel' }, { type: 'submit', name: 'save', text: 'Save', primary: true } ], initialData: { language: currentLanguage, code: currentCode }, onSubmit: api => { const data = api.getData(); insertCodeSample(editor, data.language, data.code); api.close(); } }); }; const register$1 = editor => { editor.addCommand('codesample', () => { const node = editor.selection.getNode(); if (editor.selection.isCollapsed() || isCodeSample(node)) { open(editor); } else { editor.formatter.toggle('code'); } }); }; const blank = r => s => s.replace(r, ''); const trim = blank(/^\s+|\s+$/g); var global = tinymce.util.Tools.resolve('tinymce.util.Tools'); const setup = editor => { editor.on('PreProcess', e => { const dom = editor.dom; const pres = dom.select('pre[contenteditable=false]', e.node); global.each(global.grep(pres, isCodeSample), elm => { const code = elm.textContent; dom.setAttrib(elm, 'class', trim(dom.getAttrib(elm, 'class'))); dom.setAttrib(elm, 'contentEditable', null); let child; while (child = elm.firstChild) { elm.removeChild(child); } const codeElm = dom.add(elm, 'code'); codeElm.textContent = code; }); }); editor.on('SetContent', () => { const dom = editor.dom; const unprocessedCodeSamples = global.grep(dom.select('pre'), elm => { return isCodeSample(elm) && elm.contentEditable !== 'false'; }); if (unprocessedCodeSamples.length) { editor.undoManager.transact(() => { global.each(unprocessedCodeSamples, elm => { global.each(dom.select('br', elm), elm => { elm.parentNode.replaceChild(editor.getDoc().createTextNode('\n'), elm); }); elm.contentEditable = 'false'; elm.innerHTML = dom.encode(elm.textContent); get(editor).highlightElement(elm); elm.className = trim(elm.className); }); }); } }); }; const isCodeSampleSelection = editor => { const node = editor.selection.getStart(); return editor.dom.is(node, 'pre[class*="language-"]'); }; const register = editor => { const onAction = () => editor.execCommand('codesample'); editor.ui.registry.addToggleButton('codesample', { icon: 'code-sample', tooltip: 'Insert/edit code sample', onAction, onSetup: api => { const nodeChangeHandler = () => { api.setActive(isCodeSampleSelection(editor)); }; editor.on('NodeChange', nodeChangeHandler); return () => editor.off('NodeChange', nodeChangeHandler); } }); editor.ui.registry.addMenuItem('codesample', { text: 'Code sample...', icon: 'code-sample', onAction }); }; var Plugin = () => { global$2.add('codesample', editor => { register$2(editor); setup(editor); register(editor); register$1(editor); editor.on('dblclick', ev => { if (isCodeSample(ev.target)) { open(editor); } }); }); }; Plugin(); })();