/*!-----------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * monaco-languages version: 0.8.0(fbdcb70601ea4f81278d62ad15d456807ccaa7fa)
 * Released under the MIT license
 * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
 *-----------------------------------------------------------------------------*/
define('vs/basic-languages/src/ruby', ['require', 'exports'], function(e, t) {
  'use strict'
  Object.defineProperty(t, '__esModule', { value: !0 }),
    (t.conf = {
      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: "'" }
      ]
    }),
    (t.language = {
      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']
        ]
      }
    })
})
