beansflight-json-form
Version:
> **版本号:verison 0.23.17**
1,518 lines (1,507 loc) • 92 kB
JavaScript
/**
* TinyMCE version 6.1.0 (2022-06-29)
*/
;(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(/</g, '<')
.replace(/\u00a0/g, ' ')
}
},
type: function (o) {
return Object.prototype.toString.call(o).slice(8, -1)
},
objId: function (obj) {
if (!obj['__id']) {
Object.defineProperty(obj, '__id', { value: ++uniqueId })
}
return obj['__id']
},
clone: function deepClone(o, visited) {
visited = visited || {}
var clone
var id
switch (_.util.type(o)) {
case 'Object':
id = _.util.objId(o)
if (visited[id]) {
return visited[id]
}
clone = {}
visited[id] = clone
for (var key in o) {
if (o.hasOwnProperty(key)) {
clone[key] = deepClone(o[key], visited)
}
}
return clone
case 'Array':
id = _.util.objId(o)
if (visited[id]) {
return visited[id]
}
clone = []
visited[id] = clone
o.forEach(function (v, i) {
clone[i] = deepClone(v, visited)
})
return clone
default:
return o
}
},
getLanguage: function (element) {
while (element) {
var m = lang.exec(element.className)
if (m) {
return m[1].toLowerCase()
}
element = element.parentElement
}
return 'none'
},
setLanguage: function (element, language) {
element.className = element.className.replace(
RegExp(lang, 'gi'),
''
)
element.classList.add('language-' + language)
},
currentScript: function () {
if (typeof document === 'undefined') {
return null
}
if ('currentScript' in document && 1 < 2) {
return document.currentScript
}
try {
throw new Error()
} catch (err) {
var src = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(err.stack) ||
[])[1]
if (src) {
var scripts = document.getElementsByTagName('script')
for (var i in scripts) {
if (scripts[i].src == src) {
return scripts[i]
}
}
}
return null
}
},
isActive: function (element, className, defaultActivation) {
var no = 'no-' + className
while (element) {
var classList = element.classList
if (classList.contains(className)) {
return true
}
if (classList.contains(no)) {
return false
}
element = element.parentElement
}
return !!defaultActivation
}
},
languages: {
plain: plainTextGrammar,
plaintext: plainTextGrammar,
text: plainTextGrammar,
txt: plainTextGrammar,
extend: function (id, redef) {
var lang = _.util.clone(_.languages[id])
for (var key in redef) {
lang[key] = redef[key]
}
return lang
},
insertBefore: function (inside, before, insert, root) {
root = root || _.languages
var grammar = root[inside]
var ret = {}
for (var token in grammar) {
if (grammar.hasOwnProperty(token)) {
if (token == before) {
for (var newToken in insert) {
if (insert.hasOwnProperty(newToken)) {
ret[newToken] = insert[newToken]
}
}
}
if (!insert.hasOwnProperty(token)) {
ret[token] = grammar[token]
}
}
}
var old = root[inside]
root[inside] = ret
_.languages.DFS(_.languages, function (key, value) {
if (value === old && key != inside) {
this[key] = ret
}
})
return ret
},
DFS: function DFS(o, callback, type, visited) {
visited = visited || {}
var objId = _.util.objId
for (var i in o) {
if (o.hasOwnProperty(i)) {
callback.call(o, i, o[i], type || i)
var property = o[i]
var propertyType = _.util.type(property)
if (propertyType === 'Object' && !visited[objId(property)]) {
visited[objId(property)] = true
DFS(property, callback, null, visited)
} else if (
propertyType === 'Array' &&
!visited[objId(property)]
) {
visited[objId(property)] = true
DFS(property, callback, i, visited)
}
}
}
}
},
plugins: {},
highlightAll: function (async, callback) {
_.highlightAllUnder(document, async, callback)
},
highlightAllUnder: function (container, async, callback) {
var env = {
callback: callback,
container: container,
selector:
'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
}
_.hooks.run('before-highlightall', env)
env.elements = Array.prototype.slice.apply(
env.container.querySelectorAll(env.selector)
)
_.hooks.run('before-all-elements-highlight', env)
for (var i = 0, element; (element = env.elements[i++]); ) {
_.highlightElement(element, async === true, env.callback)
}
},
highlightElement: function (element, async, callback) {
var language = _.util.getLanguage(element)
var grammar = _.languages[language]
_.util.setLanguage(element, language)
var parent = element.parentElement
if (parent && parent.nodeName.toLowerCase() === 'pre') {
_.util.setLanguage(parent, language)
}
var code = element.textContent
var env = {
element: element,
language: language,
grammar: grammar,
code: code
}
function insertHighlightedCode(highlightedCode) {
env.highlightedCode = highlightedCode
_.hooks.run('before-insert', env)
env.element.innerHTML = env.highlightedCode
_.hooks.run('after-highlight', env)
_.hooks.run('complete', env)
callback && callback.call(env.element)
}
_.hooks.run('before-sanity-check', env)
parent = env.element.parentElement
if (
parent &&
parent.nodeName.toLowerCase() === 'pre' &&
!parent.hasAttribute('tabindex')
) {
parent.setAttribute('tabindex', '0')
}
if (!env.code) {
_.hooks.run('complete', env)
callback && callback.call(env.element)
return
}
_.hooks.run('before-highlight', env)
if (!env.grammar) {
insertHighlightedCode(_.util.encode(env.code))
return
}
if (async && _self.Worker) {
var worker = new Worker(_.filename)
worker.onmessage = function (evt) {
insertHighlightedCode(evt.data)
}
worker.postMessage(
JSON.stringify({
language: env.language,
code: env.code,
immediateClose: true
})
)
} else {
insertHighlightedCode(
_.highlight(env.code, env.grammar, env.language)
)
}
},
highlight: function (text, grammar, language) {
var env = {
code: text,
grammar: grammar,
language: language
}
_.hooks.run('before-tokenize', env)
if (!env.grammar) {
throw new Error(
'The language "' + env.language + '" has no grammar.'
)
}
env.tokens = _.tokenize(env.code, env.grammar)
_.hooks.run('after-tokenize', env)
return Token.stringify(_.util.encode(env.tokens), env.language)
},
tokenize: function (text, grammar) {
var rest = grammar.rest
if (rest) {
for (var token in rest) {
grammar[token] = rest[token]
}
delete grammar.rest
}
var tokenList = new LinkedList()
addAfter(tokenList, tokenList.head, text)
matchGrammar(text, tokenList, grammar, tokenList.head, 0)
return toArray(tokenList)
},
hooks: {
all: {},
add: function (name, callback) {
var hooks = _.hooks.all
hooks[name] = hooks[name] || []
hooks[name].push(callback)
},
run: function (name, env) {
var callbacks = _.hooks.all[name]
if (!callbacks || !callbacks.length) {
return
}
for (var i = 0, callback; (callback = callbacks[i++]); ) {
callback(env)
}
}
},
Token: Token
}
_self.Prism = _
function Token(type, content, alias, matchedStr) {
this.type = type
this.content = content
this.alias = alias
this.length = (matchedStr || '').length | 0
}
Token.stringify = function stringify(o, language) {
if (typeof o == 'string') {
return o
}
if (Array.isArray(o)) {
var s = ''
o.forEach(function (e) {
s += stringify(e, language)
})
return s
}
var env = {
type: o.type,
content: stringify(o.content, language),
tag: 'span',
classes: ['token', o.type],
attributes: {},
language: language
}
var aliases = o.alias
if (aliases) {
if (Array.isArray(aliases)) {
Array.prototype.push.apply(env.classes, aliases)
} else {
env.classes.push(aliases)
}
}
_.hooks.run('wrap', env)
var attributes = ''
for (var name in env.attributes) {
attributes +=
' ' +
name +
'="' +
(env.attributes[name] || '').replace(/"/g, '"') +
'"'
}
return (
'<' +
env.tag +
' class="' +
env.classes.join(' ') +
'"' +
attributes +
'>' +
env.content +
'</' +
env.tag +
'>'
)
}
function matchPattern(pattern, pos, text, lookbehind) {
pattern.lastIndex = pos
var match = pattern.exec(text)
if (match && lookbehind && match[1]) {
var lookbehindLength = match[1].length
match.index += lookbehindLength
match[0] = match[0].slice(lookbehindLength)
}
return match
}
function matchGrammar(
text,
tokenList,
grammar,
startNode,
startPos,
rematch
) {
for (var token in grammar) {
if (!grammar.hasOwnProperty(token) || !grammar[token]) {
continue
}
var patterns = grammar[token]
patterns = Array.isArray(patterns) ? patterns : [patterns]
for (var j = 0; j < patterns.length; ++j) {
if (rematch && rematch.cause == token + ',' + j) {
return
}
var patternObj = patterns[j]
var inside = patternObj.inside
var lookbehind = !!patternObj.lookbehind
var greedy = !!patternObj.greedy
var alias = patternObj.alias
if (greedy && !patternObj.pattern.global) {
var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0]
patternObj.pattern = RegExp(
patternObj.pattern.source,
flags + 'g'
)
}
var pattern = patternObj.pattern || patternObj
for (
var currentNode = startNode.next, pos = startPos;
currentNode !== tokenList.tail;
pos += currentNode.value.length, currentNode = currentNode.next
) {
if (rematch && pos >= rematch.reach) {
break
}
var str = currentNode.value
if (tokenList.length > text.length) {
return
}
if (str instanceof Token) {
continue
}
var removeCount = 1
var match
if (greedy) {
match = matchPattern(pattern, pos, text, lookbehind)
if (!match || match.index >= text.length) {
break
}
var from = match.index
var to = match.index + match[0].length
var p = pos
p += currentNode.value.length
while (from >= p) {
currentNode = currentNode.next
p += currentNode.value.length
}
p -= currentNode.value.length
pos = p
if (currentNode.value instanceof Token) {
continue
}
for (
var k = currentNode;
k !== tokenList.tail &&
(p < to || typeof k.value === 'string');
k = k.next
) {
removeCount++
p += k.value.length
}
removeCount--
str = text.slice(pos, p)
match.index -= pos
} else {
match = matchPattern(pattern, 0, str, lookbehind)
if (!match) {
continue
}
}
var from = match.index
var matchStr = match[0]
var before = str.slice(0, from)
var after = str.slice(from + matchStr.length)
var reach = pos + str.length
if (rematch && reach > rematch.reach) {
rematch.reach = reach
}
var removeFrom = currentNode.prev
if (before) {
removeFrom = addAfter(tokenList, removeFrom, before)
pos += before.length
}
removeRange(tokenList, removeFrom, removeCount)
var wrapped = new Token(
token,
inside ? _.tokenize(matchStr, inside) : matchStr,
alias,
matchStr
)
currentNode = addAfter(tokenList, removeFrom, wrapped)
if (after) {
addAfter(tokenList, currentNode, after)
}
if (removeCount > 1) {
var nestedRematch = {
cause: token + ',' + j,
reach: reach
}
matchGrammar(
text,
tokenList,
grammar,
currentNode.prev,
pos,
nestedRematch
)
if (rematch && nestedRematch.reach > rematch.reach) {
rematch.reach = nestedRematch.reach
}
}
}
}
}
}
function LinkedList() {
var head = {
value: null,
prev: null,
next: null
}
var tail = {
value: null,
prev: head,
next: null
}
head.next = tail
this.head = head
this.tail = tail
this.length = 0
}
function addAfter(list, node, value) {
var next = node.next
var newNode = {
value: value,
prev: node,
next: next
}
node.next = newNode
next.prev = newNode
list.length++
return newNode
}
function removeRange(list, node, count) {
var next = node.next
for (var i = 0; i < count && next !== list.tail; i++) {
next = next.next
}
node.next = next
next.prev = node
list.length -= i
}
function toArray(list) {
var array = []
var node = list.head.next
while (node !== list.tail) {
array.push(node.value)
node = node.next
}
return array
}
if (!_self.document) {
if (!_self.addEventListener) {
return _
}
if (!_.disableWorkerMessageHandler) {
_self.addEventListener(
'message',
function (evt) {
var message = JSON.parse(evt.data)
var lang = message.language
var code = message.code
var immediateClose = message.immediateClose
_self.postMessage(_.highlight(code, _.languages[lang], lang))
if (immediateClose) {
_self.close()
}
},
false
)
}
return _
}
var script = _.util.currentScript()
if (script) {
_.filename = script.src
if (script.hasAttribute('data-manual')) {
_.manual = true
}
}
function highlightAutomaticallyCallback() {
if (!_.manual) {
_.highlightAll()
}
}
if (!_.manual) {
var readyState = document.readyState
if (
readyState === 'loading' ||
(readyState === 'interactive' && script && script.defer)
) {
document.addEventListener(
'DOMContentLoaded',
highlightAutomaticallyCallback
)
} else {
if (window.requestAnimationFrame) {
window.requestAnimationFrame(highlightAutomaticallyCallback)
} else {
window.setTimeout(highlightAutomaticallyCallback, 16)
}
}
}
return _
})(_self)
if (typeof module !== 'undefined' && module.exports) {
module.exports = Prism
}
if (typeof global !== 'undefined') {
global.Prism = Prism
}
Prism.languages.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(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
/<keyword>/g,
function () {
return keyword.source
}
)
Prism.languages.cpp = Prism.languages.extend('c', {
'class-name': [
{
pattern: RegExp(
/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
/<keyword>/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 +
'|' +
/<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
/<mod-name>/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(/<<self>>/g, function () {
return '(?:' + pattern + ')'
})
}
return pattern.replace(/<<self>>/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(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2)
var nestedRound = nested(/\((?:[^()]|<<self>>)*\)/.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>>|\(<<self>>*\)/.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>>|\(<<self>>*\)/.source, [
regularStringCharacterOrComment
]),
2
)
var mInterpolation = replace(
/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source,
[mInterpolationRound, formatString]
)
var sInterpolationRound = nested(
replace(
/[^"'/()]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>|\(<<self>>*\)/
.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(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|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 = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source
var className = {
pattern: RegExp(
/(^|[^\w.])/.source +
classNamePrefix +