!(function (e) {
(e.languages.ruby = e.languages.extend('clike', {
comment: { pattern: /#.*|^=begin\s[\s\S]*?^=end/m, greedy: !0 },
'class-name': {
pattern:
/(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
lookbehind: !0,
inside: { punctuation: /[.\\]/ },
},
keyword:
/\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
operator:
/\.{2,3}|&\.|===||[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
punctuation: /[(){}[\].,;]/,
})),
e.languages.insertBefore('ruby', 'operator', {
'double-colon': { pattern: /::/, alias: 'punctuation' },
});
var n = {
pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
lookbehind: !0,
inside: {
content: {
pattern: /^(#\{)[\s\S]+(?=\}$)/,
lookbehind: !0,
inside: e.languages.ruby,
},
delimiter: { pattern: /^#\{|\}$/, alias: 'punctuation' },
},
};
delete e.languages.ruby.function;
var t =
'(?:' +
[
'([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[^])*\\1',
'\\((?:[^()\\\\]|\\\\[^]|\\((?:[^()\\\\]|\\\\[^])*\\))*\\)',
'\\{(?:[^{}\\\\]|\\\\[^]|\\{(?:[^{}\\\\]|\\\\[^])*\\})*\\}',
'\\[(?:[^\\[\\]\\\\]|\\\\[^]|\\[(?:[^\\[\\]\\\\]|\\\\[^])*\\])*\\]',
'<(?:[^<>\\\\]|\\\\[^]|<(?:[^<>\\\\]|\\\\[^])*>)*>',
].join('|') +
')',
i =
'(?:"(?:\\\\.|[^"\\\\\r\n])*"|(?:\\b[a-zA-Z_]\\w*|[^\\s\0-\\x7F]+)[?!]?|\\$.)';
e.languages.insertBefore('ruby', 'keyword', {
'regex-literal': [
{
pattern: RegExp('%r' + t + '[egimnosux]{0,6}'),
greedy: !0,
inside: { interpolation: n, regex: /[\s\S]+/ },
},
{
pattern:
/(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
lookbehind: !0,
greedy: !0,
inside: { interpolation: n, regex: /[\s\S]+/ },
},
],
variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
symbol: [
{ pattern: RegExp('(^|[^:]):' + i), lookbehind: !0, greedy: !0 },
{
pattern: RegExp('([\r\n{(,][ \t]*)' + i + '(?=:(?!:))'),
lookbehind: !0,
greedy: !0,
},
],
'method-definition': {
pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
lookbehind: !0,
inside: {
function: /\b\w+$/,
keyword: /^self\b/,
'class-name': /^\w+/,
punctuation: /\./,
},
},
}),
e.languages.insertBefore('ruby', 'string', {
'string-literal': [
{
pattern: RegExp('%[qQiIwWs]?' + t),
greedy: !0,
inside: { interpolation: n, string: /[\s\S]+/ },
},
{
pattern:
/("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
greedy: !0,
inside: { interpolation: n, string: /[\s\S]+/ },
},
{
pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
alias: 'heredoc-string',
greedy: !0,
inside: {
delimiter: {
pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
inside: { symbol: /\b\w+/, punctuation: /^<<[-~]?/ },
},
interpolation: n,
string: /[\s\S]+/,
},
},
{
pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
alias: 'heredoc-string',
greedy: !0,
inside: {
delimiter: {
pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
inside: { symbol: /\b\w+/, punctuation: /^<<[-~]?'|'$/ },
},
string: /[\s\S]+/,
},
},
],
'command-literal': [
{
pattern: RegExp('%x' + t),
greedy: !0,
inside: {
interpolation: n,
command: { pattern: /[\s\S]+/, alias: 'string' },
},
},
{
pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
greedy: !0,
inside: {
interpolation: n,
command: { pattern: /[\s\S]+/, alias: 'string' },
},
},
],
}),
delete e.languages.ruby.string,
e.languages.insertBefore('ruby', 'number', {
builtin:
/\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/,
}),
(e.languages.rb = e.languages.ruby);
})(Prism);
'>48
49
50
51
52
(Prism.languages.pascal = {
directive: {
pattern: /\{\$[\s\S]*?\}/,
greedy: !0,
alias: ['marco', 'property'],
},
comment: { pattern: /\(\*[\s\S]*?\*\)|\{[\s\S]*?\}|\/\/.*/, greedy: !0 },
string: {
pattern: /(?:'(?:''|[^'\r\n])*'(?!')|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
greedy: !0,
},
asm: {
pattern: /(\basm\b)[\s\S]+?(?=\bend\s*[;[])/i,
lookbehind: !0,
greedy: !0,
inside: null,
},
keyword: [
{
pattern:
/(^|[^&])\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\b/i,
lookbehind: !0,
},
{ pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i, lookbehind: !0 },
{
pattern:
/(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
lookbehind: !0,
},
{
pattern:
/(^|[^&])\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\b/i,
lookbehind: !0,
},
],
number: [/(?:[&%]\d+|\$[a-f\d]+)/i, /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i],
operator: [
/\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/,
{
pattern:
/(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,
lookbehind: !0,
},
],
punctuation: /\(\.|\.\)|[()\[\]:;,.]/,
}),
(Prism.languages.pascal.asm.inside = Prism.languages.extend('pascal', {
asm: void 0,
keyword: void 0,
operator: void 0,
})),
(Prism.languages.objectpascal = Prism.languages.pascal);
|