gnx/GNX-mailEnterprise
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mail

Browse Source
This commit is contained in:
Iliyan Angelov
2025-09-14 23:24:25 +03:00
commit c67067a2a4
71311 changed files with 6800714 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
frontend/node_modules/refractor/core.js generated vendored Normal file
View File

@@ -0,0 +1,242 @@
'use strict'
/* global window, self */
// istanbul ignore next - Don't allow Prism to run on page load in browser or
// to start messaging from workers.
var ctx =
typeof globalThis === 'object'
? globalThis
: typeof self === 'object'
? self
: typeof window === 'object'
? window
: typeof global === 'object'
? global
: {}
var restore = capture()
ctx.Prism = {manual: true, disableWorkerMessageHandler: true}
// Load all stuff in `prism.js` itself, except for `prism-file-highlight.js`.
// The wrapped non-leaky grammars are loaded instead of Prism’s originals.
var h = require('hastscript')
var decode = require('parse-entities')
var Prism = require('prismjs/components/prism-core')
var markup = require('./lang/markup')
var css = require('./lang/css')
var clike = require('./lang/clike')
var js = require('./lang/javascript')
restore()
var own = {}.hasOwnProperty
// Inherit.
function Refractor() {}
Refractor.prototype = Prism
// Construct.
var refract = new Refractor()
// Expose.
module.exports = refract
// Create.
refract.highlight = highlight
refract.register = register
refract.alias = alias
refract.registered = registered
refract.listLanguages = listLanguages
// Register bundled grammars.
register(markup)
register(css)
register(clike)
register(js)
refract.util.encode = encode
refract.Token.stringify = stringify
function register(grammar) {
if (typeof grammar !== 'function' || !grammar.displayName) {
throw new Error('Expected `function` for `grammar`, got `' + grammar + '`')
}
// Do not duplicate registrations.
if (refract.languages[grammar.displayName] === undefined) {
grammar(refract)
}
}
function alias(name, alias) {
var languages = refract.languages
var map = name
var key
var list
var length
var index
if (alias) {
map = {}
map[name] = alias
}
for (key in map) {
list = map[key]
list = typeof list === 'string' ? [list] : list
length = list.length
index = -1
while (++index < length) {
languages[list[index]] = languages[key]
}
}
}
function highlight(value, name) {
var sup = Prism.highlight
var grammar
if (typeof value !== 'string') {
throw new Error('Expected `string` for `value`, got `' + value + '`')
}
// `name` is a grammar object.
if (refract.util.type(name) === 'Object') {
grammar = name
name = null
} else {
if (typeof name !== 'string') {
throw new Error('Expected `string` for `name`, got `' + name + '`')
}
if (own.call(refract.languages, name)) {
grammar = refract.languages[name]
} else {
throw new Error('Unknown language: `' + name + '` is not registered')
}
}
return sup.call(this, value, grammar, name)
}
function registered(language) {
if (typeof language !== 'string') {
throw new Error('Expected `string` for `language`, got `' + language + '`')
}
return own.call(refract.languages, language)
}
function listLanguages() {
var languages = refract.languages
var list = []
var language
for (language in languages) {
if (
own.call(languages, language) &&
typeof languages[language] === 'object'
) {
list.push(language)
}
}
return list
}
function stringify(value, language, parent) {
var env
if (typeof value === 'string') {
return {type: 'text', value: value}
}
if (refract.util.type(value) === 'Array') {
return stringifyAll(value, language)
}
env = {
type: value.type,
content: refract.Token.stringify(value.content, language, parent),
tag: 'span',
classes: ['token', value.type],
attributes: {},
language: language,
parent: parent
}
if (value.alias) {
env.classes = env.classes.concat(value.alias)
}
refract.hooks.run('wrap', env)
return h(
env.tag + '.' + env.classes.join('.'),
attributes(env.attributes),
env.content
)
}
function stringifyAll(values, language) {
var result = []
var length = values.length
var index = -1
var value
while (++index < length) {
value = values[index]
if (value !== '' && value !== null && value !== undefined) {
result.push(value)
}
}
index = -1
length = result.length
while (++index < length) {
value = result[index]
result[index] = refract.Token.stringify(value, language, result)
}
return result
}
function encode(tokens) {
return tokens
}
function attributes(attrs) {
var key
for (key in attrs) {
attrs[key] = decode(attrs[key])
}
return attrs
}
function capture() {
var defined = 'Prism' in ctx
/* istanbul ignore next */
var current = defined ? ctx.Prism : undefined
return restore
function restore() {
/* istanbul ignore else - Clean leaks after Prism. */
if (defined) {
ctx.Prism = current
} else {
delete ctx.Prism
}
defined = undefined
current = undefined
}
}

279
frontend/node_modules/refractor/index.js generated vendored Normal file
View File

@@ -0,0 +1,279 @@
'use strict'
var refractor = require('./core.js')
module.exports = refractor
refractor.register(require('./lang/abap.js'))
refractor.register(require('./lang/abnf.js'))
refractor.register(require('./lang/actionscript.js'))
refractor.register(require('./lang/ada.js'))
refractor.register(require('./lang/agda.js'))
refractor.register(require('./lang/al.js'))
refractor.register(require('./lang/antlr4.js'))
refractor.register(require('./lang/apacheconf.js'))
refractor.register(require('./lang/apex.js'))
refractor.register(require('./lang/apl.js'))
refractor.register(require('./lang/applescript.js'))
refractor.register(require('./lang/aql.js'))
refractor.register(require('./lang/arduino.js'))
refractor.register(require('./lang/arff.js'))
refractor.register(require('./lang/asciidoc.js'))
refractor.register(require('./lang/asm6502.js'))
refractor.register(require('./lang/asmatmel.js'))
refractor.register(require('./lang/aspnet.js'))
refractor.register(require('./lang/autohotkey.js'))
refractor.register(require('./lang/autoit.js'))
refractor.register(require('./lang/avisynth.js'))
refractor.register(require('./lang/avro-idl.js'))
refractor.register(require('./lang/bash.js'))
refractor.register(require('./lang/basic.js'))
refractor.register(require('./lang/batch.js'))
refractor.register(require('./lang/bbcode.js'))
refractor.register(require('./lang/bicep.js'))
refractor.register(require('./lang/birb.js'))
refractor.register(require('./lang/bison.js'))
refractor.register(require('./lang/bnf.js'))
refractor.register(require('./lang/brainfuck.js'))
refractor.register(require('./lang/brightscript.js'))
refractor.register(require('./lang/bro.js'))
refractor.register(require('./lang/bsl.js'))
refractor.register(require('./lang/c.js'))
refractor.register(require('./lang/cfscript.js'))
refractor.register(require('./lang/chaiscript.js'))
refractor.register(require('./lang/cil.js'))
refractor.register(require('./lang/clojure.js'))
refractor.register(require('./lang/cmake.js'))
refractor.register(require('./lang/cobol.js'))
refractor.register(require('./lang/coffeescript.js'))
refractor.register(require('./lang/concurnas.js'))
refractor.register(require('./lang/coq.js'))
refractor.register(require('./lang/cpp.js'))
refractor.register(require('./lang/crystal.js'))
refractor.register(require('./lang/csharp.js'))
refractor.register(require('./lang/cshtml.js'))
refractor.register(require('./lang/csp.js'))
refractor.register(require('./lang/css-extras.js'))
refractor.register(require('./lang/csv.js'))
refractor.register(require('./lang/cypher.js'))
refractor.register(require('./lang/d.js'))
refractor.register(require('./lang/dart.js'))
refractor.register(require('./lang/dataweave.js'))
refractor.register(require('./lang/dax.js'))
refractor.register(require('./lang/dhall.js'))
refractor.register(require('./lang/diff.js'))
refractor.register(require('./lang/django.js'))
refractor.register(require('./lang/dns-zone-file.js'))
refractor.register(require('./lang/docker.js'))
refractor.register(require('./lang/dot.js'))
refractor.register(require('./lang/ebnf.js'))
refractor.register(require('./lang/editorconfig.js'))
refractor.register(require('./lang/eiffel.js'))
refractor.register(require('./lang/ejs.js'))
refractor.register(require('./lang/elixir.js'))
refractor.register(require('./lang/elm.js'))
refractor.register(require('./lang/erb.js'))
refractor.register(require('./lang/erlang.js'))
refractor.register(require('./lang/etlua.js'))
refractor.register(require('./lang/excel-formula.js'))
refractor.register(require('./lang/factor.js'))
refractor.register(require('./lang/false.js'))
refractor.register(require('./lang/firestore-security-rules.js'))
refractor.register(require('./lang/flow.js'))
refractor.register(require('./lang/fortran.js'))
refractor.register(require('./lang/fsharp.js'))
refractor.register(require('./lang/ftl.js'))
refractor.register(require('./lang/gap.js'))
refractor.register(require('./lang/gcode.js'))
refractor.register(require('./lang/gdscript.js'))
refractor.register(require('./lang/gedcom.js'))
refractor.register(require('./lang/gherkin.js'))
refractor.register(require('./lang/git.js'))
refractor.register(require('./lang/glsl.js'))
refractor.register(require('./lang/gml.js'))
refractor.register(require('./lang/gn.js'))
refractor.register(require('./lang/go-module.js'))
refractor.register(require('./lang/go.js'))
refractor.register(require('./lang/graphql.js'))
refractor.register(require('./lang/groovy.js'))
refractor.register(require('./lang/haml.js'))
refractor.register(require('./lang/handlebars.js'))
refractor.register(require('./lang/haskell.js'))
refractor.register(require('./lang/haxe.js'))
refractor.register(require('./lang/hcl.js'))
refractor.register(require('./lang/hlsl.js'))
refractor.register(require('./lang/hoon.js'))
refractor.register(require('./lang/hpkp.js'))
refractor.register(require('./lang/hsts.js'))
refractor.register(require('./lang/http.js'))
refractor.register(require('./lang/ichigojam.js'))
refractor.register(require('./lang/icon.js'))
refractor.register(require('./lang/icu-message-format.js'))
refractor.register(require('./lang/idris.js'))
refractor.register(require('./lang/iecst.js'))
refractor.register(require('./lang/ignore.js'))
refractor.register(require('./lang/inform7.js'))
refractor.register(require('./lang/ini.js'))
refractor.register(require('./lang/io.js'))
refractor.register(require('./lang/j.js'))
refractor.register(require('./lang/java.js'))
refractor.register(require('./lang/javadoc.js'))
refractor.register(require('./lang/javadoclike.js'))
refractor.register(require('./lang/javastacktrace.js'))
refractor.register(require('./lang/jexl.js'))
refractor.register(require('./lang/jolie.js'))
refractor.register(require('./lang/jq.js'))
refractor.register(require('./lang/js-extras.js'))
refractor.register(require('./lang/js-templates.js'))
refractor.register(require('./lang/jsdoc.js'))
refractor.register(require('./lang/json.js'))
refractor.register(require('./lang/json5.js'))
refractor.register(require('./lang/jsonp.js'))
refractor.register(require('./lang/jsstacktrace.js'))
refractor.register(require('./lang/jsx.js'))
refractor.register(require('./lang/julia.js'))
refractor.register(require('./lang/keepalived.js'))
refractor.register(require('./lang/keyman.js'))
refractor.register(require('./lang/kotlin.js'))
refractor.register(require('./lang/kumir.js'))
refractor.register(require('./lang/kusto.js'))
refractor.register(require('./lang/latex.js'))
refractor.register(require('./lang/latte.js'))
refractor.register(require('./lang/less.js'))
refractor.register(require('./lang/lilypond.js'))
refractor.register(require('./lang/liquid.js'))
refractor.register(require('./lang/lisp.js'))
refractor.register(require('./lang/livescript.js'))
refractor.register(require('./lang/llvm.js'))
refractor.register(require('./lang/log.js'))
refractor.register(require('./lang/lolcode.js'))
refractor.register(require('./lang/lua.js'))
refractor.register(require('./lang/magma.js'))
refractor.register(require('./lang/makefile.js'))
refractor.register(require('./lang/markdown.js'))
refractor.register(require('./lang/markup-templating.js'))
refractor.register(require('./lang/matlab.js'))
refractor.register(require('./lang/maxscript.js'))
refractor.register(require('./lang/mel.js'))
refractor.register(require('./lang/mermaid.js'))
refractor.register(require('./lang/mizar.js'))
refractor.register(require('./lang/mongodb.js'))
refractor.register(require('./lang/monkey.js'))
refractor.register(require('./lang/moonscript.js'))
refractor.register(require('./lang/n1ql.js'))
refractor.register(require('./lang/n4js.js'))
refractor.register(require('./lang/nand2tetris-hdl.js'))
refractor.register(require('./lang/naniscript.js'))
refractor.register(require('./lang/nasm.js'))
refractor.register(require('./lang/neon.js'))
refractor.register(require('./lang/nevod.js'))
refractor.register(require('./lang/nginx.js'))
refractor.register(require('./lang/nim.js'))
refractor.register(require('./lang/nix.js'))
refractor.register(require('./lang/nsis.js'))
refractor.register(require('./lang/objectivec.js'))
refractor.register(require('./lang/ocaml.js'))
refractor.register(require('./lang/opencl.js'))
refractor.register(require('./lang/openqasm.js'))
refractor.register(require('./lang/oz.js'))
refractor.register(require('./lang/parigp.js'))
refractor.register(require('./lang/parser.js'))
refractor.register(require('./lang/pascal.js'))
refractor.register(require('./lang/pascaligo.js'))
refractor.register(require('./lang/pcaxis.js'))
refractor.register(require('./lang/peoplecode.js'))
refractor.register(require('./lang/perl.js'))
refractor.register(require('./lang/php-extras.js'))
refractor.register(require('./lang/php.js'))
refractor.register(require('./lang/phpdoc.js'))
refractor.register(require('./lang/plsql.js'))
refractor.register(require('./lang/powerquery.js'))
refractor.register(require('./lang/powershell.js'))
refractor.register(require('./lang/processing.js'))
refractor.register(require('./lang/prolog.js'))
refractor.register(require('./lang/promql.js'))
refractor.register(require('./lang/properties.js'))
refractor.register(require('./lang/protobuf.js'))
refractor.register(require('./lang/psl.js'))
refractor.register(require('./lang/pug.js'))
refractor.register(require('./lang/puppet.js'))
refractor.register(require('./lang/pure.js'))
refractor.register(require('./lang/purebasic.js'))
refractor.register(require('./lang/purescript.js'))
refractor.register(require('./lang/python.js'))
refractor.register(require('./lang/q.js'))
refractor.register(require('./lang/qml.js'))
refractor.register(require('./lang/qore.js'))
refractor.register(require('./lang/qsharp.js'))
refractor.register(require('./lang/r.js'))
refractor.register(require('./lang/racket.js'))
refractor.register(require('./lang/reason.js'))
refractor.register(require('./lang/regex.js'))
refractor.register(require('./lang/rego.js'))
refractor.register(require('./lang/renpy.js'))
refractor.register(require('./lang/rest.js'))
refractor.register(require('./lang/rip.js'))
refractor.register(require('./lang/roboconf.js'))
refractor.register(require('./lang/robotframework.js'))
refractor.register(require('./lang/ruby.js'))
refractor.register(require('./lang/rust.js'))
refractor.register(require('./lang/sas.js'))
refractor.register(require('./lang/sass.js'))
refractor.register(require('./lang/scala.js'))
refractor.register(require('./lang/scheme.js'))
refractor.register(require('./lang/scss.js'))
refractor.register(require('./lang/shell-session.js'))
refractor.register(require('./lang/smali.js'))
refractor.register(require('./lang/smalltalk.js'))
refractor.register(require('./lang/smarty.js'))
refractor.register(require('./lang/sml.js'))
refractor.register(require('./lang/solidity.js'))
refractor.register(require('./lang/solution-file.js'))
refractor.register(require('./lang/soy.js'))
refractor.register(require('./lang/sparql.js'))
refractor.register(require('./lang/splunk-spl.js'))
refractor.register(require('./lang/sqf.js'))
refractor.register(require('./lang/sql.js'))
refractor.register(require('./lang/squirrel.js'))
refractor.register(require('./lang/stan.js'))
refractor.register(require('./lang/stylus.js'))
refractor.register(require('./lang/swift.js'))
refractor.register(require('./lang/systemd.js'))
refractor.register(require('./lang/t4-cs.js'))
refractor.register(require('./lang/t4-templating.js'))
refractor.register(require('./lang/t4-vb.js'))
refractor.register(require('./lang/tap.js'))
refractor.register(require('./lang/tcl.js'))
refractor.register(require('./lang/textile.js'))
refractor.register(require('./lang/toml.js'))
refractor.register(require('./lang/tremor.js'))
refractor.register(require('./lang/tsx.js'))
refractor.register(require('./lang/tt2.js'))
refractor.register(require('./lang/turtle.js'))
refractor.register(require('./lang/twig.js'))
refractor.register(require('./lang/typescript.js'))
refractor.register(require('./lang/typoscript.js'))
refractor.register(require('./lang/unrealscript.js'))
refractor.register(require('./lang/uorazor.js'))
refractor.register(require('./lang/uri.js'))
refractor.register(require('./lang/v.js'))
refractor.register(require('./lang/vala.js'))
refractor.register(require('./lang/vbnet.js'))
refractor.register(require('./lang/velocity.js'))
refractor.register(require('./lang/verilog.js'))
refractor.register(require('./lang/vhdl.js'))
refractor.register(require('./lang/vim.js'))
refractor.register(require('./lang/visual-basic.js'))
refractor.register(require('./lang/warpscript.js'))
refractor.register(require('./lang/wasm.js'))
refractor.register(require('./lang/web-idl.js'))
refractor.register(require('./lang/wiki.js'))
refractor.register(require('./lang/wolfram.js'))
refractor.register(require('./lang/wren.js'))
refractor.register(require('./lang/xeora.js'))
refractor.register(require('./lang/xml-doc.js'))
refractor.register(require('./lang/xojo.js'))
refractor.register(require('./lang/xquery.js'))
refractor.register(require('./lang/yaml.js'))
refractor.register(require('./lang/yang.js'))
refractor.register(require('./lang/zig.js'))

59
frontend/node_modules/refractor/lang/abap.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

63
frontend/node_modules/refractor/lang/abnf.js generated vendored Normal file
View File

@@ -0,0 +1,63 @@
'use strict'
module.exports = abnf
abnf.displayName = 'abnf'
abnf.aliases = []
function abnf(Prism) {
;(function (Prism) {
var coreRules =
'(?:ALPHA|BIT|CHAR|CR|CRLF|CTL|DIGIT|DQUOTE|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)'
Prism.languages.abnf = {
comment: /;.*/,
string: {
pattern: /(?:%[is])?"[^"\n\r]*"/,
greedy: true,
inside: {
punctuation: /^%[is]/
}
},
range: {
pattern: /%(?:b[01]+-[01]+|d\d+-\d+|x[A-F\d]+-[A-F\d]+)/i,
alias: 'number'
},
terminal: {
pattern:
/%(?:b[01]+(?:\.[01]+)*|d\d+(?:\.\d+)*|x[A-F\d]+(?:\.[A-F\d]+)*)/i,
alias: 'number'
},
repetition: {
pattern: /(^|[^\w-])(?:\d*\*\d*|\d+)/,
lookbehind: true,
alias: 'operator'
},
definition: {
pattern: /(^[ \t]*)(?:[a-z][\w-]*|<[^<>\r\n]*>)(?=\s*=)/m,
lookbehind: true,
alias: 'keyword',
inside: {
punctuation: /<|>/
}
},
'core-rule': {
pattern: RegExp(
'(?:(^|[^<\\w-])' + coreRules + '|<' + coreRules + '>)(?![\\w-])',
'i'
),
lookbehind: true,
alias: ['rule', 'constant'],
inside: {
punctuation: /<|>/
}
},
rule: {
pattern: /(^|[^<\w-])[a-z][\w-]*|<[^<>\r\n]*>/i,
lookbehind: true,
inside: {
punctuation: /<|>/
}
},
operator: /=\/?|\//,
punctuation: /[()\[\]]/
}
})(Prism)
}

25
frontend/node_modules/refractor/lang/actionscript.js generated vendored Normal file
View File

@@ -0,0 +1,25 @@
'use strict'
module.exports = actionscript
actionscript.displayName = 'actionscript'
actionscript.aliases = []
function actionscript(Prism) {
Prism.languages.actionscript = Prism.languages.extend('javascript', {
keyword:
/\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/,
operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/
})
Prism.languages.actionscript['class-name'].alias = 'function' // doesn't work with AS because AS is too complex
delete Prism.languages.actionscript['parameter']
delete Prism.languages.actionscript['literal-property']
if (Prism.languages.markup) {
Prism.languages.insertBefore('actionscript', 'string', {
xml: {
pattern:
/(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/,
lookbehind: true,
inside: Prism.languages.markup
}
})
}
}

28
frontend/node_modules/refractor/lang/ada.js generated vendored Normal file
View File

@@ -0,0 +1,28 @@
'use strict'
module.exports = ada
ada.displayName = 'ada'
ada.aliases = []
function ada(Prism) {
Prism.languages.ada = {
comment: /--.*/,
string: /"(?:""|[^"\r\f\n])*"/,
number: [
{
pattern:
/\b\d(?:_?\d)*#[\dA-F](?:_?[\dA-F])*(?:\.[\dA-F](?:_?[\dA-F])*)?#(?:E[+-]?\d(?:_?\d)*)?/i
},
{
pattern: /\b\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:E[+-]?\d(?:_?\d)*)?\b/i
}
],
'attr-name': /\b'\w+/,
keyword:
/\b(?:abort|abs|abstract|accept|access|aliased|all|and|array|at|begin|body|case|constant|declare|delay|delta|digits|do|else|elsif|end|entry|exception|exit|for|function|generic|goto|if|in|interface|is|limited|loop|mod|new|not|null|of|others|out|overriding|package|pragma|private|procedure|protected|raise|range|record|rem|renames|requeue|return|reverse|select|separate|some|subtype|synchronized|tagged|task|terminate|then|type|until|use|when|while|with|xor)\b/i,
boolean: /\b(?:false|true)\b/i,
operator: /<[=>]?|>=?|=>?|:=|\/=?|\*\*?|[&+-]/,
punctuation: /\.\.?|[,;():]/,
char: /'.'/,
variable: /\b[a-z](?:\w)*\b/i
}
}

31
frontend/node_modules/refractor/lang/agda.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
'use strict'
module.exports = agda
agda.displayName = 'agda'
agda.aliases = []
function agda(Prism) {
;(function (Prism) {
Prism.languages.agda = {
comment: /\{-[\s\S]*?(?:-\}|$)|--.*/,
string: {
pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
greedy: true
},
punctuation: /[(){}⦃⦄.;@]/,
'class-name': {
pattern: /((?:data|record) +)\S+/,
lookbehind: true
},
function: {
pattern: /(^[ \t]*)(?!\s)[^:\r\n]+(?=:)/m,
lookbehind: true
},
operator: {
pattern: /(^\s*|\s)(?:[=|:∀→λ\\?_]|->)(?=\s)/,
lookbehind: true
},
keyword:
/\b(?:Set|abstract|constructor|data|eta-equality|field|forall|hiding|import|in|inductive|infix|infixl|infixr|instance|let|macro|module|mutual|no-eta-equality|open|overlap|pattern|postulate|primitive|private|public|quote|quoteContext|quoteGoal|quoteTerm|record|renaming|rewrite|syntax|tactic|unquote|unquoteDecl|unquoteDef|using|variable|where|with)\b/
}
})(Prism)
}

33
frontend/node_modules/refractor/lang/al.js generated vendored Normal file
View File

