506 lines
16 KiB
JavaScript
506 lines
16 KiB
JavaScript
(self.webpackChunkmermaid_live_editor =
|
|
self.webpackChunkmermaid_live_editor || []).push([
|
|
[9684],
|
|
{
|
|
69684: (e, t, n) => {
|
|
'use strict';
|
|
n.r(t), n.d(t, { conf: () => r, language: () => s });
|
|
var r = {
|
|
comments: { lineComment: '#', blockComment: ['=begin', '=end'] },
|
|
brackets: [
|
|
['(', ')'],
|
|
['{', '}'],
|
|
['[', ']'],
|
|
],
|
|
autoClosingPairs: [
|
|
{ open: '{', close: '}' },
|
|
{ open: '[', close: ']' },
|
|
{ open: '(', close: ')' },
|
|
{ open: '"', close: '"' },
|
|
{ open: "'", close: "'" },
|
|
],
|
|
surroundingPairs: [
|
|
{ open: '{', close: '}' },
|
|
{ open: '[', close: ']' },
|
|
{ open: '(', close: ')' },
|
|
{ open: '"', close: '"' },
|
|
{ open: "'", close: "'" },
|
|
],
|
|
indentationRules: {
|
|
increaseIndentPattern: new RegExp(
|
|
'^\\s*((begin|class|(private|protected)\\s+def|def|else|elsif|ensure|for|if|module|rescue|unless|until|when|while|case)|([^#]*\\sdo\\b)|([^#]*=\\s*(case|if|unless)))\\b([^#\\{;]|("|\'|/).*\\4)*(#.*)?$'
|
|
),
|
|
decreaseIndentPattern: new RegExp(
|
|
'^\\s*([}\\]]([,)]?\\s*(#|$)|\\.[a-zA-Z_]\\w*\\b)|(end|rescue|ensure|else|elsif|when)\\b)'
|
|
),
|
|
},
|
|
},
|
|
s = {
|
|
tokenPostfix: '.ruby',
|
|
keywords: [
|
|
'__LINE__',
|
|
'__ENCODING__',
|
|
'__FILE__',
|
|
'BEGIN',
|
|
'END',
|
|
'alias',
|
|
'and',
|
|
'begin',
|
|
'break',
|
|
'case',
|
|
'class',
|
|
'def',
|
|
'defined?',
|
|
'do',
|
|
'else',
|
|
'elsif',
|
|
'end',
|
|
'ensure',
|
|
'for',
|
|
'false',
|
|
'if',
|
|
'in',
|
|
'module',
|
|
'next',
|
|
'nil',
|
|
'not',
|
|
'or',
|
|
'redo',
|
|
'rescue',
|
|
'retry',
|
|
'return',
|
|
'self',
|
|
'super',
|
|
'then',
|
|
'true',
|
|
'undef',
|
|
'unless',
|
|
'until',
|
|
'when',
|
|
'while',
|
|
'yield',
|
|
],
|
|
keywordops: ['::', '..', '...', '?', ':', '=>'],
|
|
builtins: [
|
|
'require',
|
|
'public',
|
|
'private',
|
|
'include',
|
|
'extend',
|
|
'attr_reader',
|
|
'protected',
|
|
'private_class_method',
|
|
'protected_class_method',
|
|
'new',
|
|
],
|
|
declarations: [
|
|
'module',
|
|
'class',
|
|
'def',
|
|
'case',
|
|
'do',
|
|
'begin',
|
|
'for',
|
|
'if',
|
|
'while',
|
|
'until',
|
|
'unless',
|
|
],
|
|
linedecls: [
|
|
'def',
|
|
'case',
|
|
'do',
|
|
'begin',
|
|
'for',
|
|
'if',
|
|
'while',
|
|
'until',
|
|
'unless',
|
|
],
|
|
operators: [
|
|
'^',
|
|
'&',
|
|
'|',
|
|
'<=>',
|
|
'==',
|
|
'===',
|
|
'!~',
|
|
'=~',
|
|
'>',
|
|
'>=',
|
|
'<',
|
|
'<=',
|
|
'<<',
|
|
'>>',
|
|
'+',
|
|
'-',
|
|
'*',
|
|
'/',
|
|
'%',
|
|
'**',
|
|
'~',
|
|
'+@',
|
|
'-@',
|
|
'[]',
|
|
'[]=',
|
|
'`',
|
|
'+=',
|
|
'-=',
|
|
'*=',
|
|
'**=',
|
|
'/=',
|
|
'^=',
|
|
'%=',
|
|
'<<=',
|
|
'>>=',
|
|
'&=',
|
|
'&&=',
|
|
'||=',
|
|
'|=',
|
|
],
|
|
brackets: [
|
|
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
|
|
{ open: '{', close: '}', token: 'delimiter.curly' },
|
|
{ open: '[', close: ']', token: 'delimiter.square' },
|
|
],
|
|
symbols: /[=><!~?:&|+\-*\/\^%\.]+/,
|
|
escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
|
|
escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
|
|
decpart: /\d(_?\d)*/,
|
|
decimal: /0|@decpart/,
|
|
delim: /[^a-zA-Z0-9\s\n\r]/,
|
|
heredelim: /(?:\w+|'[^']*'|"[^"]*"|`[^`]*`)/,
|
|
regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
|
|
regexpesc: /\\(?:[AzZbBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})?/,
|
|
tokenizer: {
|
|
root: [
|
|
[
|
|
/^(\s*)([a-z_]\w*[!?=]?)/,
|
|
[
|
|
'white',
|
|
{
|
|
cases: {
|
|
'for|until|while': {
|
|
token: 'keyword.$2',
|
|
next: '@dodecl.$2',
|
|
},
|
|
'@declarations': {
|
|
token: 'keyword.$2',
|
|
next: '@root.$2',
|
|
},
|
|
end: { token: 'keyword.$S2', next: '@pop' },
|
|
'@keywords': 'keyword',
|
|
'@builtins': 'predefined',
|
|
'@default': 'identifier',
|
|
},
|
|
},
|
|
],
|
|
],
|
|
[
|
|
/[a-z_]\w*[!?=]?/,
|
|
{
|
|
cases: {
|
|
'if|unless|while|until': {
|
|
token: 'keyword.$0x',
|
|
next: '@modifier.$0x',
|
|
},
|
|
for: { token: 'keyword.$2', next: '@dodecl.$2' },
|
|
'@linedecls': { token: 'keyword.$0', next: '@root.$0' },
|
|
end: { token: 'keyword.$S2', next: '@pop' },
|
|
'@keywords': 'keyword',
|
|
'@builtins': 'predefined',
|
|
'@default': 'identifier',
|
|
},
|
|
},
|
|
],
|
|
[/[A-Z][\w]*[!?=]?/, 'constructor.identifier'],
|
|
[/\$[\w]*/, 'global.constant'],
|
|
[/@[\w]*/, 'namespace.instance.identifier'],
|
|
[/@@[\w]*/, 'namespace.class.identifier'],
|
|
[
|
|
/<<[-~](@heredelim).*/,
|
|
{ token: 'string.heredoc.delimiter', next: '@heredoc.$1' },
|
|
],
|
|
[
|
|
/[ \t\r\n]+<<(@heredelim).*/,
|
|
{ token: 'string.heredoc.delimiter', next: '@heredoc.$1' },
|
|
],
|
|
[
|
|
/^<<(@heredelim).*/,
|
|
{ token: 'string.heredoc.delimiter', next: '@heredoc.$1' },
|
|
],
|
|
{ include: '@whitespace' },
|
|
[/"/, { token: 'string.d.delim', next: '@dstring.d."' }],
|
|
[/'/, { token: 'string.sq.delim', next: '@sstring.sq' }],
|
|
[/%([rsqxwW]|Q?)/, { token: '@rematch', next: 'pstring' }],
|
|
[/`/, { token: 'string.x.delim', next: '@dstring.x.`' }],
|
|
[/:(\w|[$@])\w*[!?=]?/, 'string.s'],
|
|
[/:"/, { token: 'string.s.delim', next: '@dstring.s."' }],
|
|
[/:'/, { token: 'string.s.delim', next: '@sstring.s' }],
|
|
[
|
|
/\/(?=(\\\/|[^\/\n])+\/)/,
|
|
{ token: 'regexp.delim', next: '@regexp' },
|
|
],
|
|
[/[{}()\[\]]/, '@brackets'],
|
|
[
|
|
/@symbols/,
|
|
{
|
|
cases: {
|
|
'@keywordops': 'keyword',
|
|
'@operators': 'operator',
|
|
'@default': '',
|
|
},
|
|
},
|
|
],
|
|
[/[;,]/, 'delimiter'],
|
|
[/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, 'number.hex'],
|
|
[/0[_oO][0-7](_?[0-7])*/, 'number.octal'],
|
|
[/0[bB][01](_?[01])*/, 'number.binary'],
|
|
[/0[dD]@decpart/, 'number'],
|
|
[
|
|
/@decimal((\.@decpart)?([eE][\-+]?@decpart)?)/,
|
|
{ cases: { $1: 'number.float', '@default': 'number' } },
|
|
],
|
|
],
|
|
dodecl: [
|
|
[/^/, { token: '', switchTo: '@root.$S2' }],
|
|
[
|
|
/[a-z_]\w*[!?=]?/,
|
|
{
|
|
cases: {
|
|
end: { token: 'keyword.$S2', next: '@pop' },
|
|
do: { token: 'keyword', switchTo: '@root.$S2' },
|
|
'@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
|
|
'@keywords': 'keyword',
|
|
'@builtins': 'predefined',
|
|
'@default': 'identifier',
|
|
},
|
|
},
|
|
],
|
|
{ include: '@root' },
|
|
],
|
|
modifier: [
|
|
[/^/, '', '@pop'],
|
|
[
|
|
/[a-z_]\w*[!?=]?/,
|
|
{
|
|
cases: {
|
|
end: { token: 'keyword.$S2', next: '@pop' },
|
|
'then|else|elsif|do': {
|
|
token: 'keyword',
|
|
switchTo: '@root.$S2',
|
|
},
|
|
'@linedecls': { token: '@rematch', switchTo: '@root.$S2' },
|
|
'@keywords': 'keyword',
|
|
'@builtins': 'predefined',
|
|
'@default': 'identifier',
|
|
},
|
|
},
|
|
],
|
|
{ include: '@root' },
|
|
],
|
|
sstring: [
|
|
[/[^\\']+/, 'string.$S2'],
|
|
[/\\\\|\\'|\\$/, 'string.$S2.escape'],
|
|
[/\\./, 'string.$S2.invalid'],
|
|
[/'/, { token: 'string.$S2.delim', next: '@pop' }],
|
|
],
|
|
dstring: [
|
|
[/[^\\`"#]+/, 'string.$S2'],
|
|
[/#/, 'string.$S2.escape', '@interpolated'],
|
|
[/\\$/, 'string.$S2.escape'],
|
|
[/@escapes/, 'string.$S2.escape'],
|
|
[/\\./, 'string.$S2.escape.invalid'],
|
|
[
|
|
/[`"]/,
|
|
{
|
|
cases: {
|
|
'$#==$S3': { token: 'string.$S2.delim', next: '@pop' },
|
|
'@default': 'string.$S2',
|
|
},
|
|
},
|
|
],
|
|
],
|
|
heredoc: [
|
|
[
|
|
/^(\s*)(@heredelim)$/,
|
|
{
|
|
cases: {
|
|
'$2==$S2': [
|
|
'string.heredoc',
|
|
{ token: 'string.heredoc.delimiter', next: '@pop' },
|
|
],
|
|
'@default': ['string.heredoc', 'string.heredoc'],
|
|
},
|
|
},
|
|
],
|
|
[/.*/, 'string.heredoc'],
|
|
],
|
|
interpolated: [
|
|
[/\$\w*/, 'global.constant', '@pop'],
|
|
[/@\w*/, 'namespace.class.identifier', '@pop'],
|
|
[/@@\w*/, 'namespace.instance.identifier', '@pop'],
|
|
[
|
|
/[{]/,
|
|
{
|
|
token: 'string.escape.curly',
|
|
switchTo: '@interpolated_compound',
|
|
},
|
|
],
|
|
['', '', '@pop'],
|
|
],
|
|
interpolated_compound: [
|
|
[/[}]/, { token: 'string.escape.curly', next: '@pop' }],
|
|
{ include: '@root' },
|
|
],
|
|
pregexp: [
|
|
{ include: '@whitespace' },
|
|
[
|
|
/[^\(\{\[\\]/,
|
|
{
|
|
cases: {
|
|
'$#==$S3': { token: 'regexp.delim', next: '@pop' },
|
|
'$#==$S2': { token: 'regexp.delim', next: '@push' },
|
|
'~[)}\\]]': '@brackets.regexp.escape.control',
|
|
'~@regexpctl': 'regexp.escape.control',
|
|
'@default': 'regexp',
|
|
},
|
|
},
|
|
],
|
|
{ include: '@regexcontrol' },
|
|
],
|
|
regexp: [
|
|
{ include: '@regexcontrol' },
|
|
[/[^\\\/]/, 'regexp'],
|
|
['/[ixmp]*', { token: 'regexp.delim' }, '@pop'],
|
|
],
|
|
regexcontrol: [
|
|
[
|
|
/(\{)(\d+(?:,\d*)?)(\})/,
|
|
[
|
|
'@brackets.regexp.escape.control',
|
|
'regexp.escape.control',
|
|
'@brackets.regexp.escape.control',
|
|
],
|
|
],
|
|
[
|
|
/(\[)(\^?)/,
|
|
[
|
|
'@brackets.regexp.escape.control',
|
|
{ token: 'regexp.escape.control', next: '@regexrange' },
|
|
],
|
|
],
|
|
[
|
|
/(\()(\?[:=!])/,
|
|
['@brackets.regexp.escape.control', 'regexp.escape.control'],
|
|
],
|
|
[
|
|
/\(\?#/,
|
|
{ token: 'regexp.escape.control', next: '@regexpcomment' },
|
|
],
|
|
[/[()]/, '@brackets.regexp.escape.control'],
|
|
[/@regexpctl/, 'regexp.escape.control'],
|
|
[/\\$/, 'regexp.escape'],
|
|
[/@regexpesc/, 'regexp.escape'],
|
|
[/\\\./, 'regexp.invalid'],
|
|
[/#/, 'regexp.escape', '@interpolated'],
|
|
],
|
|
regexrange: [
|
|
[/-/, 'regexp.escape.control'],
|
|
[/\^/, 'regexp.invalid'],
|
|
[/\\$/, 'regexp.escape'],
|
|
[/@regexpesc/, 'regexp.escape'],
|
|
[/[^\]]/, 'regexp'],
|
|
[/\]/, '@brackets.regexp.escape.control', '@pop'],
|
|
],
|
|
regexpcomment: [
|
|
[/[^)]+/, 'comment'],
|
|
[/\)/, { token: 'regexp.escape.control', next: '@pop' }],
|
|
],
|
|
pstring: [
|
|
[
|
|
/%([qws])\(/,
|
|
{ token: 'string.$1.delim', switchTo: '@qstring.$1.(.)' },
|
|
],
|
|
[
|
|
/%([qws])\[/,
|
|
{ token: 'string.$1.delim', switchTo: '@qstring.$1.[.]' },
|
|
],
|
|
[
|
|
/%([qws])\{/,
|
|
{ token: 'string.$1.delim', switchTo: '@qstring.$1.{.}' },
|
|
],
|
|
[
|
|
/%([qws])</,
|
|
{ token: 'string.$1.delim', switchTo: '@qstring.$1.<.>' },
|
|
],
|
|
[
|
|
/%([qws])(@delim)/,
|
|
{ token: 'string.$1.delim', switchTo: '@qstring.$1.$2.$2' },
|
|
],
|
|
[/%r\(/, { token: 'regexp.delim', switchTo: '@pregexp.(.)' }],
|
|
[/%r\[/, { token: 'regexp.delim', switchTo: '@pregexp.[.]' }],
|
|
[/%r\{/, { token: 'regexp.delim', switchTo: '@pregexp.{.}' }],
|
|
[/%r</, { token: 'regexp.delim', switchTo: '@pregexp.<.>' }],
|
|
[
|
|
/%r(@delim)/,
|
|
{ token: 'regexp.delim', switchTo: '@pregexp.$1.$1' },
|
|
],
|
|
[
|
|
/%(x|W|Q?)\(/,
|
|
{ token: 'string.$1.delim', switchTo: '@qqstring.$1.(.)' },
|
|
],
|
|
[
|
|
/%(x|W|Q?)\[/,
|
|
{ token: 'string.$1.delim', switchTo: '@qqstring.$1.[.]' },
|
|
],
|
|
[
|
|
/%(x|W|Q?)\{/,
|
|
{ token: 'string.$1.delim', switchTo: '@qqstring.$1.{.}' },
|
|
],
|
|
[
|
|
/%(x|W|Q?)</,
|
|
{ token: 'string.$1.delim', switchTo: '@qqstring.$1.<.>' },
|
|
],
|
|
[
|
|
/%(x|W|Q?)(@delim)/,
|
|
{ token: 'string.$1.delim', switchTo: '@qqstring.$1.$2.$2' },
|
|
],
|
|
[/%([rqwsxW]|Q?)./, { token: 'invalid', next: '@pop' }],
|
|
[/./, { token: 'invalid', next: '@pop' }],
|
|
],
|
|
qstring: [
|
|
[/\\$/, 'string.$S2.escape'],
|
|
[/\\./, 'string.$S2.escape'],
|
|
[
|
|
/./,
|
|
{
|
|
cases: {
|
|
'$#==$S4': { token: 'string.$S2.delim', next: '@pop' },
|
|
'$#==$S3': { token: 'string.$S2.delim', next: '@push' },
|
|
'@default': 'string.$S2',
|
|
},
|
|
},
|
|
],
|
|
],
|
|
qqstring: [
|
|
[/#/, 'string.$S2.escape', '@interpolated'],
|
|
{ include: '@qstring' },
|
|
],
|
|
whitespace: [
|
|
[/[ \t\r\n]+/, ''],
|
|
[/^\s*=begin\b/, 'comment', '@comment'],
|
|
[/#.*$/, 'comment'],
|
|
],
|
|
comment: [
|
|
[/[^=]+/, 'comment'],
|
|
[/^\s*=begin\b/, 'comment.invalid'],
|
|
[/^\s*=end\b.*/, 'comment', '@pop'],
|
|
[/[=]/, 'comment'],
|
|
],
|
|
},
|
|
};
|
|
},
|
|
},
|
|
]);
|