@@ -0,0 +1,33 @@
'use strict'
module.exports = al
al.displayName = 'al'
al.aliases = []
function al(Prism) {
// based on https://github.com/microsoft/AL/blob/master/grammar/alsyntax.tmlanguage
Prism.languages.al = {
comment: /\/\/.*|\/\*[\s\S]*?\*\//,
string: {
pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
greedy: true
},
function: {
pattern:
/(\b(?:event|procedure|trigger)\s+|(?:^|[^.])\.\s*)[a-z_]\w*(?=\s*\()/i,
lookbehind: true
},
keyword: [
// keywords
/\b(?:array|asserterror|begin|break|case|do|downto|else|end|event|exit|for|foreach|function|if|implements|in|indataset|interface|internal|local|of|procedure|program|protected|repeat|runonclient|securityfiltering|suppressdispose|temporary|then|to|trigger|until|var|while|with|withevents)\b/i, // objects and metadata that are used like keywords
/\b(?:action|actions|addafter|addbefore|addfirst|addlast|area|assembly|chartpart|codeunit|column|controladdin|cuegroup|customizes|dataitem|dataset|dotnet|elements|enum|enumextension|extends|field|fieldattribute|fieldelement|fieldgroup|fieldgroups|fields|filter|fixed|grid|group|key|keys|label|labels|layout|modify|moveafter|movebefore|movefirst|movelast|page|pagecustomization|pageextension|part|profile|query|repeater|report|requestpage|schema|separator|systempart|table|tableelement|tableextension|textattribute|textelement|type|usercontrol|value|xmlport)\b/i
],
number:
/\b(?:0x[\da-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(?:F|LL?|U(?:LL?)?)?\b/i,
boolean: /\b(?:false|true)\b/i,
variable: /\b(?:Curr(?:FieldNo|Page|Report)|x?Rec|RequestOptionsPage)\b/,
'class-name':
/\b(?:automation|biginteger|bigtext|blob|boolean|byte|char|clienttype|code|completiontriggererrorlevel|connectiontype|database|dataclassification|datascope|date|dateformula|datetime|decimal|defaultlayout|dialog|dictionary|dotnetassembly|dotnettypedeclaration|duration|errorinfo|errortype|executioncontext|executionmode|fieldclass|fieldref|fieldtype|file|filterpagebuilder|guid|httpclient|httpcontent|httpheaders|httprequestmessage|httpresponsemessage|instream|integer|joker|jsonarray|jsonobject|jsontoken|jsonvalue|keyref|list|moduledependencyinfo|moduleinfo|none|notification|notificationscope|objecttype|option|outstream|pageresult|record|recordid|recordref|reportformat|securityfilter|sessionsettings|tableconnectiontype|tablefilter|testaction|testfield|testfilterfield|testpage|testpermissions|testrequestpage|text|textbuilder|textconst|textencoding|time|transactionmodel|transactiontype|variant|verbosity|version|view|views|webserviceactioncontext|webserviceactionresultcode|xmlattribute|xmlattributecollection|xmlcdata|xmlcomment|xmldeclaration|xmldocument|xmldocumenttype|xmlelement|xmlnamespacemanager|xmlnametable|xmlnode|xmlnodelist|xmlprocessinginstruction|xmlreadoptions|xmltext|xmlwriteoptions)\b/i,
operator: /\.\.|:[=:]|[-+*/]=?|<>|[<>]=?|=|\b(?:and|div|mod|not|or|xor)\b/i,
punctuation: /[()\[\]{}:.;,]/
}
}

74
frontend/node_modules/refractor/lang/antlr4.js generated vendored Normal file
View File

@@ -0,0 +1,74 @@
'use strict'
module.exports = antlr4
antlr4.displayName = 'antlr4'
antlr4.aliases = ['g4']
function antlr4(Prism) {
Prism.languages.antlr4 = {
comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
string: {
pattern: /'(?:\\.|[^\\'\r\n])*'/,
greedy: true
},
'character-class': {
pattern: /\[(?:\\.|[^\\\]\r\n])*\]/,
greedy: true,
alias: 'regex',
inside: {
range: {
pattern: /([^[]|(?:^|[^\\])(?:\\\\)*\\\[)-(?!\])/,
lookbehind: true,
alias: 'punctuation'
},
escape:
/\\(?:u(?:[a-fA-F\d]{4}|\{[a-fA-F\d]+\})|[pP]\{[=\w-]+\}|[^\r\nupP])/,
punctuation: /[\[\]]/
}
},
action: {
pattern: /\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\}/,
greedy: true,
inside: {
content: {
// this might be C, C++, Python, Java, C#, or any other language ANTLR4 compiles to
pattern: /(\{)[\s\S]+(?=\})/,
lookbehind: true
},
punctuation: /[{}]/
}
},
command: {
pattern:
/(->\s*(?!\s))(?:\s*(?:,\s*)?\b[a-z]\w*(?:\s*\([^()\r\n]*\))?)+(?=\s*;)/i,
lookbehind: true,
inside: {
function: /\b\w+(?=\s*(?:[,(]|$))/,
punctuation: /[,()]/
}
},
annotation: {
pattern: /@\w+(?:::\w+)*/,
alias: 'keyword'
},
label: {
pattern: /#[ \t]*\w+/,
alias: 'punctuation'
},
keyword:
/\b(?:catch|channels|finally|fragment|grammar|import|lexer|locals|mode|options|parser|returns|throws|tokens)\b/,
definition: [
{
pattern: /\b[a-z]\w*(?=\s*:)/,
alias: ['rule', 'class-name']
},
{
pattern: /\b[A-Z]\w*(?=\s*:)/,
alias: ['token', 'constant']
}
],
constant: /\b[A-Z][A-Z_]*\b/,
operator: /\.\.|->|[|~]|[*+?]\??/,
punctuation: /[;:()=]/
}
Prism.languages.g4 = Prism.languages.antlr4
}

56
frontend/node_modules/refractor/lang/apacheconf.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

82
frontend/node_modules/refractor/lang/apex.js generated vendored Normal file
View File

@@ -0,0 +1,82 @@
'use strict'
var refractorSql = require('./sql.js')
module.exports = apex
apex.displayName = 'apex'
apex.aliases = []
function apex(Prism) {
Prism.register(refractorSql)
;(function (Prism) {
var keywords =
/\b(?:(?:after|before)(?=\s+[a-z])|abstract|activate|and|any|array|as|asc|autonomous|begin|bigdecimal|blob|boolean|break|bulk|by|byte|case|cast|catch|char|class|collect|commit|const|continue|currency|date|datetime|decimal|default|delete|desc|do|double|else|end|enum|exception|exit|export|extends|final|finally|float|for|from|get(?=\s*[{};])|global|goto|group|having|hint|if|implements|import|in|inner|insert|instanceof|int|integer|interface|into|join|like|limit|list|long|loop|map|merge|new|not|null|nulls|number|object|of|on|or|outer|override|package|parallel|pragma|private|protected|public|retrieve|return|rollback|select|set|short|sObject|sort|static|string|super|switch|synchronized|system|testmethod|then|this|throw|time|transaction|transient|trigger|try|undelete|update|upsert|using|virtual|void|webservice|when|where|while|(?:inherited|with|without)\s+sharing)\b/i
var className =
/\b(?:(?=[a-z_]\w*\s*[<\[])|(?!<keyword>))[A-Z_]\w*(?:\s*\.\s*[A-Z_]\w*)*\b(?:\s*(?:\[\s*\]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>))*/.source.replace(
/<keyword>/g,
function () {
return keywords.source
}
)
/** @param {string} pattern */
function insertClassName(pattern) {
return RegExp(
pattern.replace(/<CLASS-NAME>/g, function () {
return className
}),
'i'
)
}
var classNameInside = {
keyword: keywords,
punctuation: /[()\[\]{};,:.<>]/
}
Prism.languages.apex = {
comment: Prism.languages.clike.comment,
string: Prism.languages.clike.string,
sql: {
pattern: /((?:[=,({:]|\breturn)\s*)\[[^\[\]]*\]/i,
lookbehind: true,
greedy: true,
alias: 'language-sql',
inside: Prism.languages.sql
},
annotation: {
pattern: /@\w+\b/,
alias: 'punctuation'
},
'class-name': [
{
pattern: insertClassName(
/(\b(?:class|enum|extends|implements|instanceof|interface|new|trigger\s+\w+\s+on)\s+)<CLASS-NAME>/
.source
),
lookbehind: true,
inside: classNameInside
},
{
// cast
pattern: insertClassName(
/(\(\s*)<CLASS-NAME>(?=\s*\)\s*[\w(])/.source
),
lookbehind: true,
inside: classNameInside
},
{
// variable/parameter declaration and return types
pattern: insertClassName(/<CLASS-NAME>(?=\s*\w+\s*[;=,(){:])/.source),
inside: classNameInside
}
],
trigger: {
pattern: /(\btrigger\s+)\w+\b/i,
lookbehind: true,
alias: 'class-name'
},
keyword: keywords,
function: /\b[a-z_]\w*(?=\s*\()/i,
boolean: /\b(?:false|true)\b/i,
number: /(?:\B\.\d+|\b\d+(?:\.\d+|L)?)\b/i,
operator:
/[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
punctuation: /[()\[\]{};,.]/
}
})(Prism)
}

40
frontend/node_modules/refractor/lang/apl.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
'use strict'
module.exports = apl
apl.displayName = 'apl'
apl.aliases = []
function apl(Prism) {
Prism.languages.apl = {
comment: /(?:⍝|#[! ]).*$/m,
string: {
pattern: /'(?:[^'\r\n]|'')*'/,
greedy: true
},
number:
/¯?(?:\d*\.?\b\d+(?:e[+¯]?\d+)?|¯|∞)(?:j¯?(?:(?:\d+(?:\.\d+)?|\.\d+)(?:e[+¯]?\d+)?|¯|∞))?/i,
statement: /:[A-Z][a-z][A-Za-z]*\b/,
'system-function': {
pattern: /⎕[A-Z]+/i,
alias: 'function'
},
constant: /[⍬⌾#⎕⍞]/,
function: /[-+×÷⌈⌊∣|⍳⍸?*⍟○!⌹<≤=>≥≠≡≢∊⍷∪∩~∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⊆⊇⌷⍋⍒⊤⊥⍕⍎⊣⊢⍁⍂≈⍯↗¤→]/,
'monadic-operator': {
pattern: /[\\\/⌿⍀¨⍨⌶&∥]/,
alias: 'operator'
},
'dyadic-operator': {
pattern: /[.⍣⍠⍤∘⌸@⌺⍥]/,
alias: 'operator'
},
assignment: {
pattern: /←/,
alias: 'keyword'
},
punctuation: /[\[;\]()◇⋄]/,
dfn: {
pattern: /[{}⍺⍵⍶⍹∇⍫:]/,
alias: 'builtin'
}
}
}

26
frontend/node_modules/refractor/lang/applescript.js generated vendored Normal file
View File

@@ -0,0 +1,26 @@
'use strict'
module.exports = applescript
applescript.displayName = 'applescript'
applescript.aliases = []
function applescript(Prism) {
Prism.languages.applescript = {
comment: [
// Allow one level of nesting
/\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
/--.+/,
/#.+/
],
string: /"(?:\\.|[^"\\\r\n])*"/,
number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?\b/i,
operator: [
/[&=≠≤≥*+\-\/÷^]|[<>]=?/,
/\b(?:(?:begin|end|start)s? with|(?:contains?|(?:does not|doesn't) contain)|(?:is|isn't|is not) (?:contained by|in)|(?:(?:is|isn't|is not) )?(?:greater|less) than(?: or equal)?(?: to)?|(?:comes|(?:does not|doesn't) come) (?:after|before)|(?:is|isn't|is not) equal(?: to)?|(?:(?:does not|doesn't) equal|equal to|equals|is not|isn't)|(?:a )?(?:ref(?: to)?|reference to)|(?:and|as|div|mod|not|or))\b/
],
keyword:
/\b(?:about|above|after|against|apart from|around|aside from|at|back|before|beginning|behind|below|beneath|beside|between|but|by|considering|continue|copy|does|eighth|else|end|equal|error|every|exit|false|fifth|first|for|fourth|from|front|get|given|global|if|ignoring|in|instead of|into|is|it|its|last|local|me|middle|my|ninth|of|on|onto|out of|over|prop|property|put|repeat|return|returning|second|set|seventh|since|sixth|some|tell|tenth|that|the|then|third|through|thru|timeout|times|to|transaction|true|try|until|where|while|whose|with|without)\b/,
'class-name':
/\b(?:POSIX file|RGB color|alias|application|boolean|centimeters|centimetres|class|constant|cubic centimeters|cubic centimetres|cubic feet|cubic inches|cubic meters|cubic metres|cubic yards|date|degrees Celsius|degrees Fahrenheit|degrees Kelvin|feet|file|gallons|grams|inches|integer|kilograms|kilometers|kilometres|list|liters|litres|meters|metres|miles|number|ounces|pounds|quarts|real|record|reference|script|square feet|square kilometers|square kilometres|square meters|square metres|square miles|square yards|text|yards)\b/,
punctuation: /[{}():,¬«»《》]/
}
}

56
frontend/node_modules/refractor/lang/aql.js generated vendored Normal file
View File

@@ -0,0 +1,56 @@
'use strict'
module.exports = aql
aql.displayName = 'aql'
aql.aliases = []
function aql(Prism) {
Prism.languages.aql = {
comment: /\/\/.*|\/\*[\s\S]*?\*\//,
property: {
pattern:
/([{,]\s*)(?:(?!\d)\w+|(["'´`])(?:(?!\2)[^\\\r\n]|\\.)*\2)(?=\s*:)/,
lookbehind: true,
greedy: true
},
string: {
pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
greedy: true
},
identifier: {
pattern: /([´`])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
greedy: true
},
variable: /@@?\w+/,
keyword: [
{
pattern: /(\bWITH\s+)COUNT(?=\s+INTO\b)/i,
lookbehind: true
},
/\b(?:AGGREGATE|ALL|AND|ANY|ASC|COLLECT|DESC|DISTINCT|FILTER|FOR|GRAPH|IN|INBOUND|INSERT|INTO|K_PATHS|K_SHORTEST_PATHS|LET|LIKE|LIMIT|NONE|NOT|NULL|OR|OUTBOUND|REMOVE|REPLACE|RETURN|SHORTEST_PATH|SORT|UPDATE|UPSERT|WINDOW|WITH)\b/i, // pseudo keywords get a lookbehind to avoid false positives
{
pattern: /(^|[^\w.[])(?:KEEP|PRUNE|SEARCH|TO)\b/i,
lookbehind: true
},
{
pattern: /(^|[^\w.[])(?:CURRENT|NEW|OLD)\b/,
lookbehind: true
},
{
pattern: /\bOPTIONS(?=\s*\{)/i
}
],
function: /\b(?!\d)\w+(?=\s*\()/,
boolean: /\b(?:false|true)\b/i,
range: {
pattern: /\.\./,
alias: 'operator'
},
number: [
/\b0b[01]+/i,
/\b0x[0-9a-f]+/i,
/(?:\B\.\d+|\b(?:0|[1-9]\d*)(?:\.\d+)?)(?:e[+-]?\d+)?/i
],
operator: /\*{2,}|[=!]~|[!=<>]=?|&&|\|\||[-+*/%]/,
punctuation: /::|[?.:,;()[\]{}]/
}
}

17
frontend/node_modules/refractor/lang/arduino.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
'use strict'
var refractorCpp = require('./cpp.js')
module.exports = arduino
arduino.displayName = 'arduino'
arduino.aliases = ['ino']
function arduino(Prism) {
Prism.register(refractorCpp)
Prism.languages.arduino = Prism.languages.extend('cpp', {
keyword:
/\b(?:String|array|bool|boolean|break|byte|case|catch|continue|default|do|double|else|finally|for|function|goto|if|in|instanceof|int|integer|long|loop|new|null|return|setup|string|switch|throw|try|void|while|word)\b/,
constant:
/\b(?:ANALOG_MESSAGE|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FIRMATA_STRING|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL2V56|LED_BUILTIN|LOW|OUTPUT|REPORT_ANALOG|REPORT_DIGITAL|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET)\b/,
builtin:
/\b(?:Audio|BSSID|Bridge|Client|Console|EEPROM|Esplora|EsploraTFT|Ethernet|EthernetClient|EthernetServer|EthernetUDP|File|FileIO|FileSystem|Firmata|GPRS|GSM|GSMBand|GSMClient|GSMModem|GSMPIN|GSMScanner|GSMServer|GSMVoiceCall|GSM_SMS|HttpClient|IPAddress|IRread|Keyboard|KeyboardController|LiquidCrystal|LiquidCrystal_I2C|Mailbox|Mouse|MouseController|PImage|Process|RSSI|RobotControl|RobotMotor|SD|SPI|SSID|Scheduler|Serial|Server|Servo|SoftwareSerial|Stepper|Stream|TFT|Task|USBHost|WiFi|WiFiClient|WiFiServer|WiFiUDP|Wire|YunClient|YunServer|abs|addParameter|analogRead|analogReadResolution|analogReference|analogWrite|analogWriteResolution|answerCall|attach|attachGPRS|attachInterrupt|attached|autoscroll|available|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|bitClear|bitRead|bitSet|bitWrite|blink|blinkVersion|buffer|changePIN|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compassRead|config|connect|connected|constrain|cos|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|delay|delayMicroseconds|detach|detachInterrupt|digitalRead|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endTransmission|endWrite|exists|exitValue|fill|find|findUntil|flush|gatewayIP|get|getAsynchronously|getBand|getButton|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|home|image|interrupts|isActionDone|isDirectory|isListening|isPIN|isPressed|isValid|keyPressed|keyReleased|keyboardRead|knobRead|leftToRight|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|lowByte|macAddress|maintain|map|max|messageAvailable|micros|millis|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|noListenOnLocalhost|noStroke|noTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|pinMode|playFile|playMelody|point|pointTo|position|pow|prepare|press|print|printFirmwareVersion|printVersion|println|process|processInput|pulseIn|put|random|randomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|run|runAsynchronously|runShellCommand|runShellCommandAsynchronously|running|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|serialEvent|setBand|setBitOrder|setClockDivider|setCursor|setDNS|setDataMode|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|shiftIn|shiftOut|shutdown|sin|size|sqrt|startLoop|step|stop|stroke|subnetMask|switchPIN|tan|tempoWrite|text|tone|transfer|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRGB|writeRed|yield)\b/
})
Prism.languages.ino = Prism.languages.arduino
}

17
frontend/node_modules/refractor/lang/arff.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
'use strict'
module.exports = arff
arff.displayName = 'arff'
arff.aliases = []
function arff(Prism) {
Prism.languages.arff = {
comment: /%.*/,
string: {
pattern: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
greedy: true
},
keyword: /@(?:attribute|data|end|relation)\b/i,
number: /\b\d+(?:\.\d+)?\b/,
punctuation: /[{},]/
}
}

228
frontend/node_modules/refractor/lang/asciidoc.js generated vendored Normal file
View File

@@ -0,0 +1,228 @@
'use strict'
module.exports = asciidoc
asciidoc.displayName = 'asciidoc'
asciidoc.aliases = ['adoc']
function asciidoc(Prism) {
;(function (Prism) {
var attributes = {
pattern:
/(^[ \t]*)\[(?!\[)(?:(["'$`])(?:(?!\2)[^\\]|\\.)*\2|\[(?:[^\[\]\\]|\\.)*\]|[^\[\]\\"'$`]|\\.)*\]/m,
lookbehind: true,
inside: {
quoted: {
pattern: /([$`])(?:(?!\1)[^\\]|\\.)*\1/,
inside: {
punctuation: /^[$`]|[$`]$/
}
},
interpreted: {
pattern: /'(?:[^'\\]|\\.)*'/,
inside: {
punctuation: /^'|'$/ // See rest below
}
},
string: /"(?:[^"\\]|\\.)*"/,
variable: /\w+(?==)/,
punctuation: /^\[|\]$|,/,
operator: /=/,
// The negative look-ahead prevents blank matches
'attr-value': /(?!^\s+$).+/
}
}
var asciidoc = (Prism.languages.asciidoc = {
'comment-block': {
pattern: /^(\/{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1/m,
alias: 'comment'
},
table: {
pattern: /^\|={3,}(?:(?:\r?\n|\r(?!\n)).*)*?(?:\r?\n|\r)\|={3,}$/m,
inside: {
specifiers: {
pattern:
/(?:(?:(?:\d+(?:\.\d+)?|\.\d+)[+*](?:[<^>](?:\.[<^>])?|\.[<^>])?|[<^>](?:\.[<^>])?|\.[<^>])[a-z]*|[a-z]+)(?=\|)/,
alias: 'attr-value'
},
punctuation: {
pattern: /(^|[^\\])[|!]=*/,
lookbehind: true
} // See rest below
}
},
'passthrough-block': {
pattern: /^(\+{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
inside: {
punctuation: /^\++|\++$/ // See rest below
}
},
// Literal blocks and listing blocks
'literal-block': {
pattern: /^(-{4,}|\.{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
inside: {
punctuation: /^(?:-+|\.+)|(?:-+|\.+)$/ // See rest below
}
},
// Sidebar blocks, quote blocks, example blocks and open blocks
'other-block': {
pattern:
/^(--|\*{4,}|_{4,}|={4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
inside: {
punctuation: /^(?:-+|\*+|_+|=+)|(?:-+|\*+|_+|=+)$/ // See rest below
}
},
// list-punctuation and list-label must appear before indented-block
'list-punctuation': {
pattern:
/(^[ \t]*)(?:-|\*{1,5}|\.{1,5}|(?:[a-z]|\d+)\.|[xvi]+\))(?= )/im,
lookbehind: true,
alias: 'punctuation'
},
'list-label': {
pattern: /(^[ \t]*)[a-z\d].+(?::{2,4}|;;)(?=\s)/im,
lookbehind: true,
alias: 'symbol'
},
'indented-block': {
pattern: /((\r?\n|\r)\2)([ \t]+)\S.*(?:(?:\r?\n|\r)\3.+)*(?=\2{2}|$)/,
lookbehind: true
},
comment: /^\/\/.*/m,
title: {
pattern:
/^.+(?:\r?\n|\r)(?:={3,}|-{3,}|~{3,}|\^{3,}|\+{3,})$|^={1,5} .+|^\.(?![\s.]).*/m,
alias: 'important',
inside: {
punctuation: /^(?:\.|=+)|(?:=+|-+|~+|\^+|\++)$/ // See rest below
}
},
'attribute-entry': {
pattern: /^:[^:\r\n]+:(?: .*?(?: \+(?:\r?\n|\r).*?)*)?$/m,
alias: 'tag'
},
attributes: attributes,
hr: {
pattern: /^'{3,}$/m,
alias: 'punctuation'
},
'page-break': {
pattern: /^<{3,}$/m,
alias: 'punctuation'
},
admonition: {
pattern: /^(?:CAUTION|IMPORTANT|NOTE|TIP|WARNING):/m,
alias: 'keyword'
},
callout: [
{
pattern: /(^[ \t]*)<?\d*>/m,
lookbehind: true,
alias: 'symbol'
},
{
pattern: /<\d+>/,
alias: 'symbol'
}
],
macro: {
pattern:
/\b[a-z\d][a-z\d-]*::?(?:[^\s\[\]]*\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
inside: {
function: /^[a-z\d-]+(?=:)/,
punctuation: /^::?/,
attributes: {
pattern: /(?:\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
inside: attributes.inside
}
}
},
inline: {
/*
The initial look-behind prevents the highlighting of escaped quoted text.
Quoted text can be multi-line but cannot span an empty line.
All quoted text can have attributes before [foobar, 'foobar', baz="bar"].
First, we handle the constrained quotes.
Those must be bounded by non-word chars and cannot have spaces between the delimiter and the first char.
They are, in order: _emphasis_, ``double quotes'', `single quotes', `monospace`, 'emphasis', *strong*, +monospace+ and #unquoted#
Then we handle the unconstrained quotes.
Those do not have the restrictions of the constrained quotes.
They are, in order: __emphasis__, **strong**, ++monospace++, +++passthrough+++, ##unquoted##, $$passthrough$$, ~subscript~, ^superscript^, {attribute-reference}, [[anchor]], [[[bibliography anchor]]], <<xref>>, (((indexes))) and ((indexes))
*/
pattern:
/(^|[^\\])(?:(?:\B\[(?:[^\]\\"']|(["'])(?:(?!\2)[^\\]|\\.)*\2|\\.)*\])?(?:\b_(?!\s)(?: _|[^_\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: _|[^_\\\r\n]|\\.)+)*_\b|\B``(?!\s).+?(?:(?:\r?\n|\r).+?)*''\B|\B`(?!\s)(?:[^`'\s]|\s+\S)+['`]\B|\B(['*+#])(?!\s)(?: \3|(?!\3)[^\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: \3|(?!\3)[^\\\r\n]|\\.)+)*\3\B)|(?:\[(?:[^\]\\"']|(["'])(?:(?!\4)[^\\]|\\.)*\4|\\.)*\])?(?:(__|\*\*|\+\+\+?|##|\$\$|[~^]).+?(?:(?:\r?\n|\r).+?)*\5|\{[^}\r\n]+\}|\[\[\[?.+?(?:(?:\r?\n|\r).+?)*\]?\]\]|<<.+?(?:(?:\r?\n|\r).+?)*>>|\(\(\(?.+?(?:(?:\r?\n|\r).+?)*\)?\)\)))/m,
lookbehind: true,
inside: {
attributes: attributes,
url: {
pattern: /^(?:\[\[\[?.+?\]?\]\]|<<.+?>>)$/,
inside: {
punctuation: /^(?:\[\[\[?|<<)|(?:\]\]\]?|>>)$/
}
},
'attribute-ref': {
pattern: /^\{.+\}$/,
inside: {
variable: {
pattern: /(^\{)[a-z\d,+_-]+/,
lookbehind: true
},
operator: /^[=?!#%@$]|!(?=[:}])/,
punctuation: /^\{|\}$|::?/
}
},
italic: {
pattern: /^(['_])[\s\S]+\1$/,
inside: {
punctuation: /^(?:''?|__?)|(?:''?|__?)$/
}
},
bold: {
pattern: /^\*[\s\S]+\*$/,
inside: {
punctuation: /^\*\*?|\*\*?$/
}
},
punctuation:
/^(?:``?|\+{1,3}|##?|\$\$|[~^]|\(\(\(?)|(?:''?|\+{1,3}|##?|\$\$|[~^`]|\)?\)\))$/
}
},
replacement: {
pattern: /\((?:C|R|TM)\)/,
alias: 'builtin'
},
entity: /&#?[\da-z]{1,8};/i,
'line-continuation': {
pattern: /(^| )\+$/m,
lookbehind: true,
alias: 'punctuation'
}
}) // Allow some nesting. There is no recursion though, so cloning should not be needed.
function copyFromAsciiDoc(keys) {
keys = keys.split(' ')
var o = {}
for (var i = 0, l = keys.length; i < l; i++) {
o[keys[i]] = asciidoc[keys[i]]
}
return o
}
attributes.inside['interpreted'].inside.rest = copyFromAsciiDoc(
'macro inline replacement entity'
)
asciidoc['passthrough-block'].inside.rest = copyFromAsciiDoc('macro')
asciidoc['literal-block'].inside.rest = copyFromAsciiDoc('callout')
asciidoc['table'].inside.rest = copyFromAsciiDoc(
'comment-block passthrough-block literal-block other-block list-punctuation indented-block comment title attribute-entry attributes hr page-break admonition list-label callout macro inline replacement entity line-continuation'
)
asciidoc['other-block'].inside.rest = copyFromAsciiDoc(
'table list-punctuation indented-block comment attribute-entry attributes hr page-break admonition list-label macro inline replacement entity line-continuation'
)
asciidoc['title'].inside.rest = copyFromAsciiDoc(
'macro inline replacement entity'
) // Plugin to make entity title show the real entity, idea by Roman Komarov
Prism.hooks.add('wrap', function (env) {
if (env.type === 'entity') {
env.attributes['title'] = env.content.value.replace(/&amp;/, '&')
}
})
Prism.languages.adoc = Prism.languages.asciidoc
})(Prism)
}

37
frontend/node_modules/refractor/lang/asm6502.js generated vendored Normal file
View File

@@ -0,0 +1,37 @@
'use strict'
module.exports = asm6502
asm6502.displayName = 'asm6502'
asm6502.aliases = []
function asm6502(Prism) {
Prism.languages.asm6502 = {
comment: /;.*/,
directive: {
pattern: /\.\w+(?= )/,
alias: 'property'
},
string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
'op-code': {
pattern:
/\b(?:ADC|AND|ASL|BCC|BCS|BEQ|BIT|BMI|BNE|BPL|BRK|BVC|BVS|CLC|CLD|CLI|CLV|CMP|CPX|CPY|DEC|DEX|DEY|EOR|INC|INX|INY|JMP|JSR|LDA|LDX|LDY|LSR|NOP|ORA|PHA|PHP|PLA|PLP|ROL|ROR|RTI|RTS|SBC|SEC|SED|SEI|STA|STX|STY|TAX|TAY|TSX|TXA|TXS|TYA|adc|and|asl|bcc|bcs|beq|bit|bmi|bne|bpl|brk|bvc|bvs|clc|cld|cli|clv|cmp|cpx|cpy|dec|dex|dey|eor|inc|inx|iny|jmp|jsr|lda|ldx|ldy|lsr|nop|ora|pha|php|pla|plp|rol|ror|rti|rts|sbc|sec|sed|sei|sta|stx|sty|tax|tay|tsx|txa|txs|tya)\b/,
alias: 'keyword'
},
'hex-number': {
pattern: /#?\$[\da-f]{1,4}\b/i,
alias: 'number'
},
'binary-number': {
pattern: /#?%[01]+\b/,
alias: 'number'
},
'decimal-number': {
pattern: /#?\b\d+\b/,
alias: 'number'
},
register: {
pattern: /\b[xya]\b/i,
alias: 'variable'
},
punctuation: /[(),:]/
}
}

49
frontend/node_modules/refractor/lang/asmatmel.js generated vendored Normal file
View File

@@ -0,0 +1,49 @@
'use strict'
module.exports = asmatmel
asmatmel.displayName = 'asmatmel'
asmatmel.aliases = []
function asmatmel(Prism) {
Prism.languages.asmatmel = {
comment: {
pattern: /;.*/,
greedy: true
},
string: {
pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
greedy: true
},
constant: /\b(?:PORT[A-Z]|DDR[A-Z]|(?:DD|P)[A-Z](?:\d|[0-2]\d|3[01]))\b/,
directive: {
pattern: /\.\w+(?= )/,
alias: 'property'
},
'r-register': {
pattern: /\br(?:\d|[12]\d|3[01])\b/,
alias: 'variable'
},
'op-code': {
pattern:
/\b(?:ADC|ADD|ADIW|AND|ANDI|ASR|BCLR|BLD|BRBC|BRBS|BRCC|BRCS|BREAK|BREQ|BRGE|BRHC|BRHS|BRID|BRIE|BRLO|BRLT|BRMI|BRNE|BRPL|BRSH|BRTC|BRTS|BRVC|BRVS|BSET|BST|CALL|CBI|CBR|CLC|CLH|CLI|CLN|CLR|CLS|CLT|CLV|CLZ|COM|CP|CPC|CPI|CPSE|DEC|DES|EICALL|EIJMP|ELPM|EOR|FMUL|FMULS|FMULSU|ICALL|IJMP|IN|INC|JMP|LAC|LAS|LAT|LD|LD[A-Za-z0-9]|LPM|LSL|LSR|MOV|MOVW|MUL|MULS|MULSU|NEG|NOP|OR|ORI|OUT|POP|PUSH|RCALL|RET|RETI|RJMP|ROL|ROR|SBC|SBCI|SBI|SBIC|SBIS|SBIW|SBR|SBRC|SBRS|SEC|SEH|SEI|SEN|SER|SES|SET|SEV|SEZ|SLEEP|SPM|ST|ST[A-Z0-9]|SUB|SUBI|SWAP|TST|WDR|XCH|adc|add|adiw|and|andi|asr|bclr|bld|brbc|brbs|brcc|brcs|break|breq|brge|brhc|brhs|brid|brie|brlo|brlt|brmi|brne|brpl|brsh|brtc|brts|brvc|brvs|bset|bst|call|cbi|cbr|clc|clh|cli|cln|clr|cls|clt|clv|clz|com|cp|cpc|cpi|cpse|dec|des|eicall|eijmp|elpm|eor|fmul|fmuls|fmulsu|icall|ijmp|in|inc|jmp|lac|las|lat|ld|ld[a-z0-9]|lpm|lsl|lsr|mov|movw|mul|muls|mulsu|neg|nop|or|ori|out|pop|push|rcall|ret|reti|rjmp|rol|ror|sbc|sbci|sbi|sbic|sbis|sbiw|sbr|sbrc|sbrs|sec|seh|sei|sen|ser|ses|set|sev|sez|sleep|spm|st|st[a-zA-Z0-9]|sub|subi|swap|tst|wdr|xch)\b/,
alias: 'keyword'
},
'hex-number': {
pattern: /#?\$[\da-f]{2,4}\b/i,
alias: 'number'
},
'binary-number': {
pattern: /#?%[01]+\b/,
alias: 'number'
},
'decimal-number': {
pattern: /#?\b\d+\b/,
alias: 'number'
},
register: {
pattern: /\b[acznvshtixy]\b/i,
alias: 'variable'
},
operator: />>=?|<<=?|&&?|\|\|?|[-+*/%&|^!=<>?]=?/,
punctuation: /[(),:]/
}
}

62
frontend/node_modules/refractor/lang/aspnet.js generated vendored Normal file
View File

@@ -0,0 +1,62 @@
'use strict'
var refractorCsharp = require('./csharp.js')
module.exports = aspnet
aspnet.displayName = 'aspnet'
aspnet.aliases = []
function aspnet(Prism) {
Prism.register(refractorCsharp)
Prism.languages.aspnet = Prism.languages.extend('markup', {
'page-directive': {
pattern: /<%\s*@.*%>/,
alias: 'tag',
inside: {
'page-directive': {
pattern:
/<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
alias: 'tag'
},
rest: Prism.languages.markup.tag.inside
}
},
directive: {
pattern: /<%.*%>/,
alias: 'tag',
inside: {
directive: {
pattern: /<%\s*?[$=%#:]{0,2}|%>/,
alias: 'tag'
},
rest: Prism.languages.csharp
}
}
}) // Regexp copied from prism-markup, with a negative look-ahead added
Prism.languages.aspnet.tag.pattern =
/<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/ // match directives of attribute value foo="<% Bar %>"
Prism.languages.insertBefore(
'inside',
'punctuation',
{
directive: Prism.languages.aspnet['directive']
},
Prism.languages.aspnet.tag.inside['attr-value']
)
Prism.languages.insertBefore('aspnet', 'comment', {
'asp-comment': {
pattern: /<%--[\s\S]*?--%>/,
alias: ['asp', 'comment']
}
}) // script runat="server" contains csharp, not javascript
Prism.languages.insertBefore(
'aspnet',
Prism.languages.javascript ? 'script' : 'tag',
{
'asp-script': {
pattern:
/(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
lookbehind: true,
alias: ['asp', 'script'],
inside: Prism.languages.csharp || {}
}
}
)
}

47
frontend/node_modules/refractor/lang/autohotkey.js generated vendored Normal file
View File

@@ -0,0 +1,47 @@
'use strict'
module.exports = autohotkey
autohotkey.displayName = 'autohotkey'
autohotkey.aliases = []
function autohotkey(Prism) {
// NOTES - follows first-first highlight method, block is locked after highlight, different from SyntaxHl
Prism.languages.autohotkey = {
comment: [
{
pattern: /(^|\s);.*/,
lookbehind: true
},
{
pattern:
/(^[\t ]*)\/\*(?:[\r\n](?![ \t]*\*\/)|[^\r\n])*(?:[\r\n][ \t]*\*\/)?/m,
lookbehind: true,
greedy: true
}
],
tag: {
// labels
pattern: /^([ \t]*)[^\s,`":]+(?=:[ \t]*$)/m,
lookbehind: true
},
string: /"(?:[^"\n\r]|"")*"/,
variable: /%\w+%/,
number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
operator:
/\?|\/\/?=?|:=|\|[=|]?|&[=&]?|\+[=+]?|-[=-]?|\*[=*]?|<(?:<=?|>|=)?|>>?=?|[.^!=~]=?|\b(?:AND|NOT|OR)\b/,
boolean: /\b(?:false|true)\b/,
selector:
/\b(?:AutoTrim|BlockInput|Break|Click|ClipWait|Continue|Control|ControlClick|ControlFocus|ControlGet|ControlGetFocus|ControlGetPos|ControlGetText|ControlMove|ControlSend|ControlSendRaw|ControlSetText|CoordMode|Critical|DetectHiddenText|DetectHiddenWindows|Drive|DriveGet|DriveSpaceFree|EnvAdd|EnvDiv|EnvGet|EnvMult|EnvSet|EnvSub|EnvUpdate|Exit|ExitApp|FileAppend|FileCopy|FileCopyDir|FileCreateDir|FileCreateShortcut|FileDelete|FileEncoding|FileGetAttrib|FileGetShortcut|FileGetSize|FileGetTime|FileGetVersion|FileInstall|FileMove|FileMoveDir|FileRead|FileReadLine|FileRecycle|FileRecycleEmpty|FileRemoveDir|FileSelectFile|FileSelectFolder|FileSetAttrib|FileSetTime|FormatTime|GetKeyState|Gosub|Goto|GroupActivate|GroupAdd|GroupClose|GroupDeactivate|Gui|GuiControl|GuiControlGet|Hotkey|ImageSearch|IniDelete|IniRead|IniWrite|Input|InputBox|KeyWait|ListHotkeys|ListLines|ListVars|Loop|Menu|MouseClick|MouseClickDrag|MouseGetPos|MouseMove|MsgBox|OnExit|OutputDebug|Pause|PixelGetColor|PixelSearch|PostMessage|Process|Progress|Random|RegDelete|RegRead|RegWrite|Reload|Repeat|Return|Run|RunAs|RunWait|Send|SendEvent|SendInput|SendMessage|SendMode|SendPlay|SendRaw|SetBatchLines|SetCapslockState|SetControlDelay|SetDefaultMouseSpeed|SetEnv|SetFormat|SetKeyDelay|SetMouseDelay|SetNumlockState|SetRegView|SetScrollLockState|SetStoreCapslockMode|SetTimer|SetTitleMatchMode|SetWinDelay|SetWorkingDir|Shutdown|Sleep|Sort|SoundBeep|SoundGet|SoundGetWaveVolume|SoundPlay|SoundSet|SoundSetWaveVolume|SplashImage|SplashTextOff|SplashTextOn|SplitPath|StatusBarGetText|StatusBarWait|StringCaseSense|StringGetPos|StringLeft|StringLen|StringLower|StringMid|StringReplace|StringRight|StringSplit|StringTrimLeft|StringTrimRight|StringUpper|Suspend|SysGet|Thread|ToolTip|Transform|TrayTip|URLDownloadToFile|WinActivate|WinActivateBottom|WinClose|WinGet|WinGetActiveStats|WinGetActiveTitle|WinGetClass|WinGetPos|WinGetText|WinGetTitle|WinHide|WinKill|WinMaximize|WinMenuSelectItem|WinMinimize|WinMinimizeAll|WinMinimizeAllUndo|WinMove|WinRestore|WinSet|WinSetTitle|WinShow|WinWait|WinWaitActive|WinWaitClose|WinWaitNotActive)\b/i,
constant:
/\b(?:a_ahkpath|a_ahkversion|a_appdata|a_appdatacommon|a_autotrim|a_batchlines|a_caretx|a_carety|a_computername|a_controldelay|a_cursor|a_dd|a_ddd|a_dddd|a_defaultmousespeed|a_desktop|a_desktopcommon|a_detecthiddentext|a_detecthiddenwindows|a_endchar|a_eventinfo|a_exitreason|a_fileencoding|a_formatfloat|a_formatinteger|a_gui|a_guicontrol|a_guicontrolevent|a_guievent|a_guiheight|a_guiwidth|a_guix|a_guiy|a_hour|a_iconfile|a_iconhidden|a_iconnumber|a_icontip|a_index|a_ipaddress1|a_ipaddress2|a_ipaddress3|a_ipaddress4|a_is64bitos|a_isadmin|a_iscompiled|a_iscritical|a_ispaused|a_issuspended|a_isunicode|a_keydelay|a_language|a_lasterror|a_linefile|a_linenumber|a_loopfield|a_loopfileattrib|a_loopfiledir|a_loopfileext|a_loopfilefullpath|a_loopfilelongpath|a_loopfilename|a_loopfileshortname|a_loopfileshortpath|a_loopfilesize|a_loopfilesizekb|a_loopfilesizemb|a_loopfiletimeaccessed|a_loopfiletimecreated|a_loopfiletimemodified|a_loopreadline|a_loopregkey|a_loopregname|a_loopregsubkey|a_loopregtimemodified|a_loopregtype|a_mday|a_min|a_mm|a_mmm|a_mmmm|a_mon|a_mousedelay|a_msec|a_mydocuments|a_now|a_nowutc|a_numbatchlines|a_ostype|a_osversion|a_priorhotkey|a_priorkey|a_programfiles|a_programs|a_programscommon|a_ptrsize|a_regview|a_screendpi|a_screenheight|a_screenwidth|a_scriptdir|a_scriptfullpath|a_scripthwnd|a_scriptname|a_sec|a_space|a_startmenu|a_startmenucommon|a_startup|a_startupcommon|a_stringcasesense|a_tab|a_temp|a_thisfunc|a_thishotkey|a_thislabel|a_thismenu|a_thismenuitem|a_thismenuitempos|a_tickcount|a_timeidle|a_timeidlephysical|a_timesincepriorhotkey|a_timesincethishotkey|a_titlematchmode|a_titlematchmodespeed|a_username|a_wday|a_windelay|a_windir|a_workingdir|a_yday|a_year|a_yweek|a_yyyy|clipboard|clipboardall|comspec|errorlevel|programfiles)\b/i,
builtin:
/\b(?:abs|acos|asc|asin|atan|ceil|chr|class|comobjactive|comobjarray|comobjconnect|comobjcreate|comobjerror|comobjflags|comobjget|comobjquery|comobjtype|comobjvalue|cos|dllcall|exp|fileexist|Fileopen|floor|format|il_add|il_create|il_destroy|instr|isfunc|islabel|IsObject|ln|log|ltrim|lv_add|lv_delete|lv_deletecol|lv_getcount|lv_getnext|lv_gettext|lv_insert|lv_insertcol|lv_modify|lv_modifycol|lv_setimagelist|mod|numget|numput|onmessage|regexmatch|regexreplace|registercallback|round|rtrim|sb_seticon|sb_setparts|sb_settext|sin|sqrt|strlen|strreplace|strsplit|substr|tan|tv_add|tv_delete|tv_get|tv_getchild|tv_getcount|tv_getnext|tv_getparent|tv_getprev|tv_getselection|tv_gettext|tv_modify|varsetcapacity|winactive|winexist|__Call|__Get|__New|__Set)\b/i,
symbol:
/\b(?:alt|altdown|altup|appskey|backspace|browser_back|browser_favorites|browser_forward|browser_home|browser_refresh|browser_search|browser_stop|bs|capslock|ctrl|ctrlbreak|ctrldown|ctrlup|del|delete|down|end|enter|esc|escape|f1|f10|f11|f12|f13|f14|f15|f16|f17|f18|f19|f2|f20|f21|f22|f23|f24|f3|f4|f5|f6|f7|f8|f9|home|ins|insert|joy1|joy10|joy11|joy12|joy13|joy14|joy15|joy16|joy17|joy18|joy19|joy2|joy20|joy21|joy22|joy23|joy24|joy25|joy26|joy27|joy28|joy29|joy3|joy30|joy31|joy32|joy4|joy5|joy6|joy7|joy8|joy9|joyaxes|joybuttons|joyinfo|joyname|joypov|joyr|joyu|joyv|joyx|joyy|joyz|lalt|launch_app1|launch_app2|launch_mail|launch_media|lbutton|lcontrol|lctrl|left|lshift|lwin|lwindown|lwinup|mbutton|media_next|media_play_pause|media_prev|media_stop|numlock|numpad0|numpad1|numpad2|numpad3|numpad4|numpad5|numpad6|numpad7|numpad8|numpad9|numpadadd|numpadclear|numpaddel|numpaddiv|numpaddot|numpaddown|numpadend|numpadenter|numpadhome|numpadins|numpadleft|numpadmult|numpadpgdn|numpadpgup|numpadright|numpadsub|numpadup|pgdn|pgup|printscreen|ralt|rbutton|rcontrol|rctrl|right|rshift|rwin|rwindown|rwinup|scrolllock|shift|shiftdown|shiftup|space|tab|up|volume_down|volume_mute|volume_up|wheeldown|wheelleft|wheelright|wheelup|xbutton1|xbutton2)\b/i,
important:
/#\b(?:AllowSameLineComments|ClipboardTimeout|CommentFlag|DerefChar|ErrorStdOut|EscapeChar|HotkeyInterval|HotkeyModifierTimeout|Hotstring|If|IfTimeout|IfWinActive|IfWinExist|IfWinNotActive|IfWinNotExist|Include|IncludeAgain|InputLevel|InstallKeybdHook|InstallMouseHook|KeyHistory|MaxHotkeysPerInterval|MaxMem|MaxThreads|MaxThreadsBuffer|MaxThreadsPerHotkey|MenuMaskKey|NoEnv|NoTrayIcon|Persistent|SingleInstance|UseHook|Warn|WinActivateForce)\b/i,
keyword:
/\b(?:Abort|AboveNormal|Add|ahk_class|ahk_exe|ahk_group|ahk_id|ahk_pid|All|Alnum|Alpha|AltSubmit|AltTab|AltTabAndMenu|AltTabMenu|AltTabMenuDismiss|AlwaysOnTop|AutoSize|Background|BackgroundTrans|BelowNormal|between|BitAnd|BitNot|BitOr|BitShiftLeft|BitShiftRight|BitXOr|Bold|Border|Button|ByRef|Catch|Checkbox|Checked|CheckedGray|Choose|ChooseString|Close|Color|ComboBox|Contains|ControlList|Count|Date|DateTime|Days|DDL|Default|DeleteAll|Delimiter|Deref|Destroy|Digit|Disable|Disabled|DropDownList|Edit|Eject|Else|Enable|Enabled|Error|Exist|Expand|ExStyle|FileSystem|Finally|First|Flash|Float|FloatFast|Focus|Font|for|global|Grid|Group|GroupBox|GuiClose|GuiContextMenu|GuiDropFiles|GuiEscape|GuiSize|Hdr|Hidden|Hide|High|HKCC|HKCR|HKCU|HKEY_CLASSES_ROOT|HKEY_CURRENT_CONFIG|HKEY_CURRENT_USER|HKEY_LOCAL_MACHINE|HKEY_USERS|HKLM|HKU|Hours|HScroll|Icon|IconSmall|ID|IDLast|If|IfEqual|IfExist|IfGreater|IfGreaterOrEqual|IfInString|IfLess|IfLessOrEqual|IfMsgBox|IfNotEqual|IfNotExist|IfNotInString|IfWinActive|IfWinExist|IfWinNotActive|IfWinNotExist|Ignore|ImageList|in|Integer|IntegerFast|Interrupt|is|italic|Join|Label|LastFound|LastFoundExist|Limit|Lines|List|ListBox|ListView|local|Lock|Logoff|Low|Lower|Lowercase|MainWindow|Margin|Maximize|MaximizeBox|MaxSize|Minimize|MinimizeBox|MinMax|MinSize|Minutes|MonthCal|Mouse|Move|Multi|NA|No|NoActivate|NoDefault|NoHide|NoIcon|NoMainWindow|norm|Normal|NoSort|NoSortHdr|NoStandard|Not|NoTab|NoTimers|Number|Off|Ok|On|OwnDialogs|Owner|Parse|Password|Picture|Pixel|Pos|Pow|Priority|ProcessName|Radio|Range|Read|ReadOnly|Realtime|Redraw|Region|REG_BINARY|REG_DWORD|REG_EXPAND_SZ|REG_MULTI_SZ|REG_SZ|Relative|Rename|Report|Resize|Restore|Retry|RGB|Screen|Seconds|Section|Serial|SetLabel|ShiftAltTab|Show|Single|Slider|SortDesc|Standard|static|Status|StatusBar|StatusCD|strike|Style|Submit|SysMenu|Tab2|TabStop|Text|Theme|Throw|Tile|ToggleCheck|ToggleEnable|ToolWindow|Top|Topmost|TransColor|Transparent|Tray|TreeView|Try|TryAgain|Type|UnCheck|underline|Unicode|Unlock|Until|UpDown|Upper|Uppercase|UseErrorLevel|Vis|VisFirst|Visible|VScroll|Wait|WaitClose|WantCtrlA|WantF2|WantReturn|While|Wrap|Xdigit|xm|xp|xs|Yes|ym|yp|ys)\b/i,
function: /[^(); \t,\n+*\-=?>:\\\/<&%\[\]]+(?=\()/,
punctuation: /[{}[\]():,]/
}
}

43
frontend/node_modules/refractor/lang/autoit.js generated vendored Normal file
View File

@@ -0,0 +1,43 @@
'use strict'
module.exports = autoit
autoit.displayName = 'autoit'
autoit.aliases = []
function autoit(Prism) {
Prism.languages.autoit = {
comment: [
/;.*/,
{
// The multi-line comments delimiters can actually be commented out with ";"
pattern:
/(^[\t ]*)#(?:comments-start|cs)[\s\S]*?^[ \t]*#(?:ce|comments-end)/m,
lookbehind: true
}
],
url: {
pattern: /(^[\t ]*#include\s+)(?:<[^\r\n>]+>|"[^\r\n"]+")/m,
lookbehind: true
},
string: {
pattern: /(["'])(?:\1\1|(?!\1)[^\r\n])*\1/,
greedy: true,
inside: {
variable: /([%$@])\w+\1/
}
},
directive: {
pattern: /(^[\t ]*)#[\w-]+/m,
lookbehind: true,
alias: 'keyword'
},
function: /\b\w+(?=\()/,
// Variables and macros
variable: /[$@]\w+/,
keyword:
/\b(?:Case|Const|Continue(?:Case|Loop)|Default|Dim|Do|Else(?:If)?|End(?:Func|If|Select|Switch|With)|Enum|Exit(?:Loop)?|For|Func|Global|If|In|Local|Next|Null|ReDim|Select|Static|Step|Switch|Then|To|Until|Volatile|WEnd|While|With)\b/i,
number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
boolean: /\b(?:False|True)\b/i,
operator: /<[=>]?|[-+*\/=&>]=?|[?^]|\b(?:And|Not|Or)\b/i,
punctuation: /[\[\]().,:]/
}
}

170
frontend/node_modules/refractor/lang/avisynth.js generated vendored Normal file
View File

@@ -0,0 +1,170 @@
'use strict'
module.exports = avisynth
avisynth.displayName = 'avisynth'
avisynth.aliases = ['avs']
function avisynth(Prism) {
// http://avisynth.nl/index.php/The_full_AviSynth_grammar
;(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 || '')
}
var types = /bool|clip|float|int|string|val/.source
var internals = [
// bools
/is(?:bool|clip|float|int|string)|defined|(?:(?:internal)?function|var)?exists?/
.source, // control
/apply|assert|default|eval|import|nop|select|undefined/.source, // global
/opt_(?:allowfloataudio|avipadscanlines|dwchannelmask|enable_(?:b64a|planartopackedrgb|v210|y3_10_10|y3_10_16)|usewaveextensible|vdubplanarhack)|set(?:cachemode|maxcpu|memorymax|planarlegacyalignment|workingdir)/
.source, // conv
/hex(?:value)?|value/.source, // numeric
/abs|ceil|continued(?:denominator|numerator)?|exp|floor|fmod|frac|log(?:10)?|max|min|muldiv|pi|pow|rand|round|sign|spline|sqrt/
.source, // trig
/a?sinh?|a?cosh?|a?tan[2h]?/.source, // bit
/(?:bit(?:and|not|x?or|[lr]?shift[aslu]?|sh[lr]|sa[lr]|[lr]rotatel?|ro[rl]|te?st|set(?:count)?|cl(?:ea)?r|ch(?:an)?ge?))/
.source, // runtime
/average(?:[bgr]|chroma[uv]|luma)|(?:[rgb]|chroma[uv]|luma|rgb|[yuv](?=difference(?:fromprevious|tonext)))difference(?:fromprevious|tonext)?|[yuvrgb]plane(?:median|min|max|minmaxdifference)/
.source, // script
/getprocessinfo|logmsg|script(?:dir(?:utf8)?|file(?:utf8)?|name(?:utf8)?)|setlogparams/
.source, // string
/chr|(?:fill|find|left|mid|replace|rev|right)str|format|[lu]case|ord|str(?:cmpi?|fromutf8|len|toutf8)|time|trim(?:all|left|right)/
.source, // version
/isversionorgreater|version(?:number|string)/.source, // helper
/buildpixeltype|colorspacenametopixeltype/.source, // avsplus
/addautoloaddir|on(?:cpu|cuda)|prefetch|setfiltermtmode/.source
].join('|')
var properties = [
// content
/has(?:audio|video)/.source, // resolution
/height|width/.source, // framerate
/frame(?:count|rate)|framerate(?:denominator|numerator)/.source, // interlacing
/getparity|is(?:field|frame)based/.source, // color format
/bitspercomponent|componentsize|hasalpha|is(?:planar(?:rgba?)?|interleaved|rgb(?:24|32|48|64)?|y(?:8|u(?:va?|y2))?|yv(?:12|16|24|411)|420|422|444|packedrgb)|numcomponents|pixeltype/
.source, // audio
/audio(?:bits|channels|duration|length(?:[fs]|hi|lo)?|rate)|isaudio(?:float|int)/
.source
].join('|')
var filters = [
// source
/avi(?:file)?source|directshowsource|image(?:reader|source|sourceanim)|opendmlsource|segmented(?:avisource|directshowsource)|wavsource/
.source, // color
/coloryuv|convertbacktoyuy2|convertto(?:RGB(?:24|32|48|64)|(?:planar)?RGBA?|Y8?|YV(?:12|16|24|411)|YUVA?(?:411|420|422|444)|YUY2)|fixluminance|gr[ae]yscale|invert|levels|limiter|mergea?rgb|merge(?:chroma|luma)|rgbadjust|show(?:alpha|blue|green|red)|swapuv|tweak|[uv]toy8?|ytouv/
.source, // overlay
/(?:colorkey|reset)mask|layer|mask(?:hs)?|merge|overlay|subtract/.source, // geometry
/addborders|(?:bicubic|bilinear|blackman|gauss|lanczos4|lanczos|point|sinc|spline(?:16|36|64))resize|crop(?:bottom)?|flip(?:horizontal|vertical)|(?:horizontal|vertical)?reduceby2|letterbox|skewrows|turn(?:180|left|right)/
.source, // pixel
/blur|fixbrokenchromaupsampling|generalconvolution|(?:spatial|temporal)soften|sharpen/
.source, // timeline
/trim|(?:un)?alignedsplice|(?:assume|assumescaled|change|convert)FPS|(?:delete|duplicate)frame|dissolve|fade(?:in|io|out)[02]?|freezeframe|interleave|loop|reverse|select(?:even|odd|(?:range)?every)/
.source, // interlace
/assume[bt]ff|assume(?:field|frame)based|bob|complementparity|doubleweave|peculiarblend|pulldown|separate(?:columns|fields|rows)|swapfields|weave(?:columns|rows)?/
.source, // audio
/amplify(?:db)?|assumesamplerate|audiodub(?:ex)?|audiotrim|convertaudioto(?:(?:8|16|24|32)bit|float)|converttomono|delayaudio|ensurevbrmp3sync|get(?:left|right)?channel|kill(?:audio|video)|mergechannels|mixaudio|monotostereo|normalize|resampleaudio|ssrc|supereq|timestretch/
.source, // conditional
/animate|applyrange|conditional(?:filter|reader|select)|frameevaluate|scriptclip|tcp(?:server|source)|writefile(?:end|if|start)?/
.source, // export
/imagewriter/.source, // debug
/blackness|blankclip|colorbars(?:hd)?|compare|dumpfiltergraph|echo|histogram|info|messageclip|preroll|setgraphanalysis|show(?:framenumber|smpte|time)|showfiveversions|stack(?:horizontal|vertical)|subtitle|tone|version/
.source
].join('|')
var allinternals = [internals, properties, filters].join('|')
Prism.languages.avisynth = {
comment: [
{
// Matches [* *] nestable block comments, but only supports 1 level of nested comments
// /\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|<self>)*\*\]/
pattern:
/(^|[^\\])\[\*(?:[^\[*]|\[(?!\*)|\*(?!\])|\[\*(?:[^\[*]|\[(?!\*)|\*(?!\]))*\*\])*\*\]/,
lookbehind: true,
greedy: true
},
{
// Matches /* */ block comments
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
lookbehind: true,
greedy: true
},
{
// Matches # comments
pattern: /(^|[^\\$])#.*/,
lookbehind: true,
greedy: true
}
],
// Handle before strings because optional arguments are surrounded by double quotes
argument: {
pattern: re(/\b(?:<<0>>)\s+("?)\w+\1/.source, [types], 'i'),
inside: {
keyword: /^\w+/
}
},
// Optional argument assignment
'argument-label': {
pattern: /([,(][\s\\]*)\w+\s*=(?!=)/,
lookbehind: true,
inside: {
'argument-name': {
pattern: /^\w+/,
alias: 'punctuation'
},
punctuation: /=$/
}
},
string: [
{
// triple double-quoted
pattern: /"""[\s\S]*?"""/,
greedy: true
},
{
// single double-quoted
pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
greedy: true,
inside: {
constant: {
// These *are* case-sensitive!
pattern:
/\b(?:DEFAULT_MT_MODE|(?:MAINSCRIPT|PROGRAM|SCRIPT)DIR|(?:MACHINE|USER)_(?:CLASSIC|PLUS)_PLUGINS)\b/
}
}
}
],
// The special "last" variable that takes the value of the last implicitly returned clip
variable: /\b(?:last)\b/i,
boolean: /\b(?:false|no|true|yes)\b/i,
keyword:
/\b(?:catch|else|for|function|global|if|return|try|while|__END__)\b/i,
constant: /\bMT_(?:MULTI_INSTANCE|NICE_FILTER|SERIALIZED|SPECIAL_MT)\b/,
// AviSynth's internal functions, filters, and properties
'builtin-function': {
pattern: re(/\b(?:<<0>>)\b/.source, [allinternals], 'i'),
alias: 'function'
},
'type-cast': {
pattern: re(/\b(?:<<0>>)(?=\s*\()/.source, [types], 'i'),
alias: 'keyword'
},
// External/user-defined filters
function: {
pattern: /\b[a-z_]\w*(?=\s*\()|(\.)[a-z_]\w*\b/i,
lookbehind: true
},
// Matches a \ as the first or last character on a line
'line-continuation': {
pattern: /(^[ \t]*)\\|\\(?=[ \t]*$)/m,
lookbehind: true,
alias: 'punctuation'
},
number:
/\B\$(?:[\da-f]{6}|[\da-f]{8})\b|(?:(?:\b|\B-)\d+(?:\.\d*)?\b|\B\.\d+\b)/i,
operator: /\+\+?|[!=<>]=?|&&|\|\||[?:*/%-]/,
punctuation: /[{}\[\]();,.]/
}
Prism.languages.avs = Prism.languages.avisynth
})(Prism)
}

53
frontend/node_modules/refractor/lang/avro-idl.js generated vendored Normal file
View File

@@ -0,0 +1,53 @@
'use strict'
module.exports = avroIdl
avroIdl.displayName = 'avroIdl'
avroIdl.aliases = []
function avroIdl(Prism) {
// GitHub: https://github.com/apache/avro
// Docs: https://avro.apache.org/docs/current/idl.html
Prism.languages['avro-idl'] = {
comment: {
pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
greedy: true
},
string: {
pattern: /(^|[^\\])"(?:[^\r\n"\\]|\\.)*"/,
lookbehind: true,
greedy: true
},
annotation: {
pattern: /@(?:[$\w.-]|`[^\r\n`]+`)+/,
greedy: true,
alias: 'function'
},
'function-identifier': {
pattern: /`[^\r\n`]+`(?=\s*\()/,
greedy: true,
alias: 'function'
},
identifier: {
pattern: /`[^\r\n`]+`/,
greedy: true
},
'class-name': {
pattern: /(\b(?:enum|error|protocol|record|throws)\b\s+)[$\w]+/,
lookbehind: true,
greedy: true
},
keyword:
/\b(?:array|boolean|bytes|date|decimal|double|enum|error|false|fixed|float|idl|import|int|local_timestamp_ms|long|map|null|oneway|protocol|record|schema|string|throws|time_ms|timestamp_ms|true|union|uuid|void)\b/,
function: /\b[a-z_]\w*(?=\s*\()/i,
number: [
{
pattern:
/(^|[^\w.])-?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|0x(?:[a-f0-9]+(?:\.[a-f0-9]*)?|\.[a-f0-9]+)(?:p[+-]?\d+)?)[dfl]?(?![\w.])/i,
lookbehind: true
},
/-?\b(?:Infinity|NaN)\b/
],
operator: /=/,
punctuation: /[()\[\]{}<>.:,;-]/
}
Prism.languages.avdl = Prism.languages['avro-idl']
}

234
frontend/node_modules/refractor/lang/bash.js generated vendored Normal file
View File

@@ -0,0 +1,234 @@
'use strict'
module.exports = bash
bash.displayName = 'bash'
bash.aliases = ['shell']
function bash(Prism) {
;(function (Prism) {
// $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\n' '|'
// + LC_ALL, RANDOM, REPLY, SECONDS.
// + make sure PS1..4 are here as they are not always set,
// - some useless things.
var envVars =
'\\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'
var commandAfterHeredoc = {
pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
lookbehind: true,
alias: 'punctuation',
// this looks reasonably well in all themes
inside: null // see below
}
var insideString = {
bash: commandAfterHeredoc,
environment: {
pattern: RegExp('\\$' + envVars),
alias: 'constant'
},
variable: [
// [0]: Arithmetic Environment
{
pattern: /\$?\(\([\s\S]+?\)\)/,
greedy: true,
inside: {
// If there is a $ sign at the beginning highlight $(( and )) as variable
variable: [
{
pattern: /(^\$\(\([\s\S]+)\)\)/,
lookbehind: true
},
/^\$\(\(/
],
number:
/\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
// Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
operator:
/--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
// If there is no $ sign at the beginning highlight (( and )) as punctuation
punctuation: /\(\(?|\)\)?|,|;/
}
}, // [1]: Command Substitution
{
pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
greedy: true,
inside: {
variable: /^\$\(|^`|\)$|`$/
}
}, // [2]: Brace expansion
{
pattern: /\$\{[^}]+\}/,
greedy: true,
inside: {
operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
punctuation: /[\[\]]/,
environment: {
pattern: RegExp('(\\{)' + envVars),
lookbehind: true,
alias: 'constant'
}
}
},
/\$(?:\w+|[#?*!@$])/
],
// Escape sequences from echo and printf's manuals, and escaped quotes.
entity:
/\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
}
Prism.languages.bash = {
shebang: {
pattern: /^#!\s*\/.*/,
alias: 'important'
},
comment: {
pattern: /(^|[^"{\\$])#.*/,
lookbehind: true
},
'function-name': [
// a) function foo {
// b) foo() {
// c) function foo() {
// but not “foo {”
{
// a) and c)
pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
lookbehind: true,
alias: 'function'
},
{
// b)
pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
alias: 'function'
}
],
// Highlight variable names as variables in for and select beginnings.
'for-or-select': {
pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
alias: 'variable',
lookbehind: true
},
// Highlight variable names as variables in the left-hand part
// of assignments (“=” and “+=”).
'assign-left': {
pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
inside: {
environment: {
pattern: RegExp('(^|[\\s;|&]|[<>]\\()' + envVars),
lookbehind: true,
alias: 'constant'
}
},
alias: 'variable',
lookbehind: true
},
string: [
// Support for Here-documents https://en.wikipedia.org/wiki/Here_document
{
pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
lookbehind: true,
greedy: true,
inside: insideString
}, // Here-document with quotes around the tag
// → No expansion (so no “inside”).
{
pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
lookbehind: true,
greedy: true,
inside: {
bash: commandAfterHeredoc
}
}, // “Normal” string
{
// https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
pattern:
/(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
lookbehind: true,
greedy: true,
inside: insideString
},
{
// https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
pattern: /(^|[^$\\])'[^']*'/,
lookbehind: true,
greedy: true
},
{
// https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
greedy: true,
inside: {
entity: insideString.entity
}
}
],
environment: {
pattern: RegExp('\\$?' + envVars),
alias: 'constant'
},
variable: insideString.variable,
function: {
pattern:
/(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|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|docker|docker-compose|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|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|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|vcpkg|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: true
},
keyword: {
pattern:
/(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
lookbehind: true
},
// https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
builtin: {
pattern:
/(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
lookbehind: true,
// Alias added to make those easier to distinguish from strings.
alias: 'class-name'
},
boolean: {
pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
lookbehind: true
},
'file-descriptor': {
pattern: /\B&\d\b/,
alias: 'important'
},
operator: {
// Lots of redirections here, but not just that.
pattern:
/\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
inside: {
'file-descriptor': {
pattern: /^\d/,
alias: 'important'
}
}
},
punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
number: {
pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
lookbehind: true
}
}
commandAfterHeredoc.inside = Prism.languages.bash
/* Patterns in command substitution. */
var toBeCopied = [
'comment',
'function-name',
'for-or-select',
'assign-left',
'string',
'environment',
'function',
'keyword',
'builtin',
'boolean',
'file-descriptor',
'operator',
'punctuation',
'number'
]
var inside = insideString.variable[1].inside
for (var i = 0; i < toBeCopied.length; i++) {
inside[toBeCopied[i]] = Prism.languages.bash[toBeCopied[i]]
}
Prism.languages.shell = Prism.languages.bash
})(Prism)
}

26
frontend/node_modules/refractor/lang/basic.js generated vendored Normal file
View File

@@ -0,0 +1,26 @@
'use strict'
module.exports = basic
basic.displayName = 'basic'
basic.aliases = []
function basic(Prism) {
Prism.languages.basic = {
comment: {
pattern: /(?:!|REM\b).+/i,
inside: {
keyword: /^REM/i
}
},
string: {
pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
greedy: true
},
number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
keyword:
/\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
function:
/\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
punctuation: /[,;:()]/
}
}

107
frontend/node_modules/refractor/lang/batch.js generated vendored Normal file
View File

@@ -0,0 +1,107 @@
'use strict'
module.exports = batch
batch.displayName = 'batch'
batch.aliases = []
function batch(Prism) {
;(function (Prism) {
var variable = /%%?[~:\w]+%?|!\S+!/
var parameter = {
pattern: /\/[a-z?]+(?=[ :]|$):?|-[a-z]\b|--[a-z-]+\b/im,
alias: 'attr-name',
inside: {
punctuation: /:/
}
}
var string = /"(?:[\\"]"|[^"])*"(?!")/
var number = /(?:\b|-)\d+\b/
Prism.languages.batch = {
comment: [
/^::.*/m,
{
pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
lookbehind: true
}
],
label: {
pattern: /^:.*/m,
alias: 'property'
},
command: [
{
// FOR command
pattern:
/((?:^|[&(])[ \t]*)for(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* \S+ in \([^)]+\) do/im,
lookbehind: true,
inside: {
keyword: /\b(?:do|in)\b|^for\b/i,
string: string,
parameter: parameter,
variable: variable,
number: number,
punctuation: /[()',]/
}
},
{
// IF command
pattern:
/((?:^|[&(])[ \t]*)if(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:not )?(?:cmdextversion \d+|defined \w+|errorlevel \d+|exist \S+|(?:"[^"]*"|(?!")(?:(?!==)\S)+)?(?:==| (?:equ|geq|gtr|leq|lss|neq) )(?:"[^"]*"|[^\s"]\S*))/im,
lookbehind: true,
inside: {
keyword:
/\b(?:cmdextversion|defined|errorlevel|exist|not)\b|^if\b/i,
string: string,
parameter: parameter,
variable: variable,
number: number,
operator: /\^|==|\b(?:equ|geq|gtr|leq|lss|neq)\b/i
}
},
{
// ELSE command
pattern: /((?:^|[&()])[ \t]*)else\b/im,
lookbehind: true,
inside: {
keyword: /^else\b/i
}
},
{
// SET command
pattern:
/((?:^|[&(])[ \t]*)set(?: \/[a-z](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
lookbehind: true,
inside: {
keyword: /^set\b/i,
string: string,
parameter: parameter,
variable: [variable, /\w+(?=(?:[*\/%+\-&^|]|<<|>>)?=)/],
number: number,
operator: /[*\/%+\-&^|]=?|<<=?|>>=?|[!~_=]/,
punctuation: /[()',]/
}
},
{
// Other commands
pattern:
/((?:^|[&(])[ \t]*@?)\w+\b(?:"(?:[\\"]"|[^"])*"(?!")|[^"^&)\r\n]|\^(?:\r\n|[\s\S]))*/m,
lookbehind: true,
inside: {
keyword: /^\w+\b/,
string: string,
parameter: parameter,
label: {
pattern: /(^\s*):\S+/m,
lookbehind: true,
alias: 'property'
},
variable: variable,
number: number,
operator: /\^/
}
}
],
operator: /[&@]/,
punctuation: /[()']/
}
})(Prism)
}

36
frontend/node_modules/refractor/lang/bbcode.js generated vendored Normal file
View File

@@ -0,0 +1,36 @@
'use strict'
module.exports = bbcode
bbcode.displayName = 'bbcode'
bbcode.aliases = ['shortcode']
function bbcode(Prism) {
Prism.languages.bbcode = {
tag: {
pattern:
/\[\/?[^\s=\]]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))?(?:\s+[^\s=\]]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))*\s*\]/,
inside: {
tag: {
pattern: /^\[\/?[^\s=\]]+/,
inside: {
punctuation: /^\[\/?/
}
},
'attr-value': {
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+)/,
inside: {
punctuation: [
/^=/,
{
pattern: /^(\s*)["']|["']$/,
lookbehind: true
}
]
}
},
punctuation: /\]/,
'attr-name': /[^\s=\]]+/
}
}
}
Prism.languages.shortcode = Prism.languages.bbcode
}

82
frontend/node_modules/refractor/lang/bicep.js generated vendored Normal file
View File

@@ -0,0 +1,82 @@
'use strict'
module.exports = bicep
bicep.displayName = 'bicep'
bicep.aliases = []
function bicep(Prism) {
// based loosely upon: https://github.com/Azure/bicep/blob/main/src/textmate/bicep.tmlanguage
Prism.languages.bicep = {
comment: [
{
// multiline comments eg /* ASDF */
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
lookbehind: true,
greedy: true
},
{
// singleline comments eg // ASDF
pattern: /(^|[^\\:])\/\/.*/,
lookbehind: true,
greedy: true
}
],
property: [
{
pattern: /([\r\n][ \t]*)[a-z_]\w*(?=[ \t]*:)/i,
lookbehind: true
},
{
pattern: /([\r\n][ \t]*)'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'(?=[ \t]*:)/,
lookbehind: true,
greedy: true
}
],
string: [
{
pattern: /'''[^'][\s\S]*?'''/,
greedy: true
},
{
pattern: /(^|[^\\'])'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'/,
lookbehind: true,
greedy: true
}
],
'interpolated-string': {
pattern: /(^|[^\\'])'(?:\\.|\$(?:(?!\{)|\{[^{}\r\n]*\})|[^'\\\r\n$])*'/,
lookbehind: true,
greedy: true,
inside: {
interpolation: {
pattern: /\$\{[^{}\r\n]*\}/,
inside: {
expression: {
pattern: /(^\$\{)[\s\S]+(?=\}$)/,
lookbehind: true
},
punctuation: /^\$\{|\}$/
}
},
string: /[\s\S]+/
}
},
datatype: {
pattern: /(\b(?:output|param)\b[ \t]+\w+[ \t]+)\w+\b/,
lookbehind: true,
alias: 'class-name'
},
boolean: /\b(?:false|true)\b/,
// https://github.com/Azure/bicep/blob/114a3251b4e6e30082a58729f19a8cc4e374ffa6/src/textmate/bicep.tmlanguage#L184
keyword:
/\b(?:existing|for|if|in|module|null|output|param|resource|targetScope|var)\b/,
decorator: /@\w+\b/,
function: /\b[a-z_]\w*(?=[ \t]*\()/i,
number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
operator:
/--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
punctuation: /[{}[\];(),.:]/
}
Prism.languages.bicep['interpolated-string'].inside['interpolation'].inside[
'expression'
].inside = Prism.languages.bicep
}

28
frontend/node_modules/refractor/lang/birb.js generated vendored Normal file
View File

@@ -0,0 +1,28 @@
'use strict'
module.exports = birb
birb.displayName = 'birb'
birb.aliases = []
function birb(Prism) {
Prism.languages.birb = Prism.languages.extend('clike', {
string: {
pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
greedy: true
},
'class-name': [
/\b[A-Z](?:[\d_]*[a-zA-Z]\w*)?\b/, // matches variable and function return types (parameters as well).
/\b(?:[A-Z]\w*|(?!(?:var|void)\b)[a-z]\w*)(?=\s+\w+\s*[;,=()])/
],
keyword:
/\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
operator: /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
variable: /\b[a-z_]\w*\b/
})
Prism.languages.insertBefore('birb', 'function', {
metadata: {
pattern: /<\w+>/,
greedy: true,
alias: 'symbol'
}
})
}

46
frontend/node_modules/refractor/lang/bison.js generated vendored Normal file
View File

@@ -0,0 +1,46 @@
'use strict'
var refractorC = require('./c.js')
module.exports = bison
bison.displayName = 'bison'
bison.aliases = []
function bison(Prism) {
Prism.register(refractorC)
Prism.languages.bison = Prism.languages.extend('c', {})
Prism.languages.insertBefore('bison', 'comment', {
bison: {
// This should match all the beginning of the file
// including the prologue(s), the bison declarations and
// the grammar rules.
pattern: /^(?:[^%]|%(?!%))*%%[\s\S]*?%%/,
inside: {
c: {
// Allow for one level of nested braces
pattern: /%\{[\s\S]*?%\}|\{(?:\{[^}]*\}|[^{}])*\}/,
inside: {
delimiter: {
pattern: /^%?\{|%?\}$/,
alias: 'punctuation'
},
'bison-variable': {
pattern: /[$@](?:<[^\s>]+>)?[\w$]+/,
alias: 'variable',
inside: {
punctuation: /<|>/
}
},
rest: Prism.languages.c
}
},
comment: Prism.languages.c.comment,
string: Prism.languages.c.string,
property: /\S+(?=:)/,
keyword: /%\w+/,
number: {
pattern: /(^|[^@])\b(?:0x[\da-f]+|\d+)/i,
lookbehind: true
},
punctuation: /%[%?]|[|:;\[\]<>]/
}
}
})
}

27
frontend/node_modules/refractor/lang/bnf.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
'use strict'
module.exports = bnf
bnf.displayName = 'bnf'
bnf.aliases = ['rbnf']
function bnf(Prism) {
Prism.languages.bnf = {
string: {
pattern: /"[^\r\n"]*"|'[^\r\n']*'/
},
definition: {
pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
alias: ['rule', 'keyword'],
inside: {
punctuation: /^<|>$/
}
},
rule: {
pattern: /<[^<>\r\n\t]+>/,
inside: {
punctuation: /^<|>$/
}
},
operator: /::=|[|()[\]{}*+?]|\.{3}/
}
Prism.languages.rbnf = Prism.languages.bnf
}

27
frontend/node_modules/refractor/lang/brainfuck.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
'use strict'
module.exports = brainfuck
brainfuck.displayName = 'brainfuck'
brainfuck.aliases = []
function brainfuck(Prism) {
Prism.languages.brainfuck = {
pointer: {
pattern: /<|>/,
alias: 'keyword'
},
increment: {
pattern: /\+/,
alias: 'inserted'
},
decrement: {
pattern: /-/,
alias: 'deleted'
},
branching: {
pattern: /\[|\]/,
alias: 'important'
},
operator: /[.,]/,
comment: /\S+/
}
}

54
frontend/node_modules/refractor/lang/brightscript.js generated vendored Normal file
View File

@@ -0,0 +1,54 @@
'use strict'
module.exports = brightscript
brightscript.displayName = 'brightscript'
brightscript.aliases = []
function brightscript(Prism) {
Prism.languages.brightscript = {
comment: /(?:\brem|').*/i,
'directive-statement': {
pattern: /(^[\t ]*)#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if).*/im,
lookbehind: true,
alias: 'property',
inside: {
'error-message': {
pattern: /(^#error).+/,
lookbehind: true
},
directive: {
pattern: /^#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if)/,
alias: 'keyword'
},
expression: {
pattern: /[\s\S]+/,
inside: null // see below
}
}
},
property: {
pattern:
/([\r\n{,][\t ]*)(?:(?!\d)\w+|"(?:[^"\r\n]|"")*"(?!"))(?=[ \t]*:)/,
lookbehind: true,
greedy: true
},
string: {
pattern: /"(?:[^"\r\n]|"")*"(?!")/,
greedy: true
},
'class-name': {
pattern: /(\bAs[\t ]+)\w+/i,
lookbehind: true
},
keyword:
/\b(?:As|Dim|Each|Else|Elseif|End|Exit|For|Function|Goto|If|In|Print|Return|Step|Stop|Sub|Then|To|While)\b/i,
boolean: /\b(?:false|true)\b/i,
function: /\b(?!\d)\w+(?=[\t ]*\()/,
number: /(?:\b\d+(?:\.\d+)?(?:[ed][+-]\d+)?|&h[a-f\d]+)\b[%&!#]?/i,
operator:
/--|\+\+|>>=?|<<=?|<>|[-+*/\\<>]=?|[:^=?]|\b(?:and|mod|not|or)\b/i,
punctuation: /[.,;()[\]{}]/,
constant: /\b(?:LINE_NUM)\b/i
}
Prism.languages.brightscript['directive-statement'].inside.expression.inside =
Prism.languages.brightscript
}

36
frontend/node_modules/refractor/lang/bro.js generated vendored Normal file
View File

@@ -0,0 +1,36 @@
'use strict'
module.exports = bro
bro.displayName = 'bro'
bro.aliases = []
function bro(Prism) {
Prism.languages.bro = {
comment: {
pattern: /(^|[^\\$])#.*/,
lookbehind: true,
inside: {
italic: /\b(?:FIXME|TODO|XXX)\b/
}
},
string: {
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
greedy: true
},
boolean: /\b[TF]\b/,
function: {
pattern: /(\b(?:event|function|hook)[ \t]+)\w+(?:::\w+)?/,
lookbehind: true
},
builtin:
/(?:@(?:load(?:-(?:plugin|sigs))?|unload|prefixes|ifn?def|else|(?:end)?if|DIR|FILENAME))|(?:&?(?:add_func|create_expire|default|delete_func|encrypt|error_handler|expire_func|group|log|mergeable|optional|persistent|priority|raw_output|read_expire|redef|rotate_interval|rotate_size|synchronized|type_column|write_expire))/,
constant: {
pattern: /(\bconst[ \t]+)\w+/i,
lookbehind: true
},
keyword:
/\b(?:add|addr|alarm|any|bool|break|const|continue|count|delete|double|else|enum|event|export|file|for|function|global|hook|if|in|int|interval|local|module|next|of|opaque|pattern|port|print|record|return|schedule|set|string|subnet|table|time|timeout|using|vector|when)\b/,
operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
punctuation: /[{}[\];(),.:]/
}
}

80
frontend/node_modules/refractor/lang/bsl.js generated vendored Normal file
View File

@@ -0,0 +1,80 @@
'use strict'
module.exports = bsl
bsl.displayName = 'bsl'
bsl.aliases = []
function bsl(Prism) {
/* eslint-disable no-misleading-character-class */
// 1C:Enterprise
// https://github.com/Diversus23/
//
Prism.languages.bsl = {
comment: /\/\/.*/,
string: [
// Строки
// Strings
{
pattern: /"(?:[^"]|"")*"(?!")/,
greedy: true
}, // Дата и время
// Date & time
{
pattern: /'(?:[^'\r\n\\]|\\.)*'/
}
],
keyword: [
{
// RU
pattern:
/(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:пока|для|новый|прервать|попытка|исключение|вызватьисключение|иначе|конецпопытки|неопределено|функция|перем|возврат|конецфункции|если|иначеесли|процедура|конецпроцедуры|тогда|знач|экспорт|конецесли|из|каждого|истина|ложь|по|цикл|конеццикла|выполнить)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
lookbehind: true
},
{
// EN
pattern:
/\b(?:break|do|each|else|elseif|enddo|endfunction|endif|endprocedure|endtry|except|execute|export|false|for|function|if|in|new|null|procedure|raise|return|then|to|true|try|undefined|val|var|while)\b/i
}
],
number: {
pattern:
/(^(?=\d)|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:\d+(?:\.\d*)?|\.\d+)(?:E[+-]?\d+)?/i,
lookbehind: true
},
operator: [
/[<>+\-*/]=?|[%=]/, // RU
{
pattern:
/(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:и|или|не)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
lookbehind: true
}, // EN
{
pattern: /\b(?:and|not|or)\b/i
}
],
punctuation: /\(\.|\.\)|[()\[\]:;,.]/,
directive: [
// Теги препроцессора вида &Клиент, &Сервер, ...
// Preprocessor tags of the type &Client, &Server, ...
{
pattern: /^([ \t]*)&.*/m,
lookbehind: true,
greedy: true,
alias: 'important'
}, // Инструкции препроцессора вида:
// #Если Сервер Тогда
// ...
// #КонецЕсли
// Preprocessor instructions of the form:
// #If Server Then
// ...
// #EndIf
{
pattern: /^([ \t]*)#.*/gm,
lookbehind: true,
greedy: true,
alias: 'important'
}
]
}
Prism.languages.oscript = Prism.languages['bsl']
}

89
frontend/node_modules/refractor/lang/c.js generated vendored Normal file
View File

@@ -0,0 +1,89 @@
'use strict'
module.exports = c
c.displayName = 'c'
c.aliases = []
function c(Prism) {
Prism.languages.c = Prism.languages.extend('clike', {
comment: {
pattern:
/\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
greedy: true
},
string: {
// https://en.cppreference.com/w/c/language/string_literal
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: {
// https://en.cppreference.com/w/c/language/character_constant
pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
greedy: true
}
})
Prism.languages.insertBefore('c', 'string', {
macro: {
// allow for multiline macro definitions
// spaces after the # character compile fine with gcc
pattern:
/(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
lookbehind: true,
greedy: true,
alias: 'property',
inside: {
string: [
{
// highlight the path of the include statement as a 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'
}
],
// highlight macro directives as keywords
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', {
// highlight predefined macros as constants
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']
}

53
frontend/node_modules/refractor/lang/cfscript.js generated vendored Normal file
View File

@@ -0,0 +1,53 @@
'use strict'
module.exports = cfscript
cfscript.displayName = 'cfscript'
cfscript.aliases = []
function cfscript(Prism) {
// https://cfdocs.org/script
Prism.languages.cfscript = Prism.languages.extend('clike', {
comment: [
{
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
lookbehind: true,
inside: {
annotation: {
pattern: /(?:^|[^.])@[\w\.]+/,
alias: 'punctuation'
}
}
},
{
pattern: /(^|[^\\:])\/\/.*/,
lookbehind: true,
greedy: true
}
],
keyword:
/\b(?:abstract|break|catch|component|continue|default|do|else|extends|final|finally|for|function|if|in|include|package|private|property|public|remote|required|rethrow|return|static|switch|throw|try|var|while|xml)\b(?!\s*=)/,
operator: [
/\+\+|--|&&|\|\||::|=>|[!=]==|<=?|>=?|[-+*/%&|^!=<>]=?|\?(?:\.|:)?|[?:]/,
/\b(?:and|contains|eq|equal|eqv|gt|gte|imp|is|lt|lte|mod|not|or|xor)\b/
],
scope: {
pattern:
/\b(?:application|arguments|cgi|client|cookie|local|session|super|this|variables)\b/,
alias: 'global'
},
type: {
pattern:
/\b(?:any|array|binary|boolean|date|guid|numeric|query|string|struct|uuid|void|xml)\b/,
alias: 'builtin'
}
})
Prism.languages.insertBefore('cfscript', 'keyword', {
// This must be declared before keyword because we use "function" inside the lookahead
'function-variable': {
pattern:
/[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
alias: 'function'
}
})
delete Prism.languages.cfscript['class-name']
Prism.languages.cfc = Prism.languages['cfscript']
}

67
frontend/node_modules/refractor/lang/chaiscript.js generated vendored Normal file
View File

@@ -0,0 +1,67 @@
'use strict'
var refractorCpp = require('./cpp.js')
module.exports = chaiscript
chaiscript.displayName = 'chaiscript'
chaiscript.aliases = []
function chaiscript(Prism) {
Prism.register(refractorCpp)
Prism.languages.chaiscript = Prism.languages.extend('clike', {
string: {
pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'/,
lookbehind: true,
greedy: true
},
'class-name': [
{
// e.g. class Rectangle { ... }
pattern: /(\bclass\s+)\w+/,
lookbehind: true
},
{
// e.g. attr Rectangle::height, def Rectangle::area() { ... }
pattern: /(\b(?:attr|def)\s+)\w+(?=\s*::)/,
lookbehind: true
}
],
keyword:
/\b(?:attr|auto|break|case|catch|class|continue|def|default|else|finally|for|fun|global|if|return|switch|this|try|var|while)\b/,
number: [Prism.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
operator:
/>>=?|<<=?|\|\||&&|:[:=]?|--|\+\+|[=!<>+\-*/%|&^]=?|[?~]|`[^`\r\n]{1,4}`/
})
Prism.languages.insertBefore('chaiscript', 'operator', {
'parameter-type': {
// e.g. def foo(int x, Vector y) {...}
pattern: /([,(]\s*)\w+(?=\s+\w)/,
lookbehind: true,
alias: 'class-name'
}
})
Prism.languages.insertBefore('chaiscript', 'string', {
'string-interpolation': {
pattern:
/(^|[^\\])"(?:[^"$\\]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*"/,
lookbehind: true,
greedy: true,
inside: {
interpolation: {
pattern:
/((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/,
lookbehind: true,
inside: {
'interpolation-expression': {
pattern: /(^\$\{)[\s\S]+(?=\}$)/,
lookbehind: true,
inside: Prism.languages.chaiscript
},
'interpolation-punctuation': {
pattern: /^\$\{|\}$/,
alias: 'punctuation'
}
}
},
string: /[\s\S]+/
}
}
})
}

28
frontend/node_modules/refractor/lang/cil.js generated vendored Normal file
View File

@@ -0,0 +1,28 @@
'use strict'
module.exports = cil
cil.displayName = 'cil'
cil.aliases = []
function cil(Prism) {
Prism.languages.cil = {
comment: /\/\/.*/,
string: {
pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
greedy: true
},
directive: {
pattern: /(^|\W)\.[a-z]+(?=\s)/,
lookbehind: true,
alias: 'class-name'
},
// Actually an assembly reference
variable: /\[[\w\.]+\]/,
keyword:
/\b(?:abstract|ansi|assembly|auto|autochar|beforefieldinit|bool|bstr|byvalstr|catch|char|cil|class|currency|date|decimal|default|enum|error|explicit|extends|extern|famandassem|family|famorassem|final(?:ly)?|float32|float64|hidebysig|u?int(?:8|16|32|64)?|iant|idispatch|implements|import|initonly|instance|interface|iunknown|literal|lpstr|lpstruct|lptstr|lpwstr|managed|method|native(?:Type)?|nested|newslot|object(?:ref)?|pinvokeimpl|private|privatescope|public|reqsecobj|rtspecialname|runtime|sealed|sequential|serializable|specialname|static|string|struct|syschar|tbstr|unicode|unmanagedexp|unsigned|value(?:type)?|variant|virtual|void)\b/,
function:
/\b(?:(?:constrained|no|readonly|tail|unaligned|volatile)\.)?(?:conv\.(?:[iu][1248]?|ovf\.[iu][1248]?(?:\.un)?|r\.un|r4|r8)|ldc\.(?:i4(?:\.\d+|\.[mM]1|\.s)?|i8|r4|r8)|ldelem(?:\.[iu][1248]?|\.r[48]|\.ref|a)?|ldind\.(?:[iu][1248]?|r[48]|ref)|stelem\.?(?:i[1248]?|r[48]|ref)?|stind\.(?:i[1248]?|r[48]|ref)?|end(?:fault|filter|finally)|ldarg(?:\.[0-3s]|a(?:\.s)?)?|ldloc(?:\.\d+|\.s)?|sub(?:\.ovf(?:\.un)?)?|mul(?:\.ovf(?:\.un)?)?|add(?:\.ovf(?:\.un)?)?|stloc(?:\.[0-3s])?|refany(?:type|val)|blt(?:\.un)?(?:\.s)?|ble(?:\.un)?(?:\.s)?|bgt(?:\.un)?(?:\.s)?|bge(?:\.un)?(?:\.s)?|unbox(?:\.any)?|init(?:blk|obj)|call(?:i|virt)?|brfalse(?:\.s)?|bne\.un(?:\.s)?|ldloca(?:\.s)?|brzero(?:\.s)?|brtrue(?:\.s)?|brnull(?:\.s)?|brinst(?:\.s)?|starg(?:\.s)?|leave(?:\.s)?|shr(?:\.un)?|rem(?:\.un)?|div(?:\.un)?|clt(?:\.un)?|alignment|castclass|ldvirtftn|beq(?:\.s)?|ckfinite|ldsflda|ldtoken|localloc|mkrefany|rethrow|cgt\.un|arglist|switch|stsfld|sizeof|newobj|newarr|ldsfld|ldnull|ldflda|isinst|throw|stobj|stfld|ldstr|ldobj|ldlen|ldftn|ldfld|cpobj|cpblk|break|br\.s|xor|shl|ret|pop|not|nop|neg|jmp|dup|cgt|ceq|box|and|or|br)\b/,
boolean: /\b(?:false|true)\b/,
number: /\b-?(?:0x[0-9a-f]+|\d+)(?:\.[0-9a-f]+)?\b/i,
punctuation: /[{}[\];(),:=]|IL_[0-9A-Za-z]+/
}
}

40
frontend/node_modules/refractor/lang/clike.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
'use strict'
module.exports = clike
clike.displayName = 'clike'
clike.aliases = []
function clike(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: /[{}[\];(),.:]/
}
}

40
frontend/node_modules/refractor/lang/clojure.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
'use strict'
module.exports = clojure
clojure.displayName = 'clojure'
clojure.aliases = []
function clojure(Prism) {
// Copied from https://github.com/jeluard/prism-clojure
Prism.languages.clojure = {
comment: {
pattern: /;.*/,
greedy: true
},
string: {
pattern: /"(?:[^"\\]|\\.)*"/,
greedy: true
},
char: /\\\w+/,
symbol: {
pattern: /(^|[\s()\[\]{},])::?[\w*+!?'<>=/.-]+/,
lookbehind: true
},
keyword: {
pattern:
/(\()(?:-|->|->>|\.|\.\.|\*|\/|\+|<|<=|=|==|>|>=|accessor|agent|agent-errors|aget|alength|all-ns|alter|and|append-child|apply|array-map|aset|aset-boolean|aset-byte|aset-char|aset-double|aset-float|aset-int|aset-long|aset-short|assert|assoc|await|await-for|bean|binding|bit-and|bit-not|bit-or|bit-shift-left|bit-shift-right|bit-xor|boolean|branch\?|butlast|byte|cast|char|children|class|clear-agent-errors|comment|commute|comp|comparator|complement|concat|cond|conj|cons|constantly|construct-proxy|contains\?|count|create-ns|create-struct|cycle|dec|declare|def|def-|definline|definterface|defmacro|defmethod|defmulti|defn|defn-|defonce|defproject|defprotocol|defrecord|defstruct|deftype|deref|difference|disj|dissoc|distinct|do|doall|doc|dorun|doseq|dosync|dotimes|doto|double|down|drop|drop-while|edit|end\?|ensure|eval|every\?|false\?|ffirst|file-seq|filter|find|find-doc|find-ns|find-var|first|float|flush|fn|fnseq|for|frest|gensym|get|get-proxy-class|hash-map|hash-set|identical\?|identity|if|if-let|if-not|import|in-ns|inc|index|insert-child|insert-left|insert-right|inspect-table|inspect-tree|instance\?|int|interleave|intersection|into|into-array|iterate|join|key|keys|keyword|keyword\?|last|lazy-cat|lazy-cons|left|lefts|let|line-seq|list|list\*|load|load-file|locking|long|loop|macroexpand|macroexpand-1|make-array|make-node|map|map-invert|map\?|mapcat|max|max-key|memfn|merge|merge-with|meta|min|min-key|monitor-enter|name|namespace|neg\?|new|newline|next|nil\?|node|not|not-any\?|not-every\?|not=|ns|ns-imports|ns-interns|ns-map|ns-name|ns-publics|ns-refers|ns-resolve|ns-unmap|nth|nthrest|or|parse|partial|path|peek|pop|pos\?|pr|pr-str|print|print-str|println|println-str|prn|prn-str|project|proxy|proxy-mappings|quot|quote|rand|rand-int|range|re-find|re-groups|re-matcher|re-matches|re-pattern|re-seq|read|read-line|recur|reduce|ref|ref-set|refer|rem|remove|remove-method|remove-ns|rename|rename-keys|repeat|replace|replicate|resolve|rest|resultset-seq|reverse|rfirst|right|rights|root|rrest|rseq|second|select|select-keys|send|send-off|seq|seq-zip|seq\?|set|set!|short|slurp|some|sort|sort-by|sorted-map|sorted-map-by|sorted-set|special-symbol\?|split-at|split-with|str|string\?|struct|struct-map|subs|subvec|symbol|symbol\?|sync|take|take-nth|take-while|test|throw|time|to-array|to-array-2d|tree-seq|true\?|try|union|up|update-proxy|val|vals|var|var-get|var-set|var\?|vector|vector-zip|vector\?|when|when-first|when-let|when-not|with-local-vars|with-meta|with-open|with-out-str|xml-seq|xml-zip|zero\?|zipmap|zipper)(?=[\s)]|$)/,
lookbehind: true
},
boolean: /\b(?:false|nil|true)\b/,
number: {
pattern:
/(^|[^\w$@])(?:\d+(?:[/.]\d+)?(?:e[+-]?\d+)?|0x[a-f0-9]+|[1-9]\d?r[a-z0-9]+)[lmn]?(?![\w$@])/i,
lookbehind: true
},
function: {
pattern: /((?:^|[^'])\()[\w*+!?'<>=/.-]+(?=[\s)]|$)/,
lookbehind: true
},
operator: /[#@^`~]/,
punctuation: /[{}\[\](),]/
}
}

41
frontend/node_modules/refractor/lang/cmake.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

59
frontend/node_modules/refractor/lang/cobol.js generated vendored Normal file
View File

@@ -0,0 +1,59 @@
'use strict'
module.exports = cobol
cobol.displayName = 'cobol'
cobol.aliases = []
function cobol(Prism) {
Prism.languages.cobol = {
comment: {
pattern: /\*>.*|(^[ \t]*)\*.*/m,
lookbehind: true,
greedy: true
},
string: {
pattern: /[xzgn]?(?:"(?:[^\r\n"]|"")*"(?!")|'(?:[^\r\n']|'')*'(?!'))/i,
greedy: true
},
level: {
pattern: /(^[ \t]*)\d+\b/m,
lookbehind: true,
greedy: true,
alias: 'number'
},
'class-name': {
// https://github.com/antlr/grammars-v4/blob/42edd5b687d183b5fa679e858a82297bd27141e7/cobol85/Cobol85.g4#L1015
pattern:
/(\bpic(?:ture)?\s+)(?:(?:[-\w$/,:*+<>]|\.(?!\s|$))(?:\(\d+\))?)+/i,
lookbehind: true,
inside: {
number: {
pattern: /(\()\d+/,
lookbehind: true
},
punctuation: /[()]/
}
},
keyword: {
pattern:
/(^|[^\w-])(?:ABORT|ACCEPT|ACCESS|ADD|ADDRESS|ADVANCING|AFTER|ALIGNED|ALL|ALPHABET|ALPHABETIC|ALPHABETIC-LOWER|ALPHABETIC-UPPER|ALPHANUMERIC|ALPHANUMERIC-EDITED|ALSO|ALTER|ALTERNATE|ANY|ARE|AREA|AREAS|AS|ASCENDING|ASCII|ASSIGN|ASSOCIATED-DATA|ASSOCIATED-DATA-LENGTH|AT|ATTRIBUTE|AUTHOR|AUTO|AUTO-SKIP|BACKGROUND-COLOR|BACKGROUND-COLOUR|BASIS|BEEP|BEFORE|BEGINNING|BELL|BINARY|BIT|BLANK|BLINK|BLOCK|BOTTOM|BOUNDS|BY|BYFUNCTION|BYTITLE|CALL|CANCEL|CAPABLE|CCSVERSION|CD|CF|CH|CHAINING|CHANGED|CHANNEL|CHARACTER|CHARACTERS|CLASS|CLASS-ID|CLOCK-UNITS|CLOSE|CLOSE-DISPOSITION|COBOL|CODE|CODE-SET|COL|COLLATING|COLUMN|COM-REG|COMMA|COMMITMENT|COMMON|COMMUNICATION|COMP|COMP-1|COMP-2|COMP-3|COMP-4|COMP-5|COMPUTATIONAL|COMPUTATIONAL-1|COMPUTATIONAL-2|COMPUTATIONAL-3|COMPUTATIONAL-4|COMPUTATIONAL-5|COMPUTE|CONFIGURATION|CONTAINS|CONTENT|CONTINUE|CONTROL|CONTROL-POINT|CONTROLS|CONVENTION|CONVERTING|COPY|CORR|CORRESPONDING|COUNT|CRUNCH|CURRENCY|CURSOR|DATA|DATA-BASE|DATE|DATE-COMPILED|DATE-WRITTEN|DAY|DAY-OF-WEEK|DBCS|DE|DEBUG-CONTENTS|DEBUG-ITEM|DEBUG-LINE|DEBUG-NAME|DEBUG-SUB-1|DEBUG-SUB-2|DEBUG-SUB-3|DEBUGGING|DECIMAL-POINT|DECLARATIVES|DEFAULT|DEFAULT-DISPLAY|DEFINITION|DELETE|DELIMITED|DELIMITER|DEPENDING|DESCENDING|DESTINATION|DETAIL|DFHRESP|DFHVALUE|DISABLE|DISK|DISPLAY|DISPLAY-1|DIVIDE|DIVISION|DONTCARE|DOUBLE|DOWN|DUPLICATES|DYNAMIC|EBCDIC|EGCS|EGI|ELSE|EMI|EMPTY-CHECK|ENABLE|END|END-ACCEPT|END-ADD|END-CALL|END-COMPUTE|END-DELETE|END-DIVIDE|END-EVALUATE|END-IF|END-MULTIPLY|END-OF-PAGE|END-PERFORM|END-READ|END-RECEIVE|END-RETURN|END-REWRITE|END-SEARCH|END-START|END-STRING|END-SUBTRACT|END-UNSTRING|END-WRITE|ENDING|ENTER|ENTRY|ENTRY-PROCEDURE|ENVIRONMENT|EOL|EOP|EOS|ERASE|ERROR|ESCAPE|ESI|EVALUATE|EVENT|EVERY|EXCEPTION|EXCLUSIVE|EXHIBIT|EXIT|EXPORT|EXTEND|EXTENDED|EXTERNAL|FD|FILE|FILE-CONTROL|FILLER|FINAL|FIRST|FOOTING|FOR|FOREGROUND-COLOR|FOREGROUND-COLOUR|FROM|FULL|FUNCTION|FUNCTION-POINTER|FUNCTIONNAME|GENERATE|GIVING|GLOBAL|GO|GOBACK|GRID|GROUP|HEADING|HIGH-VALUE|HIGH-VALUES|HIGHLIGHT|I-O|I-O-CONTROL|ID|IDENTIFICATION|IF|IMPLICIT|IMPORT|IN|INDEX|INDEXED|INDICATE|INITIAL|INITIALIZE|INITIATE|INPUT|INPUT-OUTPUT|INSPECT|INSTALLATION|INTEGER|INTO|INVALID|INVOKE|IS|JUST|JUSTIFIED|KANJI|KEPT|KEY|KEYBOARD|LABEL|LANGUAGE|LAST|LB|LD|LEADING|LEFT|LEFTLINE|LENGTH|LENGTH-CHECK|LIBACCESS|LIBPARAMETER|LIBRARY|LIMIT|LIMITS|LINAGE|LINAGE-COUNTER|LINE|LINE-COUNTER|LINES|LINKAGE|LIST|LOCAL|LOCAL-STORAGE|LOCK|LONG-DATE|LONG-TIME|LOW-VALUE|LOW-VALUES|LOWER|LOWLIGHT|MEMORY|MERGE|MESSAGE|MMDDYYYY|MODE|MODULES|MORE-LABELS|MOVE|MULTIPLE|MULTIPLY|NAMED|NATIONAL|NATIONAL-EDITED|NATIVE|NEGATIVE|NETWORK|NEXT|NO|NO-ECHO|NULL|NULLS|NUMBER|NUMERIC|NUMERIC-DATE|NUMERIC-EDITED|NUMERIC-TIME|OBJECT-COMPUTER|OCCURS|ODT|OF|OFF|OMITTED|ON|OPEN|OPTIONAL|ORDER|ORDERLY|ORGANIZATION|OTHER|OUTPUT|OVERFLOW|OVERLINE|OWN|PACKED-DECIMAL|PADDING|PAGE|PAGE-COUNTER|PASSWORD|PERFORM|PF|PH|PIC|PICTURE|PLUS|POINTER|PORT|POSITION|POSITIVE|PRINTER|PRINTING|PRIVATE|PROCEDURE|PROCEDURE-POINTER|PROCEDURES|PROCEED|PROCESS|PROGRAM|PROGRAM-ID|PROGRAM-LIBRARY|PROMPT|PURGE|QUEUE|QUOTE|QUOTES|RANDOM|RD|READ|READER|REAL|RECEIVE|RECEIVED|RECORD|RECORDING|RECORDS|RECURSIVE|REDEFINES|REEL|REF|REFERENCE|REFERENCES|RELATIVE|RELEASE|REMAINDER|REMARKS|REMOTE|REMOVAL|REMOVE|RENAMES|REPLACE|REPLACING|REPORT|REPORTING|REPORTS|REQUIRED|RERUN|RESERVE|RESET|RETURN|RETURN-CODE|RETURNING|REVERSE-VIDEO|REVERSED|REWIND|REWRITE|RF|RH|RIGHT|ROUNDED|RUN|SAME|SAVE|SCREEN|SD|SEARCH|SECTION|SECURE|SECURITY|SEGMENT|SEGMENT-LIMIT|SELECT|SEND|SENTENCE|SEPARATE|SEQUENCE|SEQUENTIAL|SET|SHARED|SHAREDBYALL|SHAREDBYRUNUNIT|SHARING|SHIFT-IN|SHIFT-OUT|SHORT-DATE|SIGN|SIZE|SORT|SORT-CONTROL|SORT-CORE-SIZE|SORT-FILE-SIZE|SORT-MERGE|SORT-MESSAGE|SORT-MODE-SIZE|SORT-RETURN|SOURCE|SOURCE-COMPUTER|SPACE|SPACES|SPECIAL-NAMES|STANDARD|STANDARD-1|STANDARD-2|START|STATUS|STOP|STRING|SUB-QUEUE-1|SUB-QUEUE-2|SUB-QUEUE-3|SUBTRACT|SUM|SUPPRESS|SYMBOL|SYMBOLIC|SYNC|SYNCHRONIZED|TABLE|TALLY|TALLYING|TAPE|TASK|TERMINAL|TERMINATE|TEST|TEXT|THEN|THREAD|THREAD-LOCAL|THROUGH|THRU|TIME|TIMER|TIMES|TITLE|TO|TODAYS-DATE|TODAYS-NAME|TOP|TRAILING|TRUNCATED|TYPE|TYPEDEF|UNDERLINE|UNIT|UNSTRING|UNTIL|UP|UPON|USAGE|USE|USING|VALUE|VALUES|VARYING|VIRTUAL|WAIT|WHEN|WHEN-COMPILED|WITH|WORDS|WORKING-STORAGE|WRITE|YEAR|YYYYDDD|YYYYMMDD|ZERO-FILL|ZEROES|ZEROS)(?![\w-])/i,
lookbehind: true
},
boolean: {
pattern: /(^|[^\w-])(?:false|true)(?![\w-])/i,
lookbehind: true
},
number: {
pattern:
/(^|[^\w-])(?:[+-]?(?:(?:\d+(?:[.,]\d+)?|[.,]\d+)(?:e[+-]?\d+)?|zero))(?![\w-])/i,
lookbehind: true
},
operator: [
/<>|[<>]=?|[=+*/&]/,
{
pattern: /(^|[^\w-])(?:-|and|equal|greater|less|not|or|than)(?![\w-])/i,
lookbehind: true
}
],
punctuation: /[.:,()]/
}
}

92
frontend/node_modules/refractor/lang/coffeescript.js generated vendored Normal file
View File

@@ -0,0 +1,92 @@
'use strict'
module.exports = coffeescript
coffeescript.displayName = 'coffeescript'
coffeescript.aliases = ['coffee']
function coffeescript(Prism) {
;(function (Prism) {
// Ignore comments starting with { to privilege string interpolation highlighting
var comment = /#(?!\{).+/
var interpolation = {
pattern: /#\{[^}]+\}/,
alias: 'variable'
}
Prism.languages.coffeescript = Prism.languages.extend('javascript', {
comment: comment,
string: [
// Strings are multiline
{
pattern: /'(?:\\[\s\S]|[^\\'])*'/,
greedy: true
},
{
// Strings are multiline
pattern: /"(?:\\[\s\S]|[^\\"])*"/,
greedy: true,
inside: {
interpolation: interpolation
}
}
],
keyword:
/\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
'class-member': {
pattern: /@(?!\d)\w+/,
alias: 'variable'
}
})
Prism.languages.insertBefore('coffeescript', 'comment', {
'multiline-comment': {
pattern: /###[\s\S]+?###/,
alias: 'comment'
},
// Block regexp can contain comments and interpolation
'block-regex': {
pattern: /\/{3}[\s\S]*?\/{3}/,
alias: 'regex',
inside: {
comment: comment,
interpolation: interpolation
}
}
})
Prism.languages.insertBefore('coffeescript', 'string', {
'inline-javascript': {
pattern: /`(?:\\[\s\S]|[^\\`])*`/,
inside: {
delimiter: {
pattern: /^`|`$/,
alias: 'punctuation'
},
script: {
pattern: /[\s\S]+/,
alias: 'language-javascript',
inside: Prism.languages.javascript
}
}
},
// Block strings
'multiline-string': [
{
pattern: /'''[\s\S]*?'''/,
greedy: true,
alias: 'string'
},
{
pattern: /"""[\s\S]*?"""/,
greedy: true,
alias: 'string',
inside: {
interpolation: interpolation
}
}
]
})
Prism.languages.insertBefore('coffeescript', 'keyword', {
// Object property
property: /(?!\d)\w+(?=\s*:(?!:))/
})
delete Prism.languages.coffeescript['template-string']
Prism.languages.coffee = Prism.languages.coffeescript
})(Prism)
}

71
frontend/node_modules/refractor/lang/concurnas.js generated vendored Normal file
View File

@@ -0,0 +1,71 @@
'use strict'
module.exports = concurnas
concurnas.displayName = 'concurnas'
concurnas.aliases = ['conc']
function concurnas(Prism) {
Prism.languages.concurnas = {
comment: {
pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
lookbehind: true,
greedy: true
},
langext: {
pattern: /\b\w+\s*\|\|[\s\S]+?\|\|/,
greedy: true,
inside: {
'class-name': /^\w+/,
string: {
pattern: /(^\s*\|\|)[\s\S]+(?=\|\|$)/,
lookbehind: true
},
punctuation: /\|\|/
}
},
function: {
pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/,
lookbehind: true
},
keyword:
/\b(?:abstract|actor|also|annotation|assert|async|await|bool|boolean|break|byte|case|catch|changed|char|class|closed|constant|continue|def|default|del|double|elif|else|enum|every|extends|false|finally|float|for|from|global|gpudef|gpukernel|if|import|in|init|inject|int|lambda|local|long|loop|match|new|nodefault|null|of|onchange|open|out|override|package|parfor|parforsync|post|pre|private|protected|provide|provider|public|return|shared|short|single|size_t|sizeof|super|sync|this|throw|trait|trans|transient|true|try|typedef|unchecked|using|val|var|void|while|with)\b/,
boolean: /\b(?:false|true)\b/,
number:
/\b0b[01][01_]*L?\b|\b0x(?:[\da-f_]*\.)?[\da-f_p+-]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfls]?/i,
punctuation: /[{}[\];(),.:]/,
operator:
/<==|>==|=>|->|<-|<>|&==|&<>|\?:?|\.\?|\+\+|--|[-+*/=<>]=?|[!^~]|\b(?:and|as|band|bor|bxor|comp|is|isnot|mod|or)\b=?/,
annotation: {
pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
alias: 'builtin'
}
}
Prism.languages.insertBefore('concurnas', 'langext', {
'regex-literal': {
pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
greedy: true,
inside: {
interpolation: {
pattern:
/((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
lookbehind: true,
inside: Prism.languages.concurnas
},
regex: /[\s\S]+/
}
},
'string-literal': {
pattern: /(?:\B|\bs)("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
greedy: true,
inside: {
interpolation: {
pattern:
/((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
lookbehind: true,
inside: Prism.languages.concurnas
},
string: /[\s\S]+/
}
}
})
Prism.languages.conc = Prism.languages.concurnas
}

63
frontend/node_modules/refractor/lang/coq.js generated vendored Normal file
View File

@@ -0,0 +1,63 @@
'use strict'
module.exports = coq
coq.displayName = 'coq'
coq.aliases = []
function coq(Prism) {
;(function (Prism) {
// https://github.com/coq/coq
var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source
for (var i = 0; i < 2; i++) {
commentSource = commentSource.replace(/<self>/g, function () {
return commentSource
})
}
commentSource = commentSource.replace(/<self>/g, '[]')
Prism.languages.coq = {
comment: RegExp(commentSource),
string: {
pattern: /"(?:[^"]|"")*"(?!")/,
greedy: true
},
attribute: [
{
pattern: RegExp(
/#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
/<comment>/g,
function () {
return commentSource
}
)
),
greedy: true,
alias: 'attr-name',
inside: {
comment: RegExp(commentSource),
string: {
pattern: /"(?:[^"]|"")*"(?!")/,
greedy: true
},
operator: /=/,
punctuation: /^#\[|\]$|[,()]/
}
},
{
pattern:
/\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
alias: 'attr-name'
}
],
keyword:
/\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
number:
/\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
punct: {
pattern: /@\{|\{\||\[=|:>/,
alias: 'punctuation'
},
operator:
/\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
}
})(Prism)
}

119
frontend/node_modules/refractor/lang/cpp.js generated vendored Normal file
View File

@@ -0,0 +1,119 @@
'use strict'
var refractorC = require('./c.js')
module.exports = cpp
cpp.displayName = 'cpp'
cpp.aliases = []
function cpp(Prism) {
Prism.register(refractorC)
;(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
}, // This is intended to capture the class name of method implementations like:
// void foo::bar() const {}
// However! The `foo` in the above example could also be a namespace, so we only capture the class name if
// it starts with an uppercase letter. This approximation should give decent results.
/\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, // This will capture the class name before destructors like:
// Foo::~Foo() {}
/\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, // This also intends to capture the class name of method implementations but here the class has template
// parameters, so it can't be a namespace (until C++ adds generic namespaces).
/\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: {
// https://en.cppreference.com/w/cpp/language/modules
pattern: RegExp(
/(\b(?:import|module)\s+)/.source +
'(?:' + // header-name
/"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
'|' + // module name or partition or both
/<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', {
// the base clause is an optional list of parent classes
// https://en.cppreference.com/w/cpp/language/class
'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',
{
// All untokenized words that are not namespaces should be class names
'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
},
Prism.languages.cpp['base-clause']
)
})(Prism)
}

62
frontend/node_modules/refractor/lang/crystal.js generated vendored Normal file
View File

@@ -0,0 +1,62 @@
'use strict'
var refractorRuby = require('./ruby.js')
module.exports = crystal
crystal.displayName = 'crystal'
crystal.aliases = []
function crystal(Prism) {
Prism.register(refractorRuby)
;(function (Prism) {
Prism.languages.crystal = Prism.languages.extend('ruby', {
keyword: [
/\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/,
{
pattern: /(\.\s*)(?:is_a|responds_to)\?/,
lookbehind: true
}
],
number:
/\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,
operator: [/->/, Prism.languages.ruby.operator],
punctuation: /[(){}[\].,;\\]/
})
Prism.languages.insertBefore('crystal', 'string-literal', {
attribute: {
pattern: /@\[.*?\]/,
inside: {
delimiter: {
pattern: /^@\[|\]$/,
alias: 'punctuation'
},
attribute: {
pattern: /^(\s*)\w+/,
lookbehind: true,
alias: 'class-name'
},
args: {
pattern: /\S(?:[\s\S]*\S)?/,
inside: Prism.languages.crystal
}
}
},
expansion: {
pattern: /\{(?:\{.*?\}|%.*?%)\}/,
inside: {
content: {
pattern: /^(\{.)[\s\S]+(?=.\}$)/,
lookbehind: true,
inside: Prism.languages.crystal
},
delimiter: {
pattern: /^\{[\{%]|[\}%]\}$/,
alias: 'operator'
}
}
},
char: {
pattern:
/'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,
greedy: true
}
})
})(Prism)
}

464
frontend/node_modules/refractor/lang/csharp.js generated vendored Normal file
View File

@@ -0,0 +1,464 @@
'use strict'
module.exports = csharp
csharp.displayName = 'csharp'
csharp.aliases = ['dotnet', 'cs']
function csharp(Prism) {
;(function (Prism) {
/**
* Replaces all placeholders "<<n>>" of given pattern with the n-th replacement (zero based).
*
* Note: This is a simple text based replacement. Be careful when using backreferences!
*
* @param {string} pattern the given pattern.
* @param {string[]} replacements a list of replacement which can be inserted into the given pattern.
* @returns {string} the pattern with all placeholders replaced with their corresponding replacements.
* @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source
*/
function replace(pattern, replacements) {
return pattern.replace(/<<(\d+)>>/g, function (m, index) {
return '(?:' + replacements[+index] + ')'
})
}
/**
* @param {string} pattern
* @param {string[]} replacements
* @param {string} [flags]
* @returns {RegExp}
*/
function re(pattern, replacements, flags) {
return RegExp(replace(pattern, replacements), flags || '')
}
/**
* Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
*
* @param {string} pattern
* @param {number} depthLog2
* @returns {string}
*/
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]')
} // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
var keywordKinds = {
// keywords which represent a return or variable type
type: 'bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void',
// keywords which are used to declare a type
typeDeclaration: 'class enum interface record struct',
// contextual keywords
// ("var" and "dynamic" are missing because they are used like types)
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*{)',
// all other keywords
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'
} // keywords
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
) // types
var generic = nested(/<(?:[^<>;=+\-*/%&|^]|<<self>>)*>/.source, 2) // the idea behind the other forbidden characters is to prevent false positives. Same for tupleElement.
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: /[<>()?,.:[\]]/
} // strings & characters
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#character-literals
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#string-literals
var character = /'(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'/.source // simplified pattern
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': [
{
// Using static
// using static System.Math;
pattern: re(/(\busing\s+static\s+)<<0>>(?=\s*;)/.source, [
identifier
]),
lookbehind: true,
inside: typeInside
},
{
// Using alias (type)
// using Project = PC.MyCompany.Project;
pattern: re(/(\busing\s+<<0>>\s*=\s*)<<1>>(?=\s*;)/.source, [
name,
typeExpression
]),
lookbehind: true,
inside: typeInside
},
{
// Using alias (alias)
// using Project = PC.MyCompany.Project;
pattern: re(/(\busing\s+)<<0>>(?=\s*=)/.source, [name]),
lookbehind: true
},
{
// Type declarations
// class Foo<A, B>
// interface Foo<out A, B>
pattern: re(/(\b<<0>>\s+)<<1>>/.source, [
typeDeclarationKeywords,
genericName
]),
lookbehind: true,
inside: typeInside
},
{
// Single catch exception declaration
// catch(Foo)
// (things like catch(Foo e) is covered by variable declaration)
pattern: re(/(\bcatch\s*\(\s*)<<0>>/.source, [identifier]),
lookbehind: true,
inside: typeInside
},
{
// Name of the type parameter of generic constraints
// where Foo : class
pattern: re(/(\bwhere\s+)<<0>>/.source, [name]),
lookbehind: true
},
{
// Casts and checks via as and is.
// as Foo<A>, is Bar<B>
// (things like if(a is Foo b) is covered by variable declaration)
pattern: re(/(\b(?:is(?:\s+not)?|as)\s+)<<0>>/.source, [
typeExpressionWithoutTuple
]),
lookbehind: true,
inside: typeInside
},
{
// Variable, field and parameter declaration
// (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
pattern: re(
/\b<<0>>(?=\s+(?!<<1>>|with\s*\{)<<2>>(?:\s*[=,;:{)\]]|\s+(?:in|when)\b))/
.source,
[typeExpression, nonContextualKeywords, name]
),
inside: typeInside
}
],
keyword: keywords,
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
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: {
// namespace Foo.Bar {}
// using Foo.Bar;
pattern: re(
/(\b(?:namespace|using)\s+)<<0>>(?:\s*\.\s*<<0>>)*(?=\s*[;{])/.source,
[name]
),
lookbehind: true,
inside: {
punctuation: /\./
}
},
'type-expression': {
// default(Foo), typeof(Foo<Bar>), sizeof(int)
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': {
// Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
// int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
// int Foo => 0; int Foo { get; set } = 0;
pattern: re(
/<<0>>(?=\s+(?:<<1>>\s*(?:=>|[({]|\.\s*this\s*\[)|this\s*\[))/.source,
[typeExpression, identifier]
),
inside: typeInside,
alias: 'class-name'
},
'constructor-invocation': {
// new List<Foo<Bar[]>> { }
pattern: re(/(\bnew\s+)<<0>>(?=\s*[[({])/.source, [typeExpression]),
lookbehind: true,
inside: typeInside,
alias: 'class-name'
},
/*'explicit-implementation': {
// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
pattern: replace(/\b<<0>>(?=\.<<1>>)/, className, methodOrPropertyDeclaration),
inside: classNameInside,
alias: 'class-name'
},*/
'generic-method': {
// foo<Bar>()
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': {
// The list of types inherited or of generic constraints
// class Foo<F> : Bar, IList<FooBar>
// where F : Bar, IList<int>
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: {
// highlight preprocessor directives as keywords
directive: {
pattern:
/(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
lookbehind: true,
alias: 'keyword'
}
}
}
}) // attributes
var regularStringOrCharacter = regularString + '|' + character
var regularStringCharacterOrComment = replace(
/\/(?![*/])|\/\/[^\r\n]*[\r\n]|\/\*(?:[^*]|\*(?!\/))*\*\/|<<0>>/.source,
[regularStringOrCharacter]
)
var roundExpression = nested(
replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
regularStringCharacterOrComment
]),
2
) // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets
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: {
// Attributes
// [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
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: /[:,]/
}
}
}) // string interpolation
var formatString = /:[^}\r\n]+/.source // multi line
var mInterpolationRound = nested(
replace(/[^"'/()]|<<0>>|\(<<self>>*\)/.source, [
regularStringCharacterOrComment
]),
2
)
var mInterpolation = replace(/\{(?!\{)(?:(?![}:])<<0>>)*<<1>>?\}/.source, [
mInterpolationRound,
formatString
]) // single line
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)
}

217
frontend/node_modules/refractor/lang/cshtml.js generated vendored Normal file
View File

@@ -0,0 +1,217 @@
'use strict'
var refractorCsharp = require('./csharp.js')
module.exports = cshtml
cshtml.displayName = 'cshtml'
cshtml.aliases = ['razor']
function cshtml(Prism) {
Prism.register(refractorCsharp)
// Docs:
// https://docs.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-5.0&tabs=visual-studio
// https://docs.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-5.0
;(function (Prism) {
var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//
.source
var stringLike =
/@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source +
'|' +
/'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source
/**
* Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
*
* @param {string} pattern
* @param {number} depthLog2
* @returns {string}
*/
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]')
.replace(/<str>/g, '(?:' + stringLike + ')')
.replace(/<comment>/g, '(?:' + commentLike + ')')
}
var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2)
var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 2)
var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2)
var angle = nested(/<(?:[^<>'"@/]|<str>|<comment>|<self>)*>/.source, 2) // Note about the above bracket patterns:
// They all ignore HTML expressions that might be in the C# code. This is a problem because HTML (like strings and
// comments) is parsed differently. This is a huge problem because HTML might contain brackets and quotes which
// messes up the bracket and string counting implemented by the above patterns.
//
// This problem is not fixable because 1) HTML expression are highly context sensitive and very difficult to detect
// and 2) they require one capturing group at every nested level. See the `tagRegion` pattern to admire the
// complexity of an HTML expression.
//
// To somewhat alleviate the problem a bit, the patterns for characters (e.g. 'a') is very permissive, it also
// allows invalid characters to support HTML expressions like this: <p>That's it!</p>.
var tagAttrs =
/(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?/
.source
var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source
var tagRegion =
/\B@?/.source +
'(?:' +
/<([a-zA-Z][\w:]*)/.source +
tagAttrs +
/\s*>/.source +
'(?:' +
(/[^<]/.source +
'|' + // all tags that are not the start tag
// eslint-disable-next-line regexp/strict
/<\/?(?!\1\b)/.source +
tagContent +
'|' + // nested start tag
nested(
// eslint-disable-next-line regexp/strict
/<\1/.source +
tagAttrs +
/\s*>/.source +
'(?:' +
(/[^<]/.source +
'|' + // all tags that are not the start tag
// eslint-disable-next-line regexp/strict
/<\/?(?!\1\b)/.source +
tagContent +
'|' +
'<self>') +
')*' + // eslint-disable-next-line regexp/strict
/<\/\1\s*>/.source,
2
)) +
')*' + // eslint-disable-next-line regexp/strict
/<\/\1\s*>/.source +
'|' +
/</.source +
tagContent +
')' // Now for the actual language definition(s):
//
// Razor as a language has 2 parts:
// 1) CSHTML: A markup-like language that has been extended with inline C# code expressions and blocks.
// 2) C#+HTML: A variant of C# that can contain CSHTML tags as expressions.
//
// In the below code, both CSHTML and C#+HTML will be create as separate language definitions that reference each
// other. However, only CSHTML will be exported via `Prism.languages`.
Prism.languages.cshtml = Prism.languages.extend('markup', {})
var csharpWithHtml = Prism.languages.insertBefore(
'csharp',
'string',
{
html: {
pattern: RegExp(tagRegion),
greedy: true,
inside: Prism.languages.cshtml
}
},
{
csharp: Prism.languages.extend('csharp', {})
}
)
var cs = {
pattern: /\S[\s\S]*/,
alias: 'language-csharp',
inside: csharpWithHtml
}
Prism.languages.insertBefore('cshtml', 'prolog', {
'razor-comment': {
pattern: /@\*[\s\S]*?\*@/,
greedy: true,
alias: 'comment'
},
block: {
pattern: RegExp(
/(^|[^@])@/.source +
'(?:' +
[
// @{ ... }
curly, // @code{ ... }
/(?:code|functions)\s*/.source + curly, // @for (...) { ... }
/(?:for|foreach|lock|switch|using|while)\s*/.source +
round +
/\s*/.source +
curly, // @do { ... } while (...);
/do\s*/.source +
curly +
/\s*while\s*/.source +
round +
/(?:\s*;)?/.source, // @try { ... } catch (...) { ... } finally { ... }
/try\s*/.source +
curly +
/\s*catch\s*/.source +
round +
/\s*/.source +
curly +
/\s*finally\s*/.source +
curly, // @if (...) {...} else if (...) {...} else {...}
/if\s*/.source +
round +
/\s*/.source +
curly +
'(?:' +
/\s*else/.source +
'(?:' +
/\s+if\s*/.source +
round +
')?' +
/\s*/.source +
curly +
')*'
].join('|') +
')'
),
lookbehind: true,
greedy: true,
inside: {
keyword: /^@\w*/,
csharp: cs
}
},
directive: {
pattern:
/^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
lookbehind: true,
greedy: true,
inside: {
keyword: /^@\w+/,
csharp: cs
}
},
value: {
pattern: RegExp(
/(^|[^@])@/.source +
/(?:await\b\s*)?/.source +
'(?:' +
/\w+\b/.source +
'|' +
round +
')' +
'(?:' +
/[?!]?\.\w+\b/.source +
'|' +
round +
'|' +
square +
'|' +
angle +
round +
')*'
),
lookbehind: true,
greedy: true,
alias: 'variable',
inside: {
keyword: /^@/,
csharp: cs
}
},
'delegate-operator': {
pattern: /(^|[^@])@(?=<)/,
lookbehind: true,
alias: 'operator'
}
})
Prism.languages.razor = Prism.languages.cshtml
})(Prism)
}

83
frontend/node_modules/refractor/lang/csp.js generated vendored Normal file
View File

@@ -0,0 +1,83 @@
'use strict'
module.exports = csp
csp.displayName = 'csp'
csp.aliases = []
function csp(Prism) {
/**
* Original by Scott Helme.
*
* Reference: https://scotthelme.co.uk/csp-cheat-sheet/
*
* Supports the following:
* - https://www.w3.org/TR/CSP1/
* - https://www.w3.org/TR/CSP2/
* - https://www.w3.org/TR/CSP3/
*/
;(function (Prism) {
/**
* @param {string} source
* @returns {RegExp}
*/
function value(source) {
return RegExp(
/([ \t])/.source + '(?:' + source + ')' + /(?=[\s;]|$)/.source,
'i'
)
}
Prism.languages.csp = {
directive: {
pattern:
/(^|[\s;])(?:base-uri|block-all-mixed-content|(?:child|connect|default|font|frame|img|manifest|media|object|prefetch|script|style|worker)-src|disown-opener|form-action|frame-(?:ancestors|options)|input-protection(?:-(?:clip|selectors))?|navigate-to|plugin-types|policy-uri|referrer|reflected-xss|report-(?:to|uri)|require-sri-for|sandbox|(?:script|style)-src-(?:attr|elem)|upgrade-insecure-requests)(?=[\s;]|$)/i,
lookbehind: true,
alias: 'property'
},
scheme: {
pattern: value(/[a-z][a-z0-9.+-]*:/.source),
lookbehind: true
},
none: {
pattern: value(/'none'/.source),
lookbehind: true,
alias: 'keyword'
},
nonce: {
pattern: value(/'nonce-[-+/\w=]+'/.source),
lookbehind: true,
alias: 'number'
},
hash: {
pattern: value(/'sha(?:256|384|512)-[-+/\w=]+'/.source),
lookbehind: true,
alias: 'number'
},
host: {
pattern: value(
/[a-z][a-z0-9.+-]*:\/\/[^\s;,']*/.source +
'|' +
/\*[^\s;,']*/.source +
'|' +
/[a-z0-9-]+(?:\.[a-z0-9-]+)+(?::[\d*]+)?(?:\/[^\s;,']*)?/.source
),
lookbehind: true,
alias: 'url',
inside: {
important: /\*/
}
},
keyword: [
{
pattern: value(/'unsafe-[a-z-]+'/.source),
lookbehind: true,
alias: 'unsafe'
},
{
pattern: value(/'[a-z-]+'/.source),
lookbehind: true,
alias: 'safe'
}
],
punctuation: /;/
}
})(Prism)
}

122
frontend/node_modules/refractor/lang/css-extras.js generated vendored Normal file
View File

@@ -0,0 +1,122 @@
'use strict'
module.exports = cssExtras
cssExtras.displayName = 'cssExtras'
cssExtras.aliases = []
function cssExtras(Prism) {
;(function (Prism) {
var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/
var selectorInside
Prism.languages.css.selector = {
pattern: Prism.languages.css.selector.pattern,
lookbehind: true,
inside: (selectorInside = {
'pseudo-element':
/:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
'pseudo-class': /:[-\w]+/,
class: /\.[-\w]+/,
id: /#[-\w]+/,
attribute: {
pattern: RegExp('\\[(?:[^[\\]"\']|' + string.source + ')*\\]'),
greedy: true,
inside: {
punctuation: /^\[|\]$/,
'case-sensitivity': {
pattern: /(\s)[si]$/i,
lookbehind: true,
alias: 'keyword'
},
namespace: {
pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
lookbehind: true,
inside: {
punctuation: /\|$/
}
},
'attr-name': {
pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
lookbehind: true
},
'attr-value': [
string,
{
pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
lookbehind: true
}
],
operator: /[|~*^$]?=/
}
},
'n-th': [
{
pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
lookbehind: true,
inside: {
number: /[\dn]+/,
operator: /[+-]/
}
},
{
pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
lookbehind: true
}
],
combinator: />|\+|~|\|\|/,
// the `tag` token has been existed and removed.
// because we can't find a perfect tokenize to match it.
// if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
punctuation: /[(),]/
})
}
Prism.languages.css['atrule'].inside['selector-function-argument'].inside =
selectorInside
Prism.languages.insertBefore('css', 'property', {
variable: {
pattern:
/(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
lookbehind: true
}
})
var unit = {
pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
lookbehind: true
} // 123 -123 .123 -.123 12.3 -12.3
var number = {
pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
lookbehind: true
}
Prism.languages.insertBefore('css', 'function', {
operator: {
pattern: /(\s)[+\-*\/](?=\s)/,
lookbehind: true
},
// CAREFUL!
// Previewers and Inline color use hexcode and color.
hexcode: {
pattern: /\B#[\da-f]{3,8}\b/i,
alias: 'color'
},
color: [
{
pattern:
/(^|[^\w-])(?: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)(?![\w-])/i,
lookbehind: true
},
{
pattern:
/\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)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: unit,
number: number,
function: /[\w-]+(?=\()/,
punctuation: /[(),]/
}
}
],
// it's important that there is no boundary assertion after the hex digits
entity: /\\[\da-f]{1,8}/i,
unit: unit,
number: number
})
})(Prism)
}

79
frontend/node_modules/refractor/lang/css.js generated vendored Normal file
View File

@@ -0,0 +1,79 @@
'use strict'
module.exports = css
css.displayName = 'css'
css.aliases = []
function css(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
} // See rest below
}
},
url: {
// https://drafts.csswg.org/css-values-3/#urls
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)
}

12
frontend/node_modules/refractor/lang/csv.js generated vendored Normal file
View File

@@ -0,0 +1,12 @@
'use strict'
module.exports = csv
csv.displayName = 'csv'
csv.aliases = []
function csv(Prism) {
// https://tools.ietf.org/html/rfc4180
Prism.languages.csv = {
value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
punctuation: /,/
}
}

41
frontend/node_modules/refractor/lang/cypher.js generated vendored Normal file
View File

@@ -0,0 +1,41 @@
'use strict'
module.exports = cypher
cypher.displayName = 'cypher'
cypher.aliases = []
function cypher(Prism) {
Prism.languages.cypher = {
// https://neo4j.com/docs/cypher-manual/current/syntax/comments/
comment: /\/\/.*/,
string: {
pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/,
greedy: true
},
'class-name': {
pattern: /(:\s*)(?:\w+|`(?:[^`\\\r\n])*`)(?=\s*[{):])/,
lookbehind: true,
greedy: true
},
relationship: {
pattern:
/(-\[\s*(?:\w+\s*|`(?:[^`\\\r\n])*`\s*)?:\s*|\|\s*:\s*)(?:\w+|`(?:[^`\\\r\n])*`)/,
lookbehind: true,
greedy: true,
alias: 'property'
},
identifier: {
pattern: /`(?:[^`\\\r\n])*`/,
greedy: true
},
variable: /\$\w+/,
// https://neo4j.com/docs/cypher-manual/current/syntax/reserved/
keyword:
/\b(?:ADD|ALL|AND|AS|ASC|ASCENDING|ASSERT|BY|CALL|CASE|COMMIT|CONSTRAINT|CONTAINS|CREATE|CSV|DELETE|DESC|DESCENDING|DETACH|DISTINCT|DO|DROP|ELSE|END|ENDS|EXISTS|FOR|FOREACH|IN|INDEX|IS|JOIN|KEY|LIMIT|LOAD|MANDATORY|MATCH|MERGE|NODE|NOT|OF|ON|OPTIONAL|OR|ORDER(?=\s+BY)|PERIODIC|REMOVE|REQUIRE|RETURN|SCALAR|SCAN|SET|SKIP|START|STARTS|THEN|UNION|UNIQUE|UNWIND|USING|WHEN|WHERE|WITH|XOR|YIELD)\b/i,
function: /\b\w+\b(?=\s*\()/,
boolean: /\b(?:false|null|true)\b/i,
number: /\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
// https://neo4j.com/docs/cypher-manual/current/syntax/operators/
operator: /:|<--?|--?>?|<>|=~?|[<>]=?|[+*/%^|]|\.\.\.?/,
punctuation: /[()[\]{},;.]/
}
}

87
frontend/node_modules/refractor/lang/d.js generated vendored Normal file
View File

@@ -0,0 +1,87 @@
'use strict'
module.exports = d
d.displayName = 'd'
d.aliases = []
function d(Prism) {
Prism.languages.d = Prism.languages.extend('clike', {
comment: [
{
// Shebang
pattern: /^\s*#!.+/,
greedy: true
},
{
pattern: RegExp(
/(^|[^\\])/.source +
'(?:' +
[
// /+ comment +/
// Allow one level of nesting
/\/\+(?:\/\+(?:[^+]|\+(?!\/))*\+\/|(?!\/\+)[\s\S])*?\+\//.source, // // comment
/\/\/.*/.source, // /* comment */
/\/\*[\s\S]*?\*\//.source
].join('|') +
')'
),
lookbehind: true,
greedy: true
}
],
string: [
{
pattern: RegExp(
[
// r"", x""
/\b[rx]"(?:\\[\s\S]|[^\\"])*"[cwd]?/.source, // q"[]", q"()", q"<>", q"{}"
/\bq"(?:\[[\s\S]*?\]|\([\s\S]*?\)|<[\s\S]*?>|\{[\s\S]*?\})"/.source, // q"IDENT
// ...
// IDENT"
/\bq"((?!\d)\w+)$[\s\S]*?^\1"/.source, // q"//", q"||", etc.
// eslint-disable-next-line regexp/strict
/\bq"(.)[\s\S]*?\2"/.source, // eslint-disable-next-line regexp/strict
/(["`])(?:\\[\s\S]|(?!\3)[^\\])*\3[cwd]?/.source
].join('|'),
'm'
),
greedy: true
},
{
pattern: /\bq\{(?:\{[^{}]*\}|[^{}])*\}/,
greedy: true,
alias: 'token-string'
}
],
// In order: $, keywords and special tokens, globally defined symbols
keyword:
/\$|\b(?:__(?:(?:DATE|EOF|FILE|FUNCTION|LINE|MODULE|PRETTY_FUNCTION|TIMESTAMP|TIME|VENDOR|VERSION)__|gshared|parameters|traits|vector)|abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|dstring|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|ptrdiff_t|public|pure|real|ref|return|scope|shared|short|size_t|static|string|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|wstring)\b/,
number: [
// The lookbehind and the negative look-ahead try to prevent bad highlighting of the .. operator
// Hexadecimal numbers must be handled separately to avoid problems with exponent "e"
/\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]{0,4}/i,
{
pattern:
/((?:\.\.)?)(?:\b0b\.?|\b|\.)\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:e[+-]?\d[\d_]*)?[ulfi]{0,4}/i,
lookbehind: true
}
],
operator:
/\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?/
})
Prism.languages.insertBefore('d', 'string', {
// Characters
// 'a', '\\', '\n', '\xFF', '\377', '\uFFFF', '\U0010FFFF', '\quot'
char: /'(?:\\(?:\W|\w+)|[^\\])'/
})
Prism.languages.insertBefore('d', 'keyword', {
property: /\B@\w*/
})
Prism.languages.insertBefore('d', 'function', {
register: {
// Iasm registers
pattern:
/\b(?:[ABCD][LHX]|E?(?:BP|DI|SI|SP)|[BS]PL|[ECSDGF]S|CR[0234]|[DS]IL|DR[012367]|E[ABCD]X|X?MM[0-7]|R(?:1[0-5]|[89])[BWD]?|R[ABCD]X|R[BS]P|R[DS]I|TR[3-7]|XMM(?:1[0-5]|[89])|YMM(?:1[0-5]|\d))\b|\bST(?:\([0-7]\)|\b)/,
alias: 'variable'
}
})
}

85
frontend/node_modules/refractor/lang/dart.js generated vendored Normal file
View File

@@ -0,0 +1,85 @@
'use strict'
module.exports = dart
dart.displayName = 'dart'
dart.aliases = []
function dart(Prism) {
;(function (Prism) {
var keywords = [
/\b(?:async|sync|yield)\*/,
/\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
] // Handles named imports, such as http.Client
var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/
.source // based on the dart naming conventions
var className = {
pattern: RegExp(packagePrefix + /[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: /\./
}
}
}
}
Prism.languages.dart = Prism.languages.extend('clike', {
'class-name': [
className,
{
// variables and parameters
// this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
pattern: RegExp(
packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
),
lookbehind: true,
inside: className.inside
}
],
keyword: keywords,
operator:
/\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
})
Prism.languages.insertBefore('dart', 'string', {
'string-literal': {
pattern:
/r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
greedy: true,
inside: {
interpolation: {
pattern:
/((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
lookbehind: true,
inside: {
punctuation: /^\$\{?|\}$/,
expression: {
pattern: /[\s\S]+/,
inside: Prism.languages.dart
}
}
},
string: /[\s\S]+/
}
},
string: undefined
})
Prism.languages.insertBefore('dart', 'class-name', {
metadata: {
pattern: /@\w+/,
alias: 'function'
}
})
Prism.languages.insertBefore('dart', 'class-name', {
generics: {
pattern:
/<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
inside: {
'class-name': className,
keyword: keywords,
punctuation: /[<>(),.:]/,
operator: /[?&|]/
}
}
})
})(Prism)
}

49
frontend/node_modules/refractor/lang/dataweave.js generated vendored Normal file
View File

@@ -0,0 +1,49 @@
'use strict'
module.exports = dataweave
dataweave.displayName = 'dataweave'
dataweave.aliases = []
function dataweave(Prism) {
;(function (Prism) {
Prism.languages.dataweave = {
url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
property: {
pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
greedy: true
},
string: {
pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
greedy: true
},
'mime-type':
/\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
date: {
pattern: /\|[\w:+-]+\|/,
greedy: true
},
comment: [
{
pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
lookbehind: true,
greedy: true
},
{
pattern: /(^|[^\\:])\/\/.*/,
lookbehind: true,
greedy: true
}
],
regex: {
pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
greedy: true
},
keyword:
/\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
function: /\b[A-Z_]\w*(?=\s*\()/i,
number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
punctuation: /[{}[\];(),.:@]/,
operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
boolean: /\b(?:false|true)\b/
}
})(Prism)
}

37
frontend/node_modules/refractor/lang/dax.js generated vendored Normal file
View File

@@ -0,0 +1,37 @@
'use strict'
module.exports = dax
dax.displayName = 'dax'
dax.aliases = []
function dax(Prism) {
Prism.languages.dax = {
comment: {
pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
lookbehind: true
},
'data-field': {
pattern:
/'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,
alias: 'symbol'
},
measure: {
pattern: /\[[ \w\xA0-\uFFFF]+\]/,
alias: 'constant'
},
string: {
pattern: /"(?:[^"]|"")*"(?!")/,
greedy: true
},
function:
/\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,
keyword:
/\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,
boolean: {
pattern: /\b(?:FALSE|NULL|TRUE)\b/i,
alias: 'constant'
},
number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
punctuation: /[;\[\](){}`,.]/
}
}

77
frontend/node_modules/refractor/lang/dhall.js generated vendored Normal file
View File

@@ -0,0 +1,77 @@
'use strict'
module.exports = dhall
dhall.displayName = 'dhall'
dhall.aliases = []
function dhall(Prism) {
// ABNF grammar:
// https://github.com/dhall-lang/dhall-lang/blob/master/standard/dhall.abnf
Prism.languages.dhall = {
// Multi-line comments can be nested. E.g. {- foo {- bar -} -}
// The multi-line pattern is essentially this:
// \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
comment:
/--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
string: {
pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
greedy: true,
inside: {
interpolation: {
pattern: /\$\{[^{}]*\}/,
inside: {
expression: {
pattern: /(^\$\{)[\s\S]+(?=\}$)/,
lookbehind: true,
alias: 'language-dhall',
inside: null // see blow
},
punctuation: /\$\{|\}/
}
}
}
},
label: {
pattern: /`[^`]*`/,
greedy: true
},
url: {
// https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
pattern:
/\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
greedy: true
},
env: {
// https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
greedy: true,
inside: {
function: /^env/,
operator: /^:/,
variable: /[\s\S]+/
}
},
hash: {
// https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
pattern: /\bsha256:[\da-fA-F]{64}\b/,
inside: {
function: /sha256/,
operator: /:/,
number: /[\da-fA-F]{64}/
}
},
// https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
keyword:
/\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
builtin: /\b(?:None|Some)\b/,
boolean: /\b(?:False|True)\b/,
number:
/\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
operator:
/\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
punctuation: /\.\.|[{}\[\](),./]/,
// we'll just assume that every capital word left is a type name
'class-name': /\b[A-Z]\w*\b/
}
Prism.languages.dhall.string.inside.interpolation.inside.expression.inside =
Prism.languages.dhall
}

61
frontend/node_modules/refractor/lang/diff.js generated vendored Normal file
View File

@@ -0,0 +1,61 @@
'use strict'
module.exports = diff
diff.displayName = 'diff'
diff.aliases = []
function diff(Prism) {
;(function (Prism) {
Prism.languages.diff = {
coord: [
// Match all kinds of coord lines (prefixed by "+++", "---" or "***").
/^(?:\*{3}|-{3}|\+{3}).*$/m, // Match "@@ ... @@" coord lines in unified diff.
/^@@.*@@$/m, // Match coord lines in normal diff (starts with a number).
/^\d.*$/m
] // deleted, inserted, unchanged, diff
}
/**
* A map from the name of a block to its line prefix.
*
* @type {Object<string, string>}
*/
var PREFIXES = {
'deleted-sign': '-',
'deleted-arrow': '<',
'inserted-sign': '+',
'inserted-arrow': '>',
unchanged: ' ',
diff: '!'
} // add a token for each prefix
Object.keys(PREFIXES).forEach(function (name) {
var prefix = PREFIXES[name]
var alias = []
if (!/^\w+$/.test(name)) {
// "deleted-sign" -> "deleted"
alias.push(/\w+/.exec(name)[0])
}
if (name === 'diff') {
alias.push('bold')
}
Prism.languages.diff[name] = {
pattern: RegExp(
'^(?:[' + prefix + '].*(?:\r\n?|\n|(?![\\s\\S])))+',
'm'
),
alias: alias,
inside: {
line: {
pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
lookbehind: true
},
prefix: {
pattern: /[\s\S]/,
alias: /\w+/.exec(name)[0]
}
}
}
}) // make prefixes available to Diff plugin
Object.defineProperty(Prism.languages.diff, 'PREFIXES', {
value: PREFIXES
})
})(Prism)
}

61
frontend/node_modules/refractor/lang/django.js generated vendored Normal file
View File

@@ -0,0 +1,61 @@
'use strict'
var refractorMarkupTemplating = require('./markup-templating.js')
module.exports = django
django.displayName = 'django'
django.aliases = ['jinja2']
function django(Prism) {
Prism.register(refractorMarkupTemplating)
// Django/Jinja2 syntax definition for Prism.js <http://prismjs.com> syntax highlighter.
// Mostly it works OK but can paint code incorrectly on complex html/template tag combinations.
;(function (Prism) {
Prism.languages.django = {
comment: /^\{#[\s\S]*?#\}$/,
tag: {
pattern: /(^\{%[+-]?\s*)\w+/,
lookbehind: true,
alias: 'keyword'
},
delimiter: {
pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
alias: 'punctuation'
},
string: {
pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
greedy: true
},
filter: {
pattern: /(\|)\w+/,
lookbehind: true,
alias: 'function'
},
test: {
pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
lookbehind: true,
alias: 'function'
},
function: /\b[a-z_]\w+(?=\s*\()/i,
keyword:
/\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
number: /\b\d+(?:\.\d+)?\b/,
boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
variable: /\b\w+\b/,
punctuation: /[{}[\](),.:;]/
}
var pattern = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g
var markupTemplating = Prism.languages['markup-templating']
Prism.hooks.add('before-tokenize', function (env) {
markupTemplating.buildPlaceholders(env, 'django', pattern)
})
Prism.hooks.add('after-tokenize', function (env) {
markupTemplating.tokenizePlaceholders(env, 'django')
}) // Add an Jinja2 alias
Prism.languages.jinja2 = Prism.languages.django
Prism.hooks.add('before-tokenize', function (env) {
markupTemplating.buildPlaceholders(env, 'jinja2', pattern)
})
Prism.hooks.add('after-tokenize', function (env) {
markupTemplating.tokenizePlaceholders(env, 'jinja2')
})
})(Prism)
}

40
frontend/node_modules/refractor/lang/dns-zone-file.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
'use strict'
module.exports = dnsZoneFile
dnsZoneFile.displayName = 'dnsZoneFile'
dnsZoneFile.aliases = []
function dnsZoneFile(Prism) {
Prism.languages['dns-zone-file'] = {
comment: /;.*/,
string: {
pattern: /"(?:\\.|[^"\\\r\n])*"/,
greedy: true
},
variable: [
{
pattern: /(^\$ORIGIN[ \t]+)\S+/m,
lookbehind: true
},
{
pattern: /(^|\s)@(?=\s|$)/,
lookbehind: true
}
],
keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
class: {
// https://tools.ietf.org/html/rfc1035#page-13
pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
lookbehind: true,
alias: 'keyword'
},
type: {
// https://en.wikipedia.org/wiki/List_of_DNS_record_types
pattern:
/(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,
lookbehind: true,
alias: 'keyword'
},
punctuation: /[()]/
}
Prism.languages['dns-zone'] = Prism.languages['dns-zone-file']
}

123
frontend/node_modules/refractor/lang/docker.js generated vendored Normal file
View File

@@ -0,0 +1,123 @@
'use strict'
module.exports = docker
docker.displayName = 'docker'
docker.aliases = ['dockerfile']
function docker(Prism) {
;(function (Prism) {
// Many of the following regexes will contain negated lookaheads like `[ \t]+(?![ \t])`. This is a trick to ensure
// that quantifiers behave *atomically*. Atomic quantifiers are necessary to prevent exponential backtracking.
var spaceAfterBackSlash =
/\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source // At least one space, comment, or line break
var space = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(
/<SP_BS>/g,
function () {
return spaceAfterBackSlash
}
)
var string =
/"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/
.source
var option = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(
/<STR>/g,
function () {
return string
}
)
var stringRule = {
pattern: RegExp(string),
greedy: true
}
var commentRule = {
pattern: /(^[ \t]*)#.*/m,
lookbehind: true,
greedy: true
}
/**
* @param {string} source
* @param {string} flags
* @returns {RegExp}
*/
function re(source, flags) {
source = source
.replace(/<OPT>/g, function () {
return option
})
.replace(/<SP>/g, function () {
return space
})
return RegExp(source, flags)
}
Prism.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: true,
greedy: true,
inside: {
options: {
pattern: re(
/(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,
'i'
),
lookbehind: true,
greedy: true,
inside: {
property: {
pattern: /(^|\s)--[\w-]+/,
lookbehind: true
},
string: [
stringRule,
{
pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
lookbehind: true
}
],
operator: /\\$/m,
punctuation: /=/
}
},
keyword: [
{
// https://docs.docker.com/engine/reference/builder/#healthcheck
pattern: re(
/(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/
.source,
'i'
),
lookbehind: true,
greedy: true
},
{
// https://docs.docker.com/engine/reference/builder/#from
pattern: re(
/(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/
.source,
'i'
),
lookbehind: true,
greedy: true
},
{
// https://docs.docker.com/engine/reference/builder/#onbuild
pattern: re(/(^ONBUILD<SP>)\w+/.source, 'i'),
lookbehind: true,
greedy: true
},
{
pattern: /^\w+/,
greedy: true
}
],
comment: commentRule,
string: stringRule,
variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
operator: /\\$/m
}
},
comment: commentRule
}
Prism.languages.dockerfile = Prism.languages.docker
})(Prism)
}

85
frontend/node_modules/refractor/lang/dot.js generated vendored Normal file
View File

@@ -0,0 +1,85 @@
'use strict'
module.exports = dot
dot.displayName = 'dot'
dot.aliases = ['gv']
function dot(Prism) {
// https://www.graphviz.org/doc/info/lang.html
;(function (Prism) {
var ID =
'(?:' +
[
// an identifier
/[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source, // a number
/-?(?:\.\d+|\d+(?:\.\d*)?)/.source, // a double-quoted string
/"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source, // HTML-like string
/<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/
.source
].join('|') +
')'
var IDInside = {
markup: {
pattern: /(^<)[\s\S]+(?=>$)/,
lookbehind: true,
alias: ['language-markup', 'language-html', 'language-xml'],
inside: Prism.languages.markup
}
}
/**
* @param {string} source
* @param {string} flags
* @returns {RegExp}
*/
function withID(source, flags) {
return RegExp(
source.replace(/<ID>/g, function () {
return ID
}),
flags
)
}
Prism.languages.dot = {
comment: {
pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
greedy: true
},
'graph-name': {
pattern: withID(
/(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
'i'
),
lookbehind: true,
greedy: true,
alias: 'class-name',
inside: IDInside
},
'attr-value': {
pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
lookbehind: true,
greedy: true,
inside: IDInside
},
'attr-name': {
pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
lookbehind: true,
greedy: true,
inside: IDInside
},
keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
'compass-point': {
pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
lookbehind: true,
alias: 'builtin'
},
node: {
pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
lookbehind: true,
greedy: true,
inside: IDInside
},
operator: /[=:]|-[->]/,
punctuation: /[\[\]{};,]/
}
Prism.languages.gv = Prism.languages.dot
})(Prism)
}

27
frontend/node_modules/refractor/lang/ebnf.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
'use strict'
module.exports = ebnf
ebnf.displayName = 'ebnf'
ebnf.aliases = []
function ebnf(Prism) {
Prism.languages.ebnf = {
comment: /\(\*[\s\S]*?\*\)/,
string: {
pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
greedy: true
},
special: {
pattern: /\?[^?\r\n]*\?/,
greedy: true,
alias: 'class-name'
},
definition: {
pattern: /^([\t ]*)[a-z]\w*(?:[ \t]+[a-z]\w*)*(?=\s*=)/im,
lookbehind: true,
alias: ['rule', 'keyword']
},
rule: /\b[a-z]\w*(?:[ \t]+[a-z]\w*)*\b/i,
punctuation: /\([:/]|[:/]\)|[.,;()[\]{}]/,
operator: /[-=|*/!]/
}
}

34
frontend/node_modules/refractor/lang/editorconfig.js generated vendored Normal file
View File

@@ -0,0 +1,34 @@
'use strict'
module.exports = editorconfig
editorconfig.displayName = 'editorconfig'
editorconfig.aliases = []
function editorconfig(Prism) {
Prism.languages.editorconfig = {
// https://editorconfig-specification.readthedocs.io
comment: /[;#].*/,
section: {
pattern: /(^[ \t]*)\[.+\]/m,
lookbehind: true,
alias: 'selector',
inside: {
regex: /\\\\[\[\]{},!?.*]/,
// Escape special characters with '\\'
operator: /[!?]|\.\.|\*{1,2}/,
punctuation: /[\[\]{},]/
}
},
key: {
pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
lookbehind: true,
alias: 'attr-name'
},
value: {
pattern: /=.*/,
alias: 'attr-value',
inside: {
punctuation: /^=/
}
}
}
}

39
frontend/node_modules/refractor/lang/eiffel.js generated vendored Normal file
View File

@@ -0,0 +1,39 @@
'use strict'
module.exports = eiffel
eiffel.displayName = 'eiffel'
eiffel.aliases = []
function eiffel(Prism) {
Prism.languages.eiffel = {
comment: /--.*/,
string: [
// Aligned-verbatim-strings
{
pattern: /"([^[]*)\[[\s\S]*?\]\1"/,
greedy: true
}, // Non-aligned-verbatim-strings
{
pattern: /"([^{]*)\{[\s\S]*?\}\1"/,
greedy: true
}, // Single-line string
{
pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
greedy: true
}
],
// normal char | special char | char code
char: /'(?:%.|[^%'\r\n])+'/,
keyword:
/\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
boolean: /\b(?:False|True)\b/i,
// Convention: class-names are always all upper-case characters
'class-name': /\b[A-Z][\dA-Z_]*\b/,
number: [
// hexa | octal | bin
/\b0[xcb][\da-f](?:_*[\da-f])*\b/i, // Decimal
/(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
],
punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/
}
}

33
frontend/node_modules/refractor/lang/ejs.js generated vendored Normal file
View File

@@ -0,0 +1,33 @@
'use strict'
var refractorMarkupTemplating = require('./markup-templating.js')
module.exports = ejs
ejs.displayName = 'ejs'
ejs.aliases = ['eta']
function ejs(Prism) {
Prism.register(refractorMarkupTemplating)
;(function (Prism) {
Prism.languages.ejs = {
delimiter: {
pattern: /^<%[-_=]?|[-_]?%>$/,
alias: 'punctuation'
},
comment: /^#[\s\S]*/,
'language-javascript': {
pattern: /[\s\S]+/,
inside: Prism.languages.javascript
}
}
Prism.hooks.add('before-tokenize', function (env) {
var ejsPattern = /<%(?!%)[\s\S]+?%>/g
Prism.languages['markup-templating'].buildPlaceholders(
env,
'ejs',
ejsPattern
)
})
Prism.hooks.add('after-tokenize', function (env) {
Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs')
})
Prism.languages.eta = Prism.languages.ejs
})(Prism)
}

108
frontend/node_modules/refractor/lang/elixir.js generated vendored Normal file
View File

@@ -0,0 +1,108 @@
'use strict'
module.exports = elixir
elixir.displayName = 'elixir'
elixir.aliases = []
function elixir(Prism) {
Prism.languages.elixir = {
doc: {
pattern:
/@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
inside: {
attribute: /^@\w+/,
string: /['"][\s\S]+/
}
},
comment: {
pattern: /#.*/,
greedy: true
},
// ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
regex: {
pattern:
/~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
greedy: true
},
string: [
{
// ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
pattern:
/~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
greedy: true,
inside: {
// See interpolation below
}
},
{
pattern: /("""|''')[\s\S]*?\1/,
greedy: true,
inside: {
// See interpolation below
}
},
{
// Multi-line strings are allowed
pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
greedy: true,
inside: {
// See interpolation below
}
}
],
atom: {
// Look-behind prevents bad highlighting of the :: operator
pattern: /(^|[^:]):\w+/,
lookbehind: true,
alias: 'symbol'
},
module: {
pattern: /\b[A-Z]\w*\b/,
alias: 'class-name'
},
// Look-ahead prevents bad highlighting of the :: operator
'attr-name': /\b\w+\??:(?!:)/,
argument: {
// Look-behind prevents bad highlighting of the && operator
pattern: /(^|[^&])&\d+/,
lookbehind: true,
alias: 'variable'
},
attribute: {
pattern: /@\w+/,
alias: 'variable'
},
function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
keyword:
/\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
boolean: /\b(?:false|nil|true)\b/,
operator: [
/\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
{
// We don't want to match <<
pattern: /([^<])<(?!<)/,
lookbehind: true
},
{
// We don't want to match >>
pattern: /([^>])>(?!>)/,
lookbehind: true
}
],
punctuation: /<<|>>|[.,%\[\]{}()]/
}
Prism.languages.elixir.string.forEach(function (o) {
o.inside = {
interpolation: {
pattern: /#\{[^}]+\}/,
inside: {
delimiter: {
pattern: /^#\{|\}$/,
alias: 'punctuation'
},
rest: Prism.languages.elixir
}
}
}
})
}

56
frontend/node_modules/refractor/lang/elm.js generated vendored Normal file
View File

@@ -0,0 +1,56 @@
'use strict'
module.exports = elm
elm.displayName = 'elm'
elm.aliases = []
function elm(Prism) {
Prism.languages.elm = {
comment: /--.*|\{-[\s\S]*?-\}/,
char: {
pattern:
/'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
greedy: true
},
string: [
{
// Multiline strings are wrapped in triple ". Quotes may appear unescaped.
pattern: /"""[\s\S]*?"""/,
greedy: true
},
{
pattern: /"(?:[^\\"\r\n]|\\.)*"/,
greedy: true
}
],
'import-statement': {
// The imported or hidden names are not included in this import
// statement. This is because we want to highlight those exactly like
// we do for the names in the program.
pattern:
/(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
lookbehind: true,
inside: {
keyword: /\b(?:as|exposing|import)\b/
}
},
keyword:
/\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
// These are builtin variables only. Constructors are highlighted later as a constant.
builtin:
/\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
// decimal integers and floating point numbers | hexadecimal integers
number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
// Most of this is needed because of the meaning of a single '.'.
// If it stands alone freely, it is the function composition.
// It may also be a separator between a module name and an identifier => no
// operator. If it comes together with other special characters it is an
// operator too.
// Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!
// Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ
operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
// In Elm, nearly everything is a variable, do not highlight these.
hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
punctuation: /[{}[\]|(),.:]/
}
}

36
frontend/node_modules/refractor/lang/erb.js generated vendored Normal file
View File

@@ -0,0 +1,36 @@
'use strict'
var refractorRuby = require('./ruby.js')
var refractorMarkupTemplating = require('./markup-templating.js')
module.exports = erb
erb.displayName = 'erb'
erb.aliases = []
function erb(Prism) {
Prism.register(refractorRuby)
Prism.register(refractorMarkupTemplating)
;(function (Prism) {
Prism.languages.erb = {
delimiter: {
pattern: /^(\s*)<%=?|%>(?=\s*$)/,
lookbehind: true,
alias: 'punctuation'
},
ruby: {
pattern: /\s*\S[\s\S]*/,
alias: 'language-ruby',
inside: Prism.languages.ruby
}
}
Prism.hooks.add('before-tokenize', function (env) {
var erbPattern =
/<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g
Prism.languages['markup-templating'].buildPlaceholders(
env,
'erb',
erbPattern
)
})
Prism.hooks.add('after-tokenize', function (env) {
Prism.languages['markup-templating'].tokenizePlaceholders(env, 'erb')
})
})(Prism)
}

50
frontend/node_modules/refractor/lang/erlang.js generated vendored Normal file
View File

@@ -0,0 +1,50 @@
'use strict'
module.exports = erlang
erlang.displayName = 'erlang'
erlang.aliases = []
function erlang(Prism) {
Prism.languages.erlang = {
comment: /%.+/,
string: {
pattern: /"(?:\\.|[^\\"\r\n])*"/,
greedy: true
},
'quoted-function': {
pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
alias: 'function'
},
'quoted-atom': {
pattern: /'(?:\\.|[^\\'\r\n])+'/,
alias: 'atom'
},
boolean: /\b(?:false|true)\b/,
keyword: /\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,
number: [
/\$\\?./,
/\b\d+#[a-z0-9]+/i,
/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
],
function: /\b[a-z][\w@]*(?=\()/,
variable: {
// Look-behind is used to prevent wrong highlighting of atoms containing "@"
pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
lookbehind: true
},
operator: [
/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
{
// We don't want to match <<
pattern: /(^|[^<])<(?!<)/,
lookbehind: true
},
{
// We don't want to match >>
pattern: /(^|[^>])>(?!>)/,
lookbehind: true
}
],
atom: /\b[a-z][\w@]*/,
punctuation: /[()[\]{}:;,.#|]|<<|>>/
}
}

33
frontend/node_modules/refractor/lang/etlua.js generated vendored Normal file
View File

@@ -0,0 +1,33 @@
'use strict'
var refractorLua = require('./lua.js')
var refractorMarkupTemplating = require('./markup-templating.js')
module.exports = etlua
etlua.displayName = 'etlua'
etlua.aliases = []
function etlua(Prism) {
Prism.register(refractorLua)
Prism.register(refractorMarkupTemplating)
;(function (Prism) {
Prism.languages.etlua = {
delimiter: {
pattern: /^<%[-=]?|-?%>$/,
alias: 'punctuation'
},
'language-lua': {
pattern: /[\s\S]+/,
inside: Prism.languages.lua
}
}
Prism.hooks.add('before-tokenize', function (env) {
var pattern = /<%[\s\S]+?%>/g
Prism.languages['markup-templating'].buildPlaceholders(
env,
'etlua',
pattern
)
})
Prism.hooks.add('after-tokenize', function (env) {
Prism.languages['markup-templating'].tokenizePlaceholders(env, 'etlua')
})
})(Prism)
}

73
frontend/node_modules/refractor/lang/excel-formula.js generated vendored Normal file
View File

@@ -0,0 +1,73 @@
'use strict'
module.exports = excelFormula
excelFormula.displayName = 'excelFormula'
excelFormula.aliases = []
function excelFormula(Prism) {
Prism.languages['excel-formula'] = {
comment: {
pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
lookbehind: true,
greedy: true
},
string: {
pattern: /"(?:[^"]|"")*"(?!")/,
greedy: true
},
reference: {
// https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/
// Sales!B2
// 'Winter sales'!B2
// [Sales.xlsx]Jan!B2:B5
// D:\Reports\[Sales.xlsx]Jan!B2:B5
// '[Sales.xlsx]Jan sales'!B2:B5
// 'D:\Reports\[Sales.xlsx]Jan sales'!B2:B5
pattern:
/(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,
greedy: true,
alias: 'string',
inside: {
operator: /!$/,
punctuation: /'/,
sheet: {
pattern: /[^[\]]+$/,
alias: 'function'
},
file: {
pattern: /\[[^[\]]+\]$/,
inside: {
punctuation: /[[\]]/
}
},
path: /[\s\S]+/
}
},
'function-name': {
pattern: /\b[A-Z]\w*(?=\()/i,
alias: 'keyword'
},
range: {
pattern:
/\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,
alias: 'property',
inside: {
operator: /:/,
cell: /\$?[A-Z]+\$?\d+/i,
column: /\$?[A-Z]+/i,
row: /\$?\d+/
}
},
cell: {
// Excel is case insensitive, so the string "foo1" could be either a variable or a cell.
// To combat this, we match cells case insensitive, if the contain at least one "$", and case sensitive otherwise.
pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,
alias: 'property'
},
number: /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,
boolean: /\b(?:FALSE|TRUE)\b/i,
operator: /[-+*/^%=&,]|<[=>]?|>=?/,
punctuation: /[[\]();{}|]/
}
Prism.languages['xlsx'] = Prism.languages['xls'] =
Prism.languages['excel-formula']
}

925
frontend/node_modules/refractor/lang/factor.js generated vendored Normal file
View File

@@ -0,0 +1,925 @@
'use strict'
module.exports = factor
factor.displayName = 'factor'
factor.aliases = []
function factor(Prism) {
;(function (Prism) {
var comment_inside = {
function:
/\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/
}
var string_inside = {
number: /\\[^\s']|%\w/
}
var factor = {
comment: [
{
// ! single-line exclamation point comments with whitespace after/around the !
pattern: /(^|\s)(?:! .*|!$)/,
lookbehind: true,
inside: comment_inside
},
/* from basis/multiline: */
{
// /* comment */, /* comment*/
pattern: /(^|\s)\/\*\s[\s\S]*?\*\/(?=\s|$)/,
lookbehind: true,
greedy: true,
inside: comment_inside
},
{
// ![[ comment ]] , ![===[ comment]===]
pattern: /(^|\s)!\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
lookbehind: true,
greedy: true,
inside: comment_inside
}
],
number: [
{
// basic base 10 integers 9, -9
pattern: /(^|\s)[+-]?\d+(?=\s|$)/,
lookbehind: true
},
{
// base prefix integers 0b010 0o70 0xad 0d10 0XAD -0xa9
pattern: /(^|\s)[+-]?0(?:b[01]+|o[0-7]+|d\d+|x[\dA-F]+)(?=\s|$)/i,
lookbehind: true
},
{
// fractional ratios 1/5 -1/5 and the literal float approximations 1/5. -1/5.
pattern: /(^|\s)[+-]?\d+\/\d+\.?(?=\s|$)/,
lookbehind: true
},
{
// positive mixed numbers 23+1/5 +23+1/5
pattern: /(^|\s)\+?\d+\+\d+\/\d+(?=\s|$)/,
lookbehind: true
},
{
// negative mixed numbers -23-1/5
pattern: /(^|\s)-\d+-\d+\/\d+(?=\s|$)/,
lookbehind: true
},
{
// basic decimal floats -0.01 0. .0 .1 -.1 -1. -12.13 +12.13
// and scientific notation with base 10 exponents 3e4 3e-4 .3e-4
pattern:
/(^|\s)[+-]?(?:\d*\.\d+|\d+\.\d*|\d+)(?:e[+-]?\d+)?(?=\s|$)/i,
lookbehind: true
},
{
// NAN literal syntax NAN: 80000deadbeef, NAN: a
pattern: /(^|\s)NAN:\s+[\da-fA-F]+(?=\s|$)/,
lookbehind: true
},
{
/*
base prefix floats 0x1.0p3 (8.0) 0b1.010p2 (5.0) 0x1.p1 0b1.11111111p11111...
"The normalized hex form ±0x1.MMMMMMMMMMMMM[pP]±EEEE allows any floating-point number to be specified precisely.
The values of MMMMMMMMMMMMM and EEEE map directly to the mantissa and exponent fields of the binary IEEE 754 representation."
<https://docs.factorcode.org/content/article-syntax-floats.html>
*/
pattern:
/(^|\s)[+-]?0(?:b1\.[01]*|o1\.[0-7]*|d1\.\d*|x1\.[\dA-F]*)p\d+(?=\s|$)/i,
lookbehind: true
}
],
// R/ regexp?\/\\/
regexp: {
pattern:
/(^|\s)R\/\s(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,
lookbehind: true,
alias: 'number',
inside: {
variable: /\\\S/,
keyword: /[+?*\[\]^$(){}.|]/,
operator: {
pattern: /(\/)[idmsr]+(?:-[idmsr]+)?/,
lookbehind: true
}
}
},
boolean: {
pattern: /(^|\s)[tf](?=\s|$)/,
lookbehind: true
},
// SBUF" asd", URL" ://...", P" /etc/"
'custom-string': {
pattern: /(^|\s)[A-Z0-9\-]+"\s(?:\\\S|[^"\\])*"/,
lookbehind: true,
greedy: true,
alias: 'string',
inside: {
number: /\\\S|%\w|\//
}
},
'multiline-string': [
{
// STRING: name \n content \n ; -> CONSTANT: name "content" (symbol)
pattern: /(^|\s)STRING:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*;(?=\s|$)/,
lookbehind: true,
greedy: true,
alias: 'string',
inside: {
number: string_inside.number,
// trailing semicolon on its own line
'semicolon-or-setlocal': {
pattern: /([\r\n][ \t]*);(?=\s|$)/,
lookbehind: true,
alias: 'function'
}
}
},
{
// HEREDOC: marker \n content \n marker ; -> "content" (immediate)
pattern: /(^|\s)HEREDOC:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*\S+(?=\s|$)/,
lookbehind: true,
greedy: true,
alias: 'string',
inside: string_inside
},
{
// [[ string ]], [==[ string]==]
pattern: /(^|\s)\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
lookbehind: true,
greedy: true,
alias: 'string',
inside: string_inside
}
],
'special-using': {
pattern: /(^|\s)USING:(?:\s\S+)*(?=\s+;(?:\s|$))/,
lookbehind: true,
alias: 'function',
inside: {
// this is essentially a regex for vocab names, which i don't want to specify
// but the USING: gets picked up as a vocab name
string: {
pattern: /(\s)[^:\s]+/,
lookbehind: true
}
}
},
/* this description of stack effect literal syntax is not complete and not as specific as theoretically possible
trying to do better is more work and regex-computation-time than it's worth though.
- we'd like to have the "delimiter" parts of the stack effect [ (, --, and ) ] be a different (less-important or comment-like) colour to the stack effect contents
- we'd like if nested stack effects were treated as such rather than just appearing flat (with `inside`)
- we'd like if the following variable name conventions were recognised specifically:
special row variables = ..a b..
type and stack effect annotations end with a colon = ( quot: ( a: ( -- ) -- b ) -- x ), ( x: number -- )
word throws unconditional error = *
any other word-like variable name = a ? q' etc
https://docs.factorcode.org/content/article-effects.html
these are pretty complicated to highlight properly without a real parser, and therefore out of scope
the old pattern, which may be later useful, was: (^|\s)(?:call|execute|eval)?\((?:\s+[^"\r\n\t ]\S*)*?\s+--(?:\s+[^"\n\t ]\S*)*?\s+\)(?=\s|$)
*/
// current solution is not great
'stack-effect-delimiter': [
{
// opening parenthesis
pattern: /(^|\s)(?:call|eval|execute)?\((?=\s)/,
lookbehind: true,
alias: 'operator'
},
{
// middle --
pattern: /(\s)--(?=\s)/,
lookbehind: true,
alias: 'operator'
},
{
// closing parenthesis
pattern: /(\s)\)(?=\s|$)/,
lookbehind: true,
alias: 'operator'
}
],
combinators: {
pattern: null,
lookbehind: true,
alias: 'keyword'
},
'kernel-builtin': {
pattern: null,
lookbehind: true,
alias: 'variable'
},
'sequences-builtin': {
pattern: null,
lookbehind: true,
alias: 'variable'
},
'math-builtin': {
pattern: null,
lookbehind: true,
alias: 'variable'
},
'constructor-word': {
// <array> but not <=>
pattern: /(^|\s)<(?!=+>|-+>)\S+>(?=\s|$)/,
lookbehind: true,
alias: 'keyword'
},
'other-builtin-syntax': {
pattern: null,
lookbehind: true,
alias: 'operator'
},
/*
full list of supported word naming conventions: (the convention appears outside of the [brackets])
set-[x]
change-[x]
with-[x]
new-[x]
>[string]
[base]>
[string]>[number]
+[symbol]+
[boolean-word]?
?[of]
[slot-reader]>>
>>[slot-setter]
[slot-writer]<<
([implementation-detail])
[mutater]!
[variant]*
[prettyprint].
$[help-markup]
<constructors>, SYNTAX:, etc are supported by their own patterns.
`with` and `new` from `kernel` are their own builtins.
see <https://docs.factorcode.org/content/article-conventions.html>
*/
'conventionally-named-word': {
pattern:
/(^|\s)(?!")(?:(?:change|new|set|with)-\S+|\$\S+|>[^>\s]+|[^:>\s]+>|[^>\s]+>[^>\s]+|\+[^+\s]+\+|[^?\s]+\?|\?[^?\s]+|[^>\s]+>>|>>[^>\s]+|[^<\s]+<<|\([^()\s]+\)|[^!\s]+!|[^*\s]\S*\*|[^.\s]\S*\.)(?=\s|$)/,
lookbehind: true,
alias: 'keyword'
},
'colon-syntax': {
pattern: /(^|\s)(?:[A-Z0-9\-]+#?)?:{1,2}\s+(?:;\S+|(?!;)\S+)(?=\s|$)/,
lookbehind: true,
greedy: true,
alias: 'function'
},
'semicolon-or-setlocal': {
pattern: /(\s)(?:;|:>)(?=\s|$)/,
lookbehind: true,
alias: 'function'
},
// do not highlight leading } or trailing X{ at the begin/end of the file as it's invalid syntax
'curly-brace-literal-delimiter': [
{
// opening
pattern: /(^|\s)[a-z]*\{(?=\s)/i,
lookbehind: true,
alias: 'operator'
},
{
// closing
pattern: /(\s)\}(?=\s|$)/,
lookbehind: true,
alias: 'operator'
}
],
// do not highlight leading ] or trailing [ at the begin/end of the file as it's invalid syntax
'quotation-delimiter': [
{
// opening
pattern: /(^|\s)\[(?=\s)/,
lookbehind: true,
alias: 'operator'
},
{
// closing
pattern: /(\s)\](?=\s|$)/,
lookbehind: true,
alias: 'operator'
}
],
'normal-word': {
pattern: /(^|\s)[^"\s]\S*(?=\s|$)/,
lookbehind: true
},
/*
basic first-class string "a"
with escaped double-quote "a\""
escaped backslash "\\"
and general escapes since Factor has so many "\N"
syntax that works in the reference implementation that isn't fully
supported because it's an implementation detail:
"string 1""string 2" -> 2 strings (works anyway)
"string"5 -> string, 5
"string"[ ] -> string, quotation
{ "a"} -> array<string>
the rest of those examples all properly recognise the string, but not
the other object (number, quotation, etc)
this is fine for a regex-only implementation.
*/
string: {
pattern: /"(?:\\\S|[^"\\])*"/,
greedy: true,
inside: string_inside
}
}
var escape = function (str) {
return (str + '').replace(/([.?*+\^$\[\]\\(){}|\-])/g, '\\$1')
}
var arrToWordsRegExp = function (arr) {
return new RegExp('(^|\\s)(?:' + arr.map(escape).join('|') + ')(?=\\s|$)')
}
var builtins = {
'kernel-builtin': [
'or',
'2nipd',
'4drop',
'tuck',
'wrapper',
'nip',
'wrapper?',
'callstack>array',
'die',
'dupd',
'callstack',
'callstack?',
'3dup',
'hashcode',
'pick',
'4nip',
'build',
'>boolean',
'nipd',
'clone',
'5nip',
'eq?',
'?',
'=',
'swapd',
'2over',
'clear',
'2dup',
'get-retainstack',
'not',
'tuple?',
'dup',
'3nipd',
'call',
'-rotd',
'object',
'drop',
'assert=',
'assert?',
'-rot',
'execute',
'boa',
'get-callstack',
'curried?',
'3drop',
'pickd',
'overd',
'over',
'roll',
'3nip',
'swap',
'and',
'2nip',
'rotd',
'throw',
'(clone)',
'hashcode*',
'spin',
'reach',
'4dup',
'equal?',
'get-datastack',
'assert',
'2drop',
'<wrapper>',
'boolean?',
'identity-hashcode',
'identity-tuple?',
'null',
'composed?',
'new',
'5drop',
'rot',
'-roll',
'xor',
'identity-tuple',
'boolean'
],
'other-builtin-syntax': [
// syntax
'=======',
'recursive',
'flushable',
'>>',
'<<<<<<',
'M\\',
'B',
'PRIVATE>',
'\\',
'======',
'final',
'inline',
'delimiter',
'deprecated',
'<PRIVATE',
'>>>>>>',
'<<<<<<<',
'parse-complex',
'malformed-complex',
'read-only',
'>>>>>>>',
'call-next-method',
'<<',
'foldable', // literals
'$',
'$[',
'${'
],
'sequences-builtin': [
'member-eq?',
'mismatch',
'append',
'assert-sequence=',
'longer',
'repetition',
'clone-like',
'3sequence',
'assert-sequence?',
'last-index-from',
'reversed',
'index-from',
'cut*',
'pad-tail',
'join-as',
'remove-eq!',
'concat-as',
'but-last',
'snip',
'nths',
'nth',
'sequence',
'longest',
'slice?',
'<slice>',
'remove-nth',
'tail-slice',
'empty?',
'tail*',
'member?',
'virtual-sequence?',
'set-length',
'drop-prefix',
'iota',
'unclip',
'bounds-error?',
'unclip-last-slice',
'non-negative-integer-expected',
'non-negative-integer-expected?',
'midpoint@',
'longer?',
'?set-nth',
'?first',
'rest-slice',
'prepend-as',
'prepend',
'fourth',
'sift',
'subseq-start',
'new-sequence',
'?last',
'like',
'first4',
'1sequence',
'reverse',
'slice',
'virtual@',
'repetition?',
'set-last',
'index',
'4sequence',
'max-length',
'set-second',
'immutable-sequence',
'first2',
'first3',
'supremum',
'unclip-slice',
'suffix!',
'insert-nth',
'tail',
'3append',
'short',
'suffix',
'concat',
'flip',
'immutable?',
'reverse!',
'2sequence',
'sum',
'delete-all',
'indices',
'snip-slice',
'<iota>',
'check-slice',
'sequence?',
'head',
'append-as',
'halves',
'sequence=',
'collapse-slice',
'?second',
'slice-error?',
'product',
'bounds-check?',
'bounds-check',
'immutable',
'virtual-exemplar',
'harvest',
'remove',
'pad-head',
'last',
'set-fourth',
'cartesian-product',
'remove-eq',
'shorten',
'shorter',
'reversed?',
'shorter?',
'shortest',
'head-slice',
'pop*',
'tail-slice*',
'but-last-slice',
'iota?',
'append!',
'cut-slice',
'new-resizable',
'head-slice*',
'sequence-hashcode',
'pop',
'set-nth',
'?nth',
'second',
'join',
'immutable-sequence?',
'<reversed>',
'3append-as',
'virtual-sequence',
'subseq?',
'remove-nth!',
'length',
'last-index',
'lengthen',
'assert-sequence',
'copy',
'move',
'third',
'first',
'tail?',
'set-first',
'prefix',
'bounds-error',
'<repetition>',
'exchange',
'surround',
'cut',
'min-length',
'set-third',
'push-all',
'head?',
'subseq-start-from',
'delete-slice',
'rest',
'sum-lengths',
'head*',
'infimum',
'remove!',
'glue',
'slice-error',
'subseq',
'push',
'replace-slice',
'subseq-as',
'unclip-last'
],
'math-builtin': [
'number=',
'next-power-of-2',
'?1+',
'fp-special?',
'imaginary-part',
'float>bits',
'number?',
'fp-infinity?',
'bignum?',
'fp-snan?',
'denominator',
'gcd',
'*',
'+',
'fp-bitwise=',
'-',
'u>=',
'/',
'>=',
'bitand',
'power-of-2?',
'log2-expects-positive',
'neg?',
'<',
'log2',
'>',
'integer?',
'number',
'bits>double',
'2/',
'zero?',
'bits>float',
'float?',
'shift',
'ratio?',
'rect>',
'even?',
'ratio',
'fp-sign',
'bitnot',
'>fixnum',
'complex?',
'/i',
'integer>fixnum',
'/f',
'sgn',
'>bignum',
'next-float',
'u<',
'u>',
'mod',
'recip',
'rational',
'>float',
'2^',
'integer',
'fixnum?',
'neg',
'fixnum',
'sq',
'bignum',
'>rect',
'bit?',
'fp-qnan?',
'simple-gcd',
'complex',
'<fp-nan>',
'real',
'>fraction',
'double>bits',
'bitor',
'rem',
'fp-nan-payload',
'real-part',
'log2-expects-positive?',
'prev-float',
'align',
'unordered?',
'float',
'fp-nan?',
'abs',
'bitxor',
'integer>fixnum-strict',
'u<=',
'odd?',
'<=',
'/mod',
'>integer',
'real?',
'rational?',
'numerator'
] // that's all for now
}
Object.keys(builtins).forEach(function (k) {
factor[k].pattern = arrToWordsRegExp(builtins[k])
})
var combinators = [
// kernel
'2bi',
'while',
'2tri',
'bi*',
'4dip',
'both?',
'same?',
'tri@',
'curry',
'prepose',
'3bi',
'?if',
'tri*',
'2keep',
'3keep',
'curried',
'2keepd',
'when',
'2bi*',
'2tri*',
'4keep',
'bi@',
'keepdd',
'do',
'unless*',
'tri-curry',
'if*',
'loop',
'bi-curry*',
'when*',
'2bi@',
'2tri@',
'with',
'2with',
'either?',
'bi',
'until',
'3dip',
'3curry',
'tri-curry*',
'tri-curry@',
'bi-curry',
'keepd',
'compose',
'2dip',
'if',
'3tri',
'unless',
'tuple',
'keep',
'2curry',
'tri',
'most',
'while*',
'dip',
'composed',
'bi-curry@', // sequences
'find-last-from',
'trim-head-slice',
'map-as',
'each-from',
'none?',
'trim-tail',
'partition',
'if-empty',
'accumulate*',
'reject!',
'find-from',
'accumulate-as',
'collector-for-as',
'reject',
'map',
'map-sum',
'accumulate!',
'2each-from',
'follow',
'supremum-by',
'map!',
'unless-empty',
'collector',
'padding',
'reduce-index',
'replicate-as',
'infimum-by',
'trim-tail-slice',
'count',
'find-index',
'filter',
'accumulate*!',
'reject-as',
'map-integers',
'map-find',
'reduce',
'selector',
'interleave',
'2map',
'filter-as',
'binary-reduce',
'map-index-as',
'find',
'produce',
'filter!',
'replicate',
'cartesian-map',
'cartesian-each',
'find-index-from',
'map-find-last',
'3map-as',
'3map',
'find-last',
'selector-as',
'2map-as',
'2map-reduce',
'accumulate',
'each',
'each-index',
'accumulate*-as',
'when-empty',
'all?',
'collector-as',
'push-either',
'new-like',
'collector-for',
'2selector',
'push-if',
'2all?',
'map-reduce',
'3each',
'any?',
'trim-slice',
'2reduce',
'change-nth',
'produce-as',
'2each',
'trim',
'trim-head',
'cartesian-find',
'map-index', // math
'if-zero',
'each-integer',
'unless-zero',
'(find-integer)',
'when-zero',
'find-last-integer',
'(all-integers?)',
'times',
'(each-integer)',
'find-integer',
'all-integers?', // math.combinators
'unless-negative',
'if-positive',
'when-positive',
'when-negative',
'unless-positive',
'if-negative', // combinators
'case',
'2cleave',
'cond>quot',
'case>quot',
'3cleave',
'wrong-values',
'to-fixed-point',
'alist>quot',
'cond',
'cleave',
'call-effect',
'recursive-hashcode',
'spread',
'deep-spread>quot', // combinators.short-circuit
'2||',
'0||',
'n||',
'0&&',
'2&&',
'3||',
'1||',
'1&&',
'n&&',
'3&&', // combinators.smart
'smart-unless*',
'keep-inputs',
'reduce-outputs',
'smart-when*',
'cleave>array',
'smart-with',
'smart-apply',
'smart-if',
'inputs/outputs',
'output>sequence-n',
'map-outputs',
'map-reduce-outputs',
'dropping',
'output>array',
'smart-map-reduce',
'smart-2map-reduce',
'output>array-n',
'nullary',
'input<sequence',
'append-outputs',
'drop-inputs',
'inputs',
'smart-2reduce',
'drop-outputs',
'smart-reduce',
'preserving',
'smart-when',
'outputs',
'append-outputs-as',
'smart-unless',
'smart-if*',
'sum-outputs',
'input<sequence-unsafe',
'output>sequence' // tafn
]
factor.combinators.pattern = arrToWordsRegExp(combinators)
Prism.languages.factor = factor
})(Prism)
}

39
frontend/node_modules/refractor/lang/false.js generated vendored Normal file
View File

@@ -0,0 +1,39 @@
'use strict'
module.exports = $false
$false.displayName = '$false'
$false.aliases = []
function $false(Prism) {
;(function (Prism) {
/**
* Based on the manual by Wouter van Oortmerssen.
*
* @see {@link https://github.com/PrismJS/prism/issues/2801#issue-829717504}
*/
Prism.languages['false'] = {
comment: {
pattern: /\{[^}]*\}/
},
string: {
pattern: /"[^"]*"/,
greedy: true
},
'character-code': {
pattern: /'(?:[^\r]|\r\n?)/,
alias: 'number'
},
'assembler-code': {
pattern: /\d+`/,
alias: 'important'
},
number: /\d+/,
operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
punctuation: /\[|\]/,
variable: /[a-z]/,
'non-standard': {
pattern: /[()<BDO®]/,
alias: 'bold'
}
}
})(Prism)
}

45
frontend/node_modules/refractor/lang/firestore-security-rules.js generated vendored Normal file
View File

@@ -0,0 +1,45 @@
'use strict'
module.exports = firestoreSecurityRules
firestoreSecurityRules.displayName = 'firestoreSecurityRules'
firestoreSecurityRules.aliases = []
function firestoreSecurityRules(Prism) {
Prism.languages['firestore-security-rules'] = Prism.languages.extend(
'clike',
{
comment: /\/\/.*/,
keyword:
/\b(?:allow|function|if|match|null|return|rules_version|service)\b/,
operator: /&&|\|\||[<>!=]=?|[-+*/%]|\b(?:in|is)\b/
}
)
delete Prism.languages['firestore-security-rules']['class-name']
Prism.languages.insertBefore('firestore-security-rules', 'keyword', {
path: {
pattern:
/(^|[\s(),])(?:\/(?:[\w\xA0-\uFFFF]+|\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)))+/,
lookbehind: true,
greedy: true,
inside: {
variable: {
pattern: /\{[\w\xA0-\uFFFF]+(?:=\*\*)?\}|\$\([\w\xA0-\uFFFF.]+\)/,
inside: {
operator: /=/,
keyword: /\*\*/,
punctuation: /[.$(){}]/
}
},
punctuation: /\//
}
},
method: {
// to make the pattern shorter, the actual method names are omitted
pattern: /(\ballow\s+)[a-z]+(?:\s*,\s*[a-z]+)*(?=\s*[:;])/,
lookbehind: true,
alias: 'builtin',
inside: {
punctuation: /,/
}
}
})
}

42
frontend/node_modules/refractor/lang/flow.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
'use strict'
module.exports = flow
flow.displayName = 'flow'
flow.aliases = []
function flow(Prism) {
;(function (Prism) {
Prism.languages.flow = Prism.languages.extend('javascript', {})
Prism.languages.insertBefore('flow', 'keyword', {
type: [
{
pattern:
/\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|any|mixed|null|void)\b/,
alias: 'tag'
}
]
})
Prism.languages.flow['function-variable'].pattern =
/(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i
delete Prism.languages.flow['parameter']
Prism.languages.insertBefore('flow', 'operator', {
'flow-punctuation': {
pattern: /\{\||\|\}/,
alias: 'punctuation'
}
})
if (!Array.isArray(Prism.languages.flow.keyword)) {
Prism.languages.flow.keyword = [Prism.languages.flow.keyword]
}
Prism.languages.flow.keyword.unshift(
{
pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/,
lookbehind: true
},
{
pattern:
/(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/,
lookbehind: true
}
)
})(Prism)
}

45
frontend/node_modules/refractor/lang/fortran.js generated vendored Normal file
View File

@@ -0,0 +1,45 @@
'use strict'
module.exports = fortran
fortran.displayName = 'fortran'
fortran.aliases = []
function fortran(Prism) {
Prism.languages.fortran = {
'quoted-number': {
pattern: /[BOZ](['"])[A-F0-9]+\1/i,
alias: 'number'
},
string: {
pattern:
/(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
inside: {
comment: {
pattern: /(&(?:\r\n?|\n)\s*)!.*/,
lookbehind: true
}
}
},
comment: {
pattern: /!.*/,
greedy: true
},
boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
keyword: [
// Types
/\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i, // END statements
/\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i, // Statements
/\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i, // Others
/\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
],
operator: [
/\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
{
// Use lookbehind to prevent confusion with (/ /)
pattern: /(^|(?!\().)\/(?!\))/,
lookbehind: true
}
],
punctuation: /\(\/|\/\)|[(),;:&]/
}
}

86
frontend/node_modules/refractor/lang/fsharp.js generated vendored Normal file
View File

@@ -0,0 +1,86 @@
'use strict'
module.exports = fsharp
fsharp.displayName = 'fsharp'
fsharp.aliases = []
function fsharp(Prism) {
Prism.languages.fsharp = Prism.languages.extend('clike', {
comment: [
{
pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
lookbehind: true,
greedy: true
},
{
pattern: /(^|[^\\:])\/\/.*/,
lookbehind: true,
greedy: true
}
],
string: {
pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/,
greedy: true
},
'class-name': {
pattern:
/(\b(?:exception|inherit|interface|new|of|type)\s+|\w\s*:\s*|\s:\??>\s*)[.\w]+\b(?:\s*(?:->|\*)\s*[.\w]+\b)*(?!\s*[:.])/,
lookbehind: true,
inside: {
operator: /->|\*/,
punctuation: /\./
}
},
keyword:
/\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/,
number: [
/\b0x[\da-fA-F]+(?:LF|lf|un)?\b/,
/\b0b[01]+(?:uy|y)?\b/,
/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
/\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
],
operator:
/([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
})
Prism.languages.insertBefore('fsharp', 'keyword', {
preprocessor: {
pattern: /(^[\t ]*)#.*/m,
lookbehind: true,
alias: 'property',
inside: {
directive: {
pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/,
lookbehind: true,
alias: 'keyword'
}
}
}
})
Prism.languages.insertBefore('fsharp', 'punctuation', {
'computation-expression': {
pattern: /\b[_a-z]\w*(?=\s*\{)/i,
alias: 'keyword'
}
})
Prism.languages.insertBefore('fsharp', 'string', {
annotation: {
pattern: /\[<.+?>\]/,
greedy: true,
inside: {
punctuation: /^\[<|>\]$/,
'class-name': {
pattern: /^\w+$|(^|;\s*)[A-Z]\w*(?=\()/,
lookbehind: true
},
'annotation-content': {
pattern: /[\s\S]+/,
inside: Prism.languages.fsharp
}
}
},
char: {
pattern:
/'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
greedy: true
}
})
}

129
frontend/node_modules/refractor/lang/ftl.js generated vendored Normal file
View File

@@ -0,0 +1,129 @@
'use strict'
var refractorMarkupTemplating = require('./markup-templating.js')
module.exports = ftl
ftl.displayName = 'ftl'
ftl.aliases = []
function ftl(Prism) {
Prism.register(refractorMarkupTemplating)
;(function (Prism) {
// https://freemarker.apache.org/docs/dgui_template_exp.html
// FTL expression with 4 levels of nesting supported
var FTL_EXPR =
/[^<()"']|\((?:<expr>)*\)|<(?!#--)|<#--(?:[^-]|-(?!->))*-->|"(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'/
.source
for (var i = 0; i < 2; i++) {
FTL_EXPR = FTL_EXPR.replace(/<expr>/g, function () {
return FTL_EXPR
})
}
FTL_EXPR = FTL_EXPR.replace(/<expr>/g, /[^\s\S]/.source)
var ftl = {
comment: /<#--[\s\S]*?-->/,
string: [
{
// raw string
pattern: /\br("|')(?:(?!\1)[^\\]|\\.)*\1/,
greedy: true
},
{
pattern: RegExp(
/("|')(?:(?!\1|\$\{)[^\\]|\\.|\$\{(?:(?!\})(?:<expr>))*\})*\1/.source.replace(
/<expr>/g,
function () {
return FTL_EXPR
}
)
),
greedy: true,
inside: {
interpolation: {
pattern: RegExp(
/((?:^|[^\\])(?:\\\\)*)\$\{(?:(?!\})(?:<expr>))*\}/.source.replace(
/<expr>/g,
function () {
return FTL_EXPR
}
)
),
lookbehind: true,
inside: {
'interpolation-punctuation': {
pattern: /^\$\{|\}$/,
alias: 'punctuation'
},
rest: null
}
}
}
}
],
keyword: /\b(?:as)\b/,
boolean: /\b(?:false|true)\b/,
'builtin-function': {
pattern: /((?:^|[^?])\?\s*)\w+/,
lookbehind: true,
alias: 'function'
},
function: /\b\w+(?=\s*\()/,
number: /\b\d+(?:\.\d+)?\b/,
operator:
/\.\.[<*!]?|->|--|\+\+|&&|\|\||\?{1,2}|[-+*/%!=<>]=?|\b(?:gt|gte|lt|lte)\b/,
punctuation: /[,;.:()[\]{}]/
}
ftl.string[1].inside.interpolation.inside.rest = ftl
Prism.languages.ftl = {
'ftl-comment': {
// the pattern is shortened to be more efficient
pattern: /^<#--[\s\S]*/,
alias: 'comment'
},
'ftl-directive': {
pattern: /^<[\s\S]+>$/,
inside: {
directive: {
pattern: /(^<\/?)[#@][a-z]\w*/i,
lookbehind: true,
alias: 'keyword'
},
punctuation: /^<\/?|\/?>$/,
content: {
pattern: /\s*\S[\s\S]*/,
alias: 'ftl',
inside: ftl
}
}
},
'ftl-interpolation': {
pattern: /^\$\{[\s\S]*\}$/,
inside: {
punctuation: /^\$\{|\}$/,
content: {
pattern: /\s*\S[\s\S]*/,
alias: 'ftl',
inside: ftl
}
}
}
}
Prism.hooks.add('before-tokenize', function (env) {
// eslint-disable-next-line regexp/no-useless-lazy
var pattern = RegExp(
/<#--[\s\S]*?-->|<\/?[#@][a-zA-Z](?:<expr>)*?>|\$\{(?:<expr>)*?\}/.source.replace(
/<expr>/g,
function () {
return FTL_EXPR
}
),
'gi'
)
Prism.languages['markup-templating'].buildPlaceholders(
env,
'ftl',
pattern
)
})
Prism.hooks.add('after-tokenize', function (env) {
Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ftl')
})
})(Prism)
}

57
frontend/node_modules/refractor/lang/gap.js generated vendored Normal file
View File

@@ -0,0 +1,57 @@
'use strict'
module.exports = gap
gap.displayName = 'gap'
gap.aliases = []
function gap(Prism) {
// https://www.gap-system.org/Manuals/doc/ref/chap4.html
// https://www.gap-system.org/Manuals/doc/ref/chap27.html
Prism.languages.gap = {
shell: {
pattern: /^gap>[\s\S]*?(?=^gap>|$(?![\s\S]))/m,
greedy: true,
inside: {
gap: {
pattern: /^(gap>).+(?:(?:\r(?:\n|(?!\n))|\n)>.*)*/,
lookbehind: true,
inside: null // see below
},
punctuation: /^gap>/
}
},
comment: {
pattern: /#.*/,
greedy: true
},
string: {
pattern:
/(^|[^\\'"])(?:'(?:[^\r\n\\']|\\.){1,10}'|"(?:[^\r\n\\"]|\\.)*"(?!")|"""[\s\S]*?""")/,
lookbehind: true,
greedy: true,
inside: {
continuation: {
pattern: /([\r\n])>/,
lookbehind: true,
alias: 'punctuation'
}
}
},
keyword:
/\b(?:Assert|Info|IsBound|QUIT|TryNextMethod|Unbind|and|atomic|break|continue|do|elif|else|end|fi|for|function|if|in|local|mod|not|od|or|quit|readonly|readwrite|rec|repeat|return|then|until|while)\b/,
boolean: /\b(?:false|true)\b/,
function: /\b[a-z_]\w*(?=\s*\()/i,
number: {
pattern:
/(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
lookbehind: true
},
continuation: {
pattern: /([\r\n])>/,
lookbehind: true,
alias: 'punctuation'
},
operator: /->|[-+*/^~=!]|<>|[<>]=?|:=|\.\./,
punctuation: /[()[\]{},;.:]/
}
Prism.languages.gap.shell.inside.gap.inside = Prism.languages.gap
}

23
frontend/node_modules/refractor/lang/gcode.js generated vendored Normal file
View File

@@ -0,0 +1,23 @@
'use strict'
module.exports = gcode
gcode.displayName = 'gcode'
gcode.aliases = []
function gcode(Prism) {
Prism.languages.gcode = {
comment: /;.*|\B\(.*?\)\B/,
string: {
pattern: /"(?:""|[^"])*"/,
greedy: true
},
keyword: /\b[GM]\d+(?:\.\d+)?\b/,
property: /\b[A-Z]/,
checksum: {
pattern: /(\*)\d+/,
lookbehind: true,
alias: 'number'
},
// T0:0:0
punctuation: /[:*]/
}
}

37
frontend/node_modules/refractor/lang/gdscript.js generated vendored Normal file
View File

@@ -0,0 +1,37 @@
'use strict'
module.exports = gdscript
gdscript.displayName = 'gdscript'
gdscript.aliases = []
function gdscript(Prism) {
Prism.languages.gdscript = {
comment: /#.*/,
string: {
pattern:
/@?(?:("|')(?:(?!\1)[^\n\\]|\\[\s\S])*\1(?!"|')|"""(?:[^\\]|\\[\s\S])*?""")/,
greedy: true
},
'class-name': {
// class_name Foo, extends Bar, class InnerClass
// export(int) var baz, export(int, 0) var i
// as Node
// const FOO: int = 9, var bar: bool = true
// func add(reference: Item, amount: int) -> Item:
pattern:
/(^(?:class|class_name|extends)[ \t]+|^export\([ \t]*|\bas[ \t]+|(?:\b(?:const|var)[ \t]|[,(])[ \t]*\w+[ \t]*:[ \t]*|->[ \t]*)[a-zA-Z_]\w*/m,
lookbehind: true
},
keyword:
/\b(?:and|as|assert|break|breakpoint|class|class_name|const|continue|elif|else|enum|export|extends|for|func|if|in|is|master|mastersync|match|not|null|onready|or|pass|preload|puppet|puppetsync|remote|remotesync|return|self|setget|signal|static|tool|var|while|yield)\b/,
function: /\b[a-z_]\w*(?=[ \t]*\()/i,
variable: /\$\w+/,
number: [
/\b0b[01_]+\b|\b0x[\da-fA-F_]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.[\d_]+)(?:e[+-]?[\d_]+)?\b/,
/\b(?:INF|NAN|PI|TAU)\b/
],
constant: /\b[A-Z][A-Z_\d]*\b/,
boolean: /\b(?:false|true)\b/,
operator: /->|:=|&&|\|\||<<|>>|[-+*/%&|!<>=]=?|[~^]/,
punctuation: /[.:,;()[\]{}]/
}
}

37
frontend/node_modules/refractor/lang/gedcom.js generated vendored Normal file
View File

@@ -0,0 +1,37 @@
'use strict'
module.exports = gedcom
gedcom.displayName = 'gedcom'
gedcom.aliases = []
function gedcom(Prism) {
Prism.languages.gedcom = {
'line-value': {
// Preceded by level, optional pointer, and tag
pattern:
/(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?\w+ ).+/m,
lookbehind: true,
inside: {
pointer: {
pattern: /^@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@$/,
alias: 'variable'
}
}
},
tag: {
// Preceded by level and optional pointer
pattern:
/(^[\t ]*\d+ +(?:@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@ +)?)\w+/m,
lookbehind: true,
alias: 'string'
},
level: {
pattern: /(^[\t ]*)\d+/m,
lookbehind: true,
alias: 'number'
},
pointer: {
pattern: /@\w[\w!"$%&'()*+,\-./:;<=>?[\\\]^`{|}~\x80-\xfe #]*@/,
alias: 'variable'
}
}
}

92
frontend/node_modules/refractor/lang/gherkin.js generated vendored Normal file
View File

@@ -0,0 +1,92 @@
'use strict'
module.exports = gherkin
gherkin.displayName = 'gherkin'
gherkin.aliases = []
function gherkin(Prism) {
;(function (Prism) {
var tableRow = /(?:\r?\n|\r)[ \t]*\|.+\|(?:(?!\|).)*/.source
Prism.languages.gherkin = {
pystring: {
pattern: /("""|''')[\s\S]+?\1/,
alias: 'string'
},
comment: {
pattern: /(^[ \t]*)#.*/m,
lookbehind: true
},
tag: {
pattern: /(^[ \t]*)@\S*/m,
lookbehind: true
},
feature: {
pattern:
/((?:^|\r?\n|\r)[ \t]*)(?:Ability|Ahoy matey!|Arwedd|Aspekt|Besigheid Behoefte|Business Need|Caracteristica|Característica|Egenskab|Egenskap|Eiginleiki|Feature|Fīča|Fitur|Fonctionnalité|Fonksyonalite|Funcionalidade|Funcionalitat|Functionalitate|Funcţionalitate|Funcționalitate|Functionaliteit|Fungsi|Funkcia|Funkcija|Funkcionalitāte|Funkcionalnost|Funkcja|Funksie|Funktionalität|Funktionalitéit|Funzionalità|Hwaet|Hwæt|Jellemző|Karakteristik|Lastnost|Mak|Mogucnost|laH|Mogućnost|Moznosti|Možnosti|OH HAI|Omadus|Ominaisuus|Osobina|Özellik|Potrzeba biznesowa|perbogh|poQbogh malja'|Požadavek|Požiadavka|Pretty much|Qap|Qu'meH 'ut|Savybė|Tính năng|Trajto|Vermoë|Vlastnosť|Właściwość|Značilnost|Δυνατότητα|Λειτουργία|Могућност|Мөмкинлек|Особина|Свойство|Үзенчәлеклелек|Функционал|Функционалност|Функция|Функціонал|תכונה|خاصية|خصوصیت|صلاحیت|کاروبار کی ضرورت|وِیژگی|रूप लेख|ਖਾਸੀਅਤ|ਨਕਸ਼ ਨੁਹਾਰ|ਮੁਹਾਂਦਰਾ|గుణము|ಹೆಚ್ಚಳ|ความต้องการทางธุรกิจ|ความสามารถ|โครงหลัก|기능|フィーチャ|功能|機能):(?:[^:\r\n]+(?:\r?\n|\r|$))*/,
lookbehind: true,
inside: {
important: {
pattern: /(:)[^\r\n]+/,
lookbehind: true
},
keyword: /[^:\r\n]+:/
}
},
scenario: {
pattern:
/(^[ \t]*)(?:Abstract Scenario|Abstrakt Scenario|Achtergrond|Aer|Ær|Agtergrond|All y'all|Antecedentes|Antecedents|Atburðarás|Atburðarásir|Awww, look mate|B4|Background|Baggrund|Bakgrund|Bakgrunn|Bakgrunnur|Beispiele|Beispiller|Bối cảnh|Cefndir|Cenario|Cenário|Cenario de Fundo|Cenário de Fundo|Cenarios|Cenários|Contesto|Context|Contexte|Contexto|Conto|Contoh|Contone|Dæmi|Dasar|Dead men tell no tales|Delineacao do Cenario|Delineação do Cenário|Dis is what went down|Dữ liệu|Dyagram Senaryo|Dyagram senaryo|Egzanp|Ejemplos|Eksempler|Ekzemploj|Enghreifftiau|Esbozo do escenario|Escenari|Escenario|Esempi|Esquema de l'escenari|Esquema del escenario|Esquema do Cenario|Esquema do Cenário|EXAMPLZ|Examples|Exempel|Exemple|Exemples|Exemplos|First off|Fono|Forgatókönyv|Forgatókönyv vázlat|Fundo|Geçmiş|Grundlage|Hannergrond|ghantoH|Háttér|Heave to|Istorik|Juhtumid|Keadaan|Khung kịch bản|Khung tình huống|Kịch bản|Koncept|Konsep skenario|Kontèks|Kontekst|Kontekstas|Konteksts|Kontext|Konturo de la scenaro|Latar Belakang|lut chovnatlh|lut|lutmey|Lýsing Atburðarásar|Lýsing Dæma|MISHUN SRSLY|MISHUN|Menggariskan Senario|mo'|Náčrt Scenára|Náčrt Scénáře|Náčrt Scenáru|Oris scenarija|Örnekler|Osnova|Osnova Scenára|Osnova scénáře|Osnutek|Ozadje|Paraugs|Pavyzdžiai|Példák|Piemēri|Plan du scénario|Plan du Scénario|Plan Senaryo|Plan senaryo|Plang vum Szenario|Pozadí|Pozadie|Pozadina|Príklady|Příklady|Primer|Primeri|Primjeri|Przykłady|Raamstsenaarium|Reckon it's like|Rerefons|Scenár|Scénář|Scenarie|Scenarij|Scenarijai|Scenarijaus šablonas|Scenariji|Scenārijs|Scenārijs pēc parauga|Scenarijus|Scenario|Scénario|Scenario Amlinellol|Scenario Outline|Scenario Template|Scenariomal|Scenariomall|Scenarios|Scenariu|Scenariusz|Scenaro|Schema dello scenario|Se ðe|Se the|Se þe|Senario|Senaryo Deskripsyon|Senaryo deskripsyon|Senaryo|Senaryo taslağı|Shiver me timbers|Situācija|Situai|Situasie Uiteensetting|Situasie|Skenario konsep|Skenario|Skica|Structura scenariu|Structură scenariu|Struktura scenarija|Stsenaarium|Swa hwaer swa|Swa|Swa hwær swa|Szablon scenariusza|Szenario|Szenariogrundriss|Tapaukset|Tapaus|Tapausaihio|Taust|Tausta|Template Keadaan|Template Senario|Template Situai|The thing of it is|Tình huống|Variantai|Voorbeelde|Voorbeelden|Wharrimean is|Yo-ho-ho|You'll wanna|Założenia|Παραδείγματα|Περιγραφή Σεναρίου|Σενάρια|Σενάριο|Υπόβαθρο|Кереш|Контекст|Концепт|Мисаллар|Мисоллар|Основа|Передумова|Позадина|Предистория|Предыстория|Приклади|Пример|Примери|Примеры|Рамка на сценарий|Скица|Структура сценарија|Структура сценария|Структура сценарію|Сценарий|Сценарий структураси|Сценарийның төзелеше|Сценарији|Сценарио|Сценарій|Тарих|Үрнәкләр|דוגמאות|רקע|תבנית תרחיש|תרחיש|الخلفية|الگوی سناریو|امثلة|پس منظر|زمینه|سناریو|سيناريو|سيناريو مخطط|مثالیں|منظر نامے کا خاکہ|منظرنامہ|نمونه ها|उदाहरण|परिदृश्य|परिदृश्य रूपरेखा|पृष्ठभूमि|ਉਦਾਹਰਨਾਂ|ਪਟਕਥਾ|ਪਟਕਥਾ ਢਾਂਚਾ|ਪਟਕਥਾ ਰੂਪ ਰੇਖਾ|ਪਿਛੋਕੜ|ఉదాహరణలు|కథనం|నేపథ్యం|సన్నివేశం|ಉದಾಹರಣೆಗಳು|ಕಥಾಸಾರಾಂಶ|ವಿವರಣೆ|ಹಿನ್ನೆಲೆ|โครงสร้างของเหตุการณ์|ชุดของตัวอย่าง|ชุดของเหตุการณ์|แนวคิด|สรุปเหตุการณ์|เหตุการณ์|배경|시나리오|시나리오 개요|예|サンプル|シナリオ|シナリオアウトライン|シナリオテンプレ|シナリオテンプレート|テンプレ|例|例子|剧本|剧本大纲|劇本|劇本大綱|场景|场景大纲|場景|場景大綱|背景):[^:\r\n]*/m,
lookbehind: true,
inside: {
important: {
pattern: /(:)[^\r\n]*/,
lookbehind: true
},
keyword: /[^:\r\n]+:/
}
},
'table-body': {
// Look-behind is used to skip the table head, which has the same format as any table row
pattern: RegExp('(' + tableRow + ')(?:' + tableRow + ')+'),
lookbehind: true,
inside: {
outline: {
pattern: /<[^>]+>/,
alias: 'variable'
},
td: {
pattern: /\s*[^\s|][^|]*/,
alias: 'string'
},
punctuation: /\|/
}
},
'table-head': {
pattern: RegExp(tableRow),
inside: {
th: {
pattern: /\s*[^\s|][^|]*/,
alias: 'variable'
},
punctuation: /\|/
}
},
atrule: {
pattern:
/(^[ \t]+)(?:'a|'ach|'ej|7|a|A také|A taktiež|A tiež|A zároveň|Aber|Ac|Adott|Akkor|Ak|Aleshores|Ale|Ali|Allora|Alors|Als|Ama|Amennyiben|Amikor|Ampak|an|AN|Ananging|And y'all|And|Angenommen|Anrhegedig a|An|Apabila|Atès|Atesa|Atunci|Avast!|Aye|A|awer|Bagi|Banjur|Bet|Biết|Blimey!|Buh|But at the end of the day I reckon|But y'all|But|BUT|Cal|Când|Cand|Cando|Ce|Cuando|Če|Ða ðe|Ða|Dadas|Dada|Dados|Dado|DaH ghu' bejlu'|dann|Dann|Dano|Dan|Dar|Dat fiind|Data|Date fiind|Date|Dati fiind|Dati|Daţi fiind|Dați fiind|DEN|Dato|De|Den youse gotta|Dengan|Diberi|Diyelim ki|Donada|Donat|Donitaĵo|Do|Dun|Duota|Ðurh|Eeldades|Ef|Eğer ki|Entao|Então|Entón|E|En|Entonces|Epi|És|Etant donnée|Etant donné|Et|Étant données|Étant donnée|Étant donné|Etant données|Etant donnés|Étant donnés|Fakat|Gangway!|Gdy|Gegeben seien|Gegeben sei|Gegeven|Gegewe|ghu' noblu'|Gitt|Given y'all|Given|Givet|Givun|Ha|Cho|I CAN HAZ|In|Ir|It's just unbelievable|I|Ja|Jeśli|Jeżeli|Kad|Kada|Kadar|Kai|Kaj|Když|Keď|Kemudian|Ketika|Khi|Kiedy|Ko|Kuid|Kui|Kun|Lan|latlh|Le sa a|Let go and haul|Le|Lè sa a|Lè|Logo|Lorsqu'<|Lorsque|mä|Maar|Mais|Mając|Ma|Majd|Maka|Manawa|Mas|Men|Menawa|Mutta|Nalika|Nalikaning|Nanging|Når|När|Nato|Nhưng|Niin|Njuk|O zaman|Och|Og|Oletetaan|Ond|Onda|Oraz|Pak|Pero|Però|Podano|Pokiaľ|Pokud|Potem|Potom|Privzeto|Pryd|Quan|Quand|Quando|qaSDI'|Så|Sed|Se|Siis|Sipoze ke|Sipoze Ke|Sipoze|Si|Şi|Și|Soit|Stel|Tada|Tad|Takrat|Tak|Tapi|Ter|Tetapi|Tha the|Tha|Then y'all|Then|Thì|Thurh|Toda|Too right|Un|Und|ugeholl|Và|vaj|Vendar|Ve|wann|Wanneer|WEN|Wenn|When y'all|When|Wtedy|Wun|Y'know|Yeah nah|Yna|Youse know like when|Youse know when youse got|Y|Za predpokladu|Za předpokladu|Zadan|Zadani|Zadano|Zadate|Zadato|Zakładając|Zaradi|Zatati|Þa þe|Þa|Þá|Þegar|Þurh|Αλλά|Δεδομένου|Και|Όταν|Τότε|А також|Агар|Але|Али|Аммо|А|Әгәр|Әйтик|Әмма|Бирок|Ва|Вә|Дадено|Дано|Допустим|Если|Задате|Задати|Задато|И|І|К тому же|Када|Кад|Когато|Когда|Коли|Ләкин|Лекин|Нәтиҗәдә|Нехай|Но|Онда|Припустимо, що|Припустимо|Пусть|Также|Та|Тогда|Тоді|То|Унда|Һәм|Якщо|אבל|אזי|אז|בהינתן|וגם|כאשר|آنگاه|اذاً|اگر|اما|اور|با فرض|بالفرض|بفرض|پھر|تب|ثم|جب|عندما|فرض کیا|لكن|لیکن|متى|هنگامی|و|अगर|और|कदा|किन्तु|चूंकि|जब|तथा|तदा|तब|परन्तु|पर|यदि|ਅਤੇ|ਜਦੋਂ|ਜਿਵੇਂ ਕਿ|ਜੇਕਰ|ਤਦ|ਪਰ|అప్పుడు|ఈ పరిస్థితిలో|కాని|చెప్పబడినది|మరియు|ಆದರೆ|ನಂತರ|ನೀಡಿದ|ಮತ್ತು|ಸ್ಥಿತಿಯನ್ನು|กำหนดให้|ดังนั้น|แต่|เมื่อ|และ|그러면<|그리고<|단<|만약<|만일<|먼저<|조건<|하지만<|かつ<|しかし<|ただし<|ならば<|もし<|並且<|但し<|但是<|假如<|假定<|假設<|假设<|前提<|同时<|同時<|并且<|当<|當<|而且<|那么<|那麼<)(?=[ \t])/m,
lookbehind: true
},
string: {
pattern: /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/,
inside: {
outline: {
pattern: /<[^>]+>/,
alias: 'variable'
}
}
},
outline: {
pattern: /<[^>]+>/,
alias: 'variable'
}
}
})(Prism)
}

70
frontend/node_modules/refractor/lang/git.js generated vendored Normal file
View File

@@ -0,0 +1,70 @@
'use strict'
module.exports = git
git.displayName = 'git'
git.aliases = []
function git(Prism) {
Prism.languages.git = {
/*
* A simple one line comment like in a git status command
* For instance:
* $ git status
* # On branch infinite-scroll
* # Your branch and 'origin/sharedBranches/frontendTeam/infinite-scroll' have diverged,
* # and have 1 and 2 different commits each, respectively.
* nothing to commit (working directory clean)
*/
comment: /^#.*/m,
/*
* Regexp to match the changed lines in a git diff output. Check the example below.
*/
deleted: /^[-–].*/m,
inserted: /^\+.*/m,
/*
* a string (double and simple quote)
*/
string: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
/*
* a git command. It starts with a random prompt finishing by a $, then "git" then some other parameters
* For instance:
* $ git add file.txt
*/
command: {
pattern: /^.*\$ git .*$/m,
inside: {
/*
* A git command can contain a parameter starting by a single or a double dash followed by a string
* For instance:
* $ git diff --cached
* $ git log -p
*/
parameter: /\s--?\w+/
}
},
/*
* Coordinates displayed in a git diff command
* For instance:
* $ git diff
* diff --git file.txt file.txt
* index 6214953..1d54a52 100644
* --- file.txt
* +++ file.txt
* @@ -1 +1,2 @@
* -Here's my tetx file
* +Here's my text file
* +And this is the second line
*/
coord: /^@@.*@@$/m,
/*
* Match a "commit [SHA1]" line in a git log output.
* For instance:
* $ git log
* commit a11a14ef7e26f2ca62d4b35eac455ce636d0dc09
* Author: lgiraudel
* Date: Mon Feb 17 11:18:34 2014 +0100
*
* Add of a new line
*/
'commit-sha1': /^commit \w{40}$/m
}
}

12
frontend/node_modules/refractor/lang/glsl.js generated vendored Normal file
View File

@@ -0,0 +1,12 @@
'use strict'
var refractorC = require('./c.js')
module.exports = glsl
glsl.displayName = 'glsl'
glsl.aliases = []
function glsl(Prism) {
Prism.register(refractorC)
Prism.languages.glsl = Prism.languages.extend('c', {
keyword:
/\b(?:active|asm|atomic_uint|attribute|[ibdu]?vec[234]|bool|break|buffer|case|cast|centroid|class|coherent|common|const|continue|d?mat[234](?:x[234])?|default|discard|do|double|else|enum|extern|external|false|filter|fixed|flat|float|for|fvec[234]|goto|half|highp|hvec[234]|[iu]?sampler2DMS(?:Array)?|[iu]?sampler2DRect|[iu]?samplerBuffer|[iu]?samplerCube|[iu]?samplerCubeArray|[iu]?sampler[123]D|[iu]?sampler[12]DArray|[iu]?image2DMS(?:Array)?|[iu]?image2DRect|[iu]?imageBuffer|[iu]?imageCube|[iu]?imageCubeArray|[iu]?image[123]D|[iu]?image[12]DArray|if|in|inline|inout|input|int|interface|invariant|layout|long|lowp|mediump|namespace|noinline|noperspective|out|output|partition|patch|precise|precision|public|readonly|resource|restrict|return|sample|sampler[12]DArrayShadow|sampler[12]DShadow|sampler2DRectShadow|sampler3DRect|samplerCubeArrayShadow|samplerCubeShadow|shared|short|sizeof|smooth|static|struct|subroutine|superp|switch|template|this|true|typedef|uint|uniform|union|unsigned|using|varying|void|volatile|while|writeonly)\b/
})
}

20
frontend/node_modules/refractor/lang/gml.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

57
frontend/node_modules/refractor/lang/gn.js generated vendored Normal file
View File

@@ -0,0 +1,57 @@
'use strict'
module.exports = gn
gn.displayName = 'gn'
gn.aliases = ['gni']
function gn(Prism) {
// https://gn.googlesource.com/gn/+/refs/heads/main/docs/reference.md#grammar
Prism.languages.gn = {
comment: {
pattern: /#.*/,
greedy: true
},
'string-literal': {
pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/,
lookbehind: true,
greedy: true,
inside: {
interpolation: {
pattern:
/((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/,
lookbehind: true,
inside: {
number: /^\$0x[\s\S]{2}$/,
variable: /^\$\w+$/,
'interpolation-punctuation': {
pattern: /^\$\{|\}$/,
alias: 'punctuation'
},
expression: {
pattern: /[\s\S]+/,
inside: null // see below
}
}
},
string: /[\s\S]+/
}
},
keyword: /\b(?:else|if)\b/,
boolean: /\b(?:false|true)\b/,
'builtin-function': {
// a few functions get special highlighting to improve readability
pattern:
/\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i,
alias: 'keyword'
},
function: /\b[a-z_]\w*(?=\s*\()/i,
constant:
/\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/,
number: /-?\b\d+\b/,
operator: /[-+!=<>]=?|&&|\|\|/,
punctuation: /[(){}[\],.]/
}
Prism.languages.gn['string-literal'].inside['interpolation'].inside[
'expression'
].inside = Prism.languages.gn
Prism.languages.gni = Prism.languages.gn
}

30
frontend/node_modules/refractor/lang/go-module.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
'use strict'
module.exports = goModule
goModule.displayName = 'goModule'
goModule.aliases = []
function goModule(Prism) {
// https://go.dev/ref/mod#go-mod-file-module
Prism.languages['go-mod'] = Prism.languages['go-module'] = {
comment: {
pattern: /\/\/.*/,
greedy: true
},
version: {
pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,
lookbehind: true,
alias: 'number'
},
'go-version': {
pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,
lookbehind: true,
alias: 'number'
},
keyword: {
pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,
lookbehind: true
},
operator: /=>/,
punctuation: /[()[\],]/
}
}

34
frontend/node_modules/refractor/lang/go.js generated vendored Normal file
View File

@@ -0,0 +1,34 @@
'use strict'
module.exports = go
go.displayName = 'go'
go.aliases = []
function go(Prism) {
Prism.languages.go = Prism.languages.extend('clike', {
string: {
pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
lookbehind: true,
greedy: true
},
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(?:_|false|iota|nil|true)\b/,
number: [
// binary and octal integers
/\b0(?:b[01_]+|o[0-7_]+)i?\b/i, // hexadecimal integers and floats
/\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i, // decimal integers and floats
/(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
],
operator:
/[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
builtin:
/\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
})
Prism.languages.insertBefore('go', 'string', {
char: {
pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
greedy: true
}
})
delete Prism.languages.go['class-name']
}

209
frontend/node_modules/refractor/lang/graphql.js generated vendored Normal file
View File

@@ -0,0 +1,209 @@
'use strict'
module.exports = graphql
graphql.displayName = 'graphql'
graphql.aliases = []
function graphql(Prism) {
Prism.languages.graphql = {
comment: /#.*/,
description: {
pattern:
/(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
greedy: true,
alias: 'string',
inside: {
'language-markdown': {
pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
lookbehind: true,
inside: Prism.languages.markdown
}
}
},
string: {
pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
greedy: true
},
number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
boolean: /\b(?:false|true)\b/,
variable: /\$[a-z_]\w*/i,
directive: {
pattern: /@[a-z_]\w*/i,
alias: 'function'
},
'attr-name': {
pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
greedy: true
},
'atom-input': {
pattern: /\b[A-Z]\w*Input\b/,
alias: 'class-name'
},
scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
constant: /\b[A-Z][A-Z_\d]*\b/,
'class-name': {
pattern:
/(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
lookbehind: true
},
fragment: {
pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
lookbehind: true,
alias: 'function'
},
'definition-mutation': {
pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
lookbehind: true,
alias: 'function'
},
'definition-query': {
pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
lookbehind: true,
alias: 'function'
},
keyword:
/\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
operator: /[!=|&]|\.{3}/,
'property-query': /\w+(?=\s*\()/,
object: /\w+(?=\s*\{)/,
punctuation: /[!(){}\[\]:=,]/,
property: /\w+/
}
Prism.hooks.add('after-tokenize', function afterTokenizeGraphql(env) {
if (env.language !== 'graphql') {
return
}
/**
* get the graphql token stream that we want to customize
*
* @typedef {InstanceType<import("./prism-core")["Token"]>} Token
* @type {Token[]}
*/
var validTokens = env.tokens.filter(function (token) {
return (
typeof token !== 'string' &&
token.type !== 'comment' &&
token.type !== 'scalar'
)
})
var currentIndex = 0
/**
* Returns whether the token relative to the current index has the given type.
*
* @param {number} offset
* @returns {Token | undefined}
*/
function getToken(offset) {
return validTokens[currentIndex + offset]
}
/**
* Returns whether the token relative to the current index has the given type.
*
* @param {readonly string[]} types
* @param {number} [offset=0]
* @returns {boolean}
*/
function isTokenType(types, offset) {
offset = offset || 0
for (var i = 0; i < types.length; i++) {
var token = getToken(i + offset)
if (!token || token.type !== types[i]) {
return false
}
}
return true
}
/**
* Returns the index of the closing bracket to an opening bracket.
*
* It is assumed that `token[currentIndex - 1]` is an opening bracket.
*
* If no closing bracket could be found, `-1` will be returned.
*
* @param {RegExp} open
* @param {RegExp} close
* @returns {number}
*/
function findClosingBracket(open, close) {
var stackHeight = 1
for (var i = currentIndex; i < validTokens.length; i++) {
var token = validTokens[i]
var content = token.content
if (token.type === 'punctuation' && typeof content === 'string') {
if (open.test(content)) {
stackHeight++
} else if (close.test(content)) {
stackHeight--
if (stackHeight === 0) {
return i
}
}
}
}
return -1
}
/**
* Adds an alias to the given token.
*
* @param {Token} token
* @param {string} alias
* @returns {void}
*/
function addAlias(token, alias) {
var aliases = token.alias
if (!aliases) {
token.alias = aliases = []
} else if (!Array.isArray(aliases)) {
token.alias = aliases = [aliases]
}
aliases.push(alias)
}
for (; currentIndex < validTokens.length; ) {
var startToken = validTokens[currentIndex++] // add special aliases for mutation tokens
if (startToken.type === 'keyword' && startToken.content === 'mutation') {
// any array of the names of all input variables (if any)
var inputVariables = []
if (
isTokenType(['definition-mutation', 'punctuation']) &&
getToken(1).content === '('
) {
// definition
currentIndex += 2 // skip 'definition-mutation' and 'punctuation'
var definitionEnd = findClosingBracket(/^\($/, /^\)$/)
if (definitionEnd === -1) {
continue
} // find all input variables
for (; currentIndex < definitionEnd; currentIndex++) {
var t = getToken(0)
if (t.type === 'variable') {
addAlias(t, 'variable-input')
inputVariables.push(t.content)
}
}
currentIndex = definitionEnd + 1
}
if (
isTokenType(['punctuation', 'property-query']) &&
getToken(0).content === '{'
) {
currentIndex++ // skip opening bracket
addAlias(getToken(0), 'property-mutation')
if (inputVariables.length > 0) {
var mutationEnd = findClosingBracket(/^\{$/, /^\}$/)
if (mutationEnd === -1) {
continue
} // give references to input variables a special alias
for (var i = currentIndex; i < mutationEnd; i++) {
var varToken = validTokens[i]
if (
varToken.type === 'variable' &&
inputVariables.indexOf(varToken.content) >= 0
) {
addAlias(varToken, 'variable-input')
}
}
}
}
}
}
})
}

71
frontend/node_modules/refractor/lang/groovy.js generated vendored Normal file
View File

@@ -0,0 +1,71 @@
'use strict'
module.exports = groovy
groovy.displayName = 'groovy'
groovy.aliases = []
function groovy(Prism) {
Prism.languages.groovy = Prism.languages.extend('clike', {
string: [
{
// https://groovy-lang.org/syntax.html#_dollar_slashy_string
pattern:
/("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
greedy: true
},
{
// TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
// simple division (see JS regex), so find a fix maybe?
pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
greedy: true
}
],
keyword:
/\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|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: true
},
punctuation: /\.+|[{}[\];(),:$]/
})
Prism.languages.insertBefore('groovy', 'string', {
shebang: {
pattern: /#!.+/,
alias: 'comment'
}
})
Prism.languages.insertBefore('groovy', 'punctuation', {
'spock-block': /\b(?:and|cleanup|expect|given|setup|then|when|where):/
})
Prism.languages.insertBefore('groovy', 'function', {
annotation: {
pattern: /(^|[^.])@\w+/,
lookbehind: true,
alias: 'punctuation'
}
}) // Handle string interpolation
Prism.hooks.add('wrap', function (env) {
if (env.language === 'groovy' && env.type === 'string') {
var delimiter = env.content.value[0]
if (delimiter != "'") {
var pattern = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/
if (delimiter === '$') {
pattern = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/
} // To prevent double HTML-encoding we have to decode env.content first
env.content.value = env.content.value
.replace(/&lt;/g, '<')
.replace(/&amp;/g, '&')
env.content = Prism.highlight(env.content.value, {
expression: {
pattern: pattern,
lookbehind: true,
inside: Prism.languages.groovy
}
})
env.classes.push(delimiter === '/' ? 'regex' : 'gstring')
}
}
})
}

165
frontend/node_modules/refractor/lang/haml.js generated vendored Normal file
View File

@@ -0,0 +1,165 @@
'use strict'
var refractorRuby = require('./ruby.js')
module.exports = haml
haml.displayName = 'haml'
haml.aliases = []
function haml(Prism) {
Prism.register(refractorRuby)
/* TODO
Handle multiline code after tag
%foo= some |
multiline |
code |
*/
;(function (Prism) {
Prism.languages.haml = {
// Multiline stuff should appear before the rest
'multiline-comment': {
pattern:
/((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
lookbehind: true,
alias: 'comment'
},
'multiline-code': [
{
pattern:
/((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
lookbehind: true,
inside: Prism.languages.ruby
},
{
pattern:
/((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
lookbehind: true,
inside: Prism.languages.ruby
}
],
// See at the end of the file for known filters
filter: {
pattern:
/((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
lookbehind: true,
inside: {
'filter-name': {
pattern: /^:[\w-]+/,
alias: 'symbol'
}
}
},
markup: {
pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
lookbehind: true,
inside: Prism.languages.markup
},
doctype: {
pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
lookbehind: true
},
tag: {
// Allows for one nested group of braces
pattern:
/((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
lookbehind: true,
inside: {
attributes: [
{
// Lookbehind tries to prevent interpolations from breaking it all
// Allows for one nested group of braces
pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
lookbehind: true,
inside: Prism.languages.ruby
},
{
pattern: /\([^)]+\)/,
inside: {
'attr-value': {
pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
lookbehind: true
},
'attr-name': /[\w:-]+(?=\s*!?=|\s*[,)])/,
punctuation: /[=(),]/
}
},
{
pattern: /\[[^\]]+\]/,
inside: Prism.languages.ruby
}
],
punctuation: /[<>]/
}
},
code: {
pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
lookbehind: true,
inside: Prism.languages.ruby
},
// Interpolations in plain text
interpolation: {
pattern: /#\{[^}]+\}/,
inside: {
delimiter: {
pattern: /^#\{|\}$/,
alias: 'punctuation'
},
ruby: {
pattern: /[\s\S]+/,
inside: Prism.languages.ruby
}
}
},
punctuation: {
pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
lookbehind: true
}
}
var filter_pattern =
'((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+' // Non exhaustive list of available filters and associated languages
var filters = [
'css',
{
filter: 'coffee',
language: 'coffeescript'
},
'erb',
'javascript',
'less',
'markdown',
'ruby',
'scss',
'textile'
]
var all_filters = {}
for (var i = 0, l = filters.length; i < l; i++) {
var filter = filters[i]
filter =
typeof filter === 'string'
? {
filter: filter,
language: filter
}
: filter
if (Prism.languages[filter.language]) {
all_filters['filter-' + filter.filter] = {
pattern: RegExp(
filter_pattern.replace('{{filter_name}}', function () {
return filter.filter
})
),
lookbehind: true,
inside: {
'filter-name': {
pattern: /^:[\w-]+/,
alias: 'symbol'
},
text: {
pattern: /[\s\S]+/,
alias: [filter.language, 'language-' + filter.language],
inside: Prism.languages[filter.language]
}
}
}
}
}
Prism.languages.insertBefore('haml', 'filter', all_filters)
})(Prism)
}

49
frontend/node_modules/refractor/lang/handlebars.js generated vendored Normal file
View File

@@ -0,0 +1,49 @@
'use strict'
var refractorMarkupTemplating = require('./markup-templating.js')
module.exports = handlebars
handlebars.displayName = 'handlebars'
handlebars.aliases = ['hbs']
function handlebars(Prism) {
Prism.register(refractorMarkupTemplating)
;(function (Prism) {
Prism.languages.handlebars = {
comment: /\{\{![\s\S]*?\}\}/,
delimiter: {
pattern: /^\{\{\{?|\}\}\}?$/,
alias: 'punctuation'
},
string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
boolean: /\b(?:false|true)\b/,
block: {
pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
lookbehind: true,
alias: 'keyword'
},
brackets: {
pattern: /\[[^\]]+\]/,
inside: {
punctuation: /\[|\]/,
variable: /[\s\S]+/
}
},
punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
}
Prism.hooks.add('before-tokenize', function (env) {
var handlebarsPattern = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g
Prism.languages['markup-templating'].buildPlaceholders(
env,
'handlebars',
handlebarsPattern
)
})
Prism.hooks.add('after-tokenize', function (env) {
Prism.languages['markup-templating'].tokenizePlaceholders(
env,
'handlebars'
)
})
Prism.languages.hbs = Prism.languages.handlebars
})(Prism)
}

76
frontend/node_modules/refractor/lang/haskell.js generated vendored Normal file
View File

@@ -0,0 +1,76 @@
'use strict'
module.exports = haskell
haskell.displayName = 'haskell'
haskell.aliases = ['hs']
function haskell(Prism) {
Prism.languages.haskell = {
comment: {
pattern:
/(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
lookbehind: true
},
char: {
pattern:
/'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
alias: 'string'
},
string: {
pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
greedy: true
},
keyword:
/\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
'import-statement': {
// The imported or hidden names are not included in this import
// statement. This is because we want to highlight those exactly like
// we do for the names in the program.
pattern:
/(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
lookbehind: true,
inside: {
keyword: /\b(?:as|hiding|import|qualified)\b/,
punctuation: /\./
}
},
// These are builtin variables only. Constructors are highlighted later as a constant.
builtin:
/\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
// decimal integers and floating point numbers | octal integers | hexadecimal integers
number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
operator: [
{
// infix operator
pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
greedy: true
},
{
// function composition
pattern: /(\s)\.(?=\s)/,
lookbehind: true
}, // Most of this is needed because of the meaning of a single '.'.
// If it stands alone freely, it is the function composition.
// It may also be a separator between a module name and an identifier => no
// operator. If it comes together with other special characters it is an
// operator too.
//
// This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
/[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
],
// In Haskell, nearly everything is a variable, do not highlight these.
hvariable: {
pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
inside: {
punctuation: /\./
}
},
constant: {
pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
inside: {
punctuation: /\./
}
},
punctuation: /[{}[\];(),.:]/
}
Prism.languages.hs = Prism.languages.haskell
}

83
frontend/node_modules/refractor/lang/haxe.js generated vendored Normal file
View File

@@ -0,0 +1,83 @@
'use strict'
module.exports = haxe
haxe.displayName = 'haxe'
haxe.aliases = []
function haxe(Prism) {
Prism.languages.haxe = Prism.languages.extend('clike', {
string: {
// Strings can be multi-line
pattern: /"(?:[^"\\]|\\[\s\S])*"/,
greedy: true
},
'class-name': [
{
pattern:
/(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
lookbehind: true
}, // based on naming convention
/\b[A-Z]\w*/
],
// The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
keyword:
/\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
function: {
pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
greedy: true
},
operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
})
Prism.languages.insertBefore('haxe', 'string', {
'string-interpolation': {
pattern: /'(?:[^'\\]|\\[\s\S])*'/,
greedy: true,
inside: {
interpolation: {
pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
lookbehind: true,
inside: {
'interpolation-punctuation': {
pattern: /^\$\{?|\}$/,
alias: 'punctuation'
},
expression: {
pattern: /[\s\S]+/,
inside: Prism.languages.haxe
}
}
},
string: /[\s\S]+/
}
}
})
Prism.languages.insertBefore('haxe', 'class-name', {
regex: {
pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
greedy: true,
inside: {
'regex-flags': /\b[a-z]+$/,
'regex-source': {
pattern: /^(~\/)[\s\S]+(?=\/$)/,
lookbehind: true,
alias: 'language-regex',
inside: Prism.languages.regex
},
'regex-delimiter': /^~\/|\/$/
}
}
})
Prism.languages.insertBefore('haxe', 'keyword', {
preprocessor: {
pattern: /#(?:else|elseif|end|if)\b.*/,
alias: 'property'
},
metadata: {
pattern: /@:?[\w.]+/,
alias: 'symbol'
},
reification: {
pattern: /\$(?:\w+|(?=\{))/,
alias: 'important'
}
})
}

Some files were not shown because too many files have changed in this diff Show More