{"version":3,"file":"mode-ruby-81623b97.js","sources":["../../node_modules/ace-builds/src-noconflict/mode-ruby.js"],"sourcesContent":["ace.define(\"ace/mode/ruby_highlight_rules\",[\"require\",\"exports\",\"module\",\"ace/lib/oop\",\"ace/mode/text_highlight_rules\"], function(require, exports, module){\"use strict\";\nvar oop = require(\"../lib/oop\");\nvar TextHighlightRules = require(\"./text_highlight_rules\").TextHighlightRules;\nvar constantOtherSymbol = exports.constantOtherSymbol = {\n    token: \"constant.other.symbol.ruby\",\n    regex: \"[:](?:[A-Za-z_]|[@$](?=[a-zA-Z0-9_]))[a-zA-Z0-9_]*[!=?]?\"\n};\nexports.qString = {\n    token: \"string\",\n    regex: \"['](?:(?:\\\\\\\\.)|(?:[^'\\\\\\\\]))*?[']\"\n};\nexports.qqString = {\n    token: \"string\",\n    regex: '[\"](?:(?:\\\\\\\\.)|(?:[^\"\\\\\\\\]))*?[\"]'\n};\nexports.tString = {\n    token: \"string\",\n    regex: \"[`](?:(?:\\\\\\\\.)|(?:[^'\\\\\\\\]))*?[`]\"\n};\nvar constantNumericHex = exports.constantNumericHex = {\n    token: \"constant.numeric\",\n    regex: \"0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_(?=[0-9a-fA-F]))*\\\\b\"\n};\nvar constantNumericBinary = exports.constantNumericBinary = {\n    token: \"constant.numeric\",\n    regex: /\\b(0[bB][01](?:[01]|_(?=[01]))*)\\b/\n};\nvar constantNumericDecimal = exports.constantNumericDecimal = {\n    token: \"constant.numeric\",\n    regex: /\\b(0[dD](?:[1-9](?:[\\d]|_(?=[\\d]))*|0))\\b/\n};\nvar constantNumericOctal = exports.constantNumericDecimal = {\n    token: \"constant.numeric\",\n    regex: /\\b(0[oO]?(?:[1-7](?:[0-7]|_(?=[0-7]))*|0))\\b/\n};\nvar constantNumericRational = exports.constantNumericRational = {\n    token: \"constant.numeric\",\n    regex: /\\b([\\d]+(?:[./][\\d]+)?ri?)\\b/\n};\nvar constantNumericComplex = exports.constantNumericComplex = {\n    token: \"constant.numeric\",\n    regex: /\\b([\\d]i)\\b/\n};\nvar constantNumericFloat = exports.constantNumericFloat = {\n    token: \"constant.numeric\",\n    regex: \"[+-]?\\\\d(?:\\\\d|_(?=\\\\d))*(?:(?:\\\\.\\\\d(?:\\\\d|_(?=\\\\d))*)?(?:[eE][+-]?\\\\d+)?)?i?\\\\b\"\n};\nvar instanceVariable = exports.instanceVariable = {\n    token: \"variable.instance\",\n    regex: \"@{1,2}[a-zA-Z_\\\\d]+\"\n};\nvar RubyHighlightRules = function () {\n    var builtinFunctions = (\"abort|Array|assert|assert_equal|assert_not_equal|assert_same|assert_not_same|\" +\n        \"assert_nil|assert_not_nil|assert_match|assert_no_match|assert_in_delta|assert_throws|\" +\n        \"assert_raise|assert_nothing_raised|assert_instance_of|assert_kind_of|assert_respond_to|\" +\n        \"assert_operator|assert_send|assert_difference|assert_no_difference|assert_recognizes|\" +\n        \"assert_generates|assert_response|assert_redirected_to|assert_template|assert_select|\" +\n        \"assert_select_email|assert_select_rjs|assert_select_encoded|css_select|at_exit|\" +\n        \"attr|attr_writer|attr_reader|attr_accessor|attr_accessible|autoload|binding|block_given?|callcc|\" +\n        \"caller|catch|chomp|chomp!|chop|chop!|defined?|delete_via_redirect|eval|exec|exit|\" +\n        \"exit!|fail|Float|flunk|follow_redirect!|fork|form_for|form_tag|format|gets|global_variables|gsub|\" +\n        \"gsub!|get_via_redirect|host!|https?|https!|include|Integer|lambda|link_to|\" +\n        \"link_to_unless_current|link_to_function|link_to_remote|load|local_variables|loop|open|open_session|\" +\n        \"p|print|printf|proc|putc|puts|post_via_redirect|put_via_redirect|raise|rand|\" +\n        \"raw|readline|readlines|redirect?|request_via_redirect|require|scan|select|\" +\n        \"set_trace_func|sleep|split|sprintf|srand|String|stylesheet_link_tag|syscall|system|sub|sub!|test|\" +\n        \"throw|trace_var|trap|untrace_var|atan2|cos|exp|frexp|ldexp|log|log10|sin|sqrt|tan|\" +\n        \"render|javascript_include_tag|csrf_meta_tag|label_tag|text_field_tag|submit_tag|check_box_tag|\" +\n        \"content_tag|radio_button_tag|text_area_tag|password_field_tag|hidden_field_tag|\" +\n        \"fields_for|select_tag|options_for_select|options_from_collection_for_select|collection_select|\" +\n        \"time_zone_select|select_date|select_time|select_datetime|date_select|time_select|datetime_select|\" +\n        \"select_year|select_month|select_day|select_hour|select_minute|select_second|file_field_tag|\" +\n        \"file_field|respond_to|skip_before_filter|around_filter|after_filter|verify|\" +\n        \"protect_from_forgery|rescue_from|helper_method|redirect_to|before_filter|\" +\n        \"send_data|send_file|validates_presence_of|validates_uniqueness_of|validates_length_of|\" +\n        \"validates_format_of|validates_acceptance_of|validates_associated|validates_exclusion_of|\" +\n        \"validates_inclusion_of|validates_numericality_of|validates_with|validates_each|\" +\n        \"authenticate_or_request_with_http_basic|authenticate_or_request_with_http_digest|\" +\n        \"filter_parameter_logging|match|get|post|resources|redirect|scope|assert_routing|\" +\n        \"translate|localize|extract_locale_from_tld|caches_page|expire_page|caches_action|expire_action|\" +\n        \"cache|expire_fragment|expire_cache_for|observe|cache_sweeper|\" +\n        \"has_many|has_one|belongs_to|has_and_belongs_to_many|p|warn|refine|using|module_function|extend|alias_method|\" +\n        \"private_class_method|remove_method|undef_method\");\n    var keywords = (\"alias|and|BEGIN|begin|break|case|class|def|defined|do|else|elsif|END|end|ensure|\" +\n        \"__FILE__|finally|for|gem|if|in|__LINE__|module|next|not|or|private|protected|public|\" +\n        \"redo|rescue|retry|return|super|then|undef|unless|until|when|while|yield|__ENCODING__|prepend\");\n    var buildinConstants = (\"true|TRUE|false|FALSE|nil|NIL|ARGF|ARGV|DATA|ENV|RUBY_PLATFORM|RUBY_RELEASE_DATE|\" +\n        \"RUBY_VERSION|STDERR|STDIN|STDOUT|TOPLEVEL_BINDING|RUBY_PATCHLEVEL|RUBY_REVISION|RUBY_COPYRIGHT|RUBY_ENGINE|RUBY_ENGINE_VERSION|RUBY_DESCRIPTION\");\n    var builtinVariables = (\"$DEBUG|$defout|$FILENAME|$LOAD_PATH|$SAFE|$stdin|$stdout|$stderr|$VERBOSE|\" +\n        \"$!|root_url|flash|session|cookies|params|request|response|logger|self\");\n    var keywordMapper = this.$keywords = this.createKeywordMapper({\n        \"keyword\": keywords,\n        \"constant.language\": buildinConstants,\n        \"variable.language\": builtinVariables,\n        \"support.function\": builtinFunctions,\n        \"invalid.deprecated\": \"debugger\" // TODO is this a remnant from js mode?\n    }, \"identifier\");\n    var escapedChars = \"\\\\\\\\(?:n(?:[1-7][0-7]{0,2}|0)|[nsrtvfbae'\\\"\\\\\\\\]|c(?:\\\\\\\\M-)?.|M-(?:\\\\\\\\C-|\\\\\\\\c)?.|C-(?:\\\\\\\\M-)?.|[0-7]{3}|x[\\\\da-fA-F]{2}|u[\\\\da-fA-F]{4}|u{[\\\\da-fA-F]{1,6}(?:\\\\s[\\\\da-fA-F]{1,6})*})\";\n    var closeParen = {\n        \"(\": \")\",\n        \"[\": \"]\",\n        \"{\": \"}\",\n        \"<\": \">\",\n        \"^\": \"^\",\n        \"|\": \"|\",\n        \"%\": \"%\"\n    };\n    this.$rules = {\n        \"start\": [\n            {\n                token: \"comment\",\n                regex: \"#.*$\"\n            }, {\n                token: \"comment.multiline\",\n                regex: \"^=begin(?=$|\\\\s.*$)\",\n                next: \"comment\"\n            }, {\n                token: \"string.regexp\",\n                regex: /[/](?=.*\\/)/,\n                next: \"regex\"\n            },\n            [{\n                    token: [\"constant.other.symbol.ruby\", \"string.start\"],\n                    regex: /(:)?(\")/,\n                    push: [{\n                            token: \"constant.language.escape\",\n                            regex: escapedChars\n                        }, {\n                            token: \"paren.start\",\n                            regex: /#{/,\n                            push: \"start\"\n                        }, {\n                            token: \"string.end\",\n                            regex: /\"/,\n                            next: \"pop\"\n                        }, {\n                            defaultToken: \"string\"\n                        }]\n                }, {\n                    token: \"string.start\",\n                    regex: /`/,\n                    push: [{\n                            token: \"constant.language.escape\",\n                            regex: escapedChars\n                        }, {\n                            token: \"paren.start\",\n                            regex: /#{/,\n                            push: \"start\"\n                        }, {\n                            token: \"string.end\",\n                            regex: /`/,\n                            next: \"pop\"\n                        }, {\n                            defaultToken: \"string\"\n                        }]\n                }, {\n                    token: [\"constant.other.symbol.ruby\", \"string.start\"],\n                    regex: /(:)?(')/,\n                    push: [{\n                            token: \"constant.language.escape\",\n                            regex: /\\\\['\\\\]/\n                        }, {\n                            token: \"string.end\",\n                            regex: /'/,\n                            next: \"pop\"\n                        }, {\n                            defaultToken: \"string\"\n                        }]\n                }, {\n                    token: \"string.start\",\n                    regex: /%[qwx]([(\\[<{^|%])/, onMatch: function (val, state, stack) {\n                        if (stack.length)\n                            stack = [];\n                        var paren = val[val.length - 1];\n                        stack.unshift(paren, state);\n                        this.next = \"qStateWithoutInterpolation\";\n                        return this.token;\n                    }\n                }, {\n                    token: \"string.start\",\n                    regex: /%[QWX]?([(\\[<{^|%])/, onMatch: function (val, state, stack) {\n                        if (stack.length)\n                            stack = [];\n                        var paren = val[val.length - 1];\n                        stack.unshift(paren, state);\n                        this.next = \"qStateWithInterpolation\";\n                        return this.token;\n                    }\n                }, {\n                    token: \"constant.other.symbol.ruby\",\n                    regex: /%[si]([(\\[<{^|%])/, onMatch: function (val, state, stack) {\n                        if (stack.length)\n                            stack = [];\n                        var paren = val[val.length - 1];\n                        stack.unshift(paren, state);\n                        this.next = \"sStateWithoutInterpolation\";\n                        return this.token;\n                    }\n                }, {\n                    token: \"constant.other.symbol.ruby\",\n                    regex: /%[SI]([(\\[<{^|%])/, onMatch: function (val, state, stack) {\n                        if (stack.length)\n                            stack = [];\n                        var paren = val[val.length - 1];\n                        stack.unshift(paren, state);\n                        this.next = \"sStateWithInterpolation\";\n                        return this.token;\n                    }\n                }, {\n                    token: \"string.regexp\",\n                    regex: /%[r]([(\\[<{^|%])/, onMatch: function (val, state, stack) {\n                        if (stack.length)\n                            stack = [];\n                        var paren = val[val.length - 1];\n                        stack.unshift(paren, state);\n                        this.next = \"rState\";\n                        return this.token;\n                    }\n                }],\n            {\n                token: \"punctuation\",\n                regex: \"::\"\n            },\n            instanceVariable,\n            {\n                token: \"variable.global\",\n                regex: \"[$][a-zA-Z_\\\\d]+\"\n            }, {\n                token: \"support.class\",\n                regex: \"[A-Z][a-zA-Z_\\\\d]*\"\n            }, {\n                token: [\"punctuation.operator\", \"support.function\"],\n                regex: /(\\.)([a-zA-Z_\\d]+)(?=\\()/\n            }, {\n                token: [\"punctuation.operator\", \"identifier\"],\n                regex: /(\\.)([a-zA-Z_][a-zA-Z_\\d]*)/\n            }, {\n                token: \"string.character\",\n                regex: \"\\\\B\\\\?(?:\" + escapedChars + \"|\\\\S)\"\n            }, {\n                token: \"punctuation.operator\",\n                regex: /\\?(?=.+:)/\n            },\n            constantNumericRational,\n            constantNumericComplex,\n            constantOtherSymbol,\n            constantNumericHex,\n            constantNumericFloat,\n            constantNumericBinary,\n            constantNumericDecimal,\n            constantNumericOctal,\n            {\n                token: \"constant.language.boolean\",\n                regex: \"(?:true|false)\\\\b\"\n            }, {\n                token: keywordMapper,\n                regex: \"[a-zA-Z_$][a-zA-Z0-9_$]*\\\\b\"\n            }, {\n                token: \"punctuation.separator.key-value\",\n                regex: \"=>\"\n            }, {\n                stateName: \"heredoc\",\n                onMatch: function (value, currentState, stack) {\n                    var next = (value[2] == '-' || value[2] == '~') ? \"indentedHeredoc\" : \"heredoc\";\n                    var tokens = value.split(this.splitRegex);\n                    stack.push(next, tokens[3]);\n                    return [\n                        { type: \"constant\", value: tokens[1] },\n                        { type: \"string\", value: tokens[2] },\n                        { type: \"support.class\", value: tokens[3] },\n                        { type: \"string\", value: tokens[4] }\n                    ];\n                },\n                regex: \"(<<[-~]?)(['\\\"`]?)([\\\\w]+)(['\\\"`]?)\",\n                rules: {\n                    heredoc: [{\n                            onMatch: function (value, currentState, stack) {\n                                if (value === stack[1]) {\n                                    stack.shift();\n                                    stack.shift();\n                                    this.next = stack[0] || \"start\";\n                                    return \"support.class\";\n                                }\n                                this.next = \"\";\n                                return \"string\";\n                            },\n                            regex: \".*$\",\n                            next: \"start\"\n                        }],\n                    indentedHeredoc: [{\n                            token: \"string\",\n                            regex: \"^ +\"\n                        }, {\n                            onMatch: function (value, currentState, stack) {\n                                if (value === stack[1]) {\n                                    stack.shift();\n                                    stack.shift();\n                                    this.next = stack[0] || \"start\";\n                                    return \"support.class\";\n                                }\n                                this.next = \"\";\n                                return \"string\";\n                            },\n                            regex: \".*$\",\n                            next: \"start\"\n                        }]\n                }\n            }, {\n                regex: \"$\",\n                token: \"empty\",\n                next: function (currentState, stack) {\n                    if (stack[0] === \"heredoc\" || stack[0] === \"indentedHeredoc\")\n                        return stack[0];\n                    return currentState;\n                }\n            }, {\n                token: \"keyword.operator\",\n                regex: \"!|\\\\$|%|&|\\\\*|/|\\\\-\\\\-|\\\\-|\\\\+\\\\+|\\\\+|~|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\\\\|\\\\||\\\\?\\\\:|\\\\*=|%=|\\\\+=|\\\\-=|&=|\\\\^=|\\\\||\\\\b(?:in|instanceof|new|delete|typeof|void)\"\n            }, {\n                token: \"paren.lparen\",\n                regex: \"[[({]\"\n            }, {\n                token: \"paren.rparen\",\n                regex: \"[\\\\])}]\",\n                onMatch: function (value, currentState, stack) {\n                    this.next = '';\n                    if (value == \"}\" && stack.length > 1 && stack[1] != \"start\") {\n                        stack.shift();\n                        this.next = stack.shift();\n                    }\n                    return this.token;\n                }\n            }, {\n                token: \"text\",\n                regex: \"\\\\s+\"\n            }, {\n                token: \"punctuation.operator\",\n                regex: /[?:,;.]/\n            }\n        ],\n        \"comment\": [\n            {\n                token: \"comment.multiline\",\n                regex: \"^=end(?=$|\\\\s.*$)\",\n                next: \"start\"\n            }, {\n                token: \"comment\",\n                regex: \".+\"\n            }\n        ],\n        \"qStateWithInterpolation\": [{\n                token: \"string.start\",\n                regex: /[(\\[<{]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === stack[0]) {\n                        stack.unshift(val, state);\n                        return this.token;\n                    }\n                    return \"string\";\n                }\n            }, {\n                token: \"constant.language.escape\",\n                regex: escapedChars\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\\\./\n            }, {\n                token: \"paren.start\",\n                regex: /#{/,\n                push: \"start\"\n            }, {\n                token: \"string.end\",\n                regex: /[)\\]>}^|%]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === closeParen[stack[0]]) {\n                        stack.shift();\n                        this.next = stack.shift();\n                        return this.token;\n                    }\n                    this.next = '';\n                    return \"string\";\n                }\n            }, {\n                defaultToken: \"string\"\n            }],\n        \"qStateWithoutInterpolation\": [{\n                token: \"string.start\",\n                regex: /[(\\[<{]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === stack[0]) {\n                        stack.unshift(val, state);\n                        return this.token;\n                    }\n                    return \"string\";\n                }\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\\\['\\\\]/\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\\\./\n            }, {\n                token: \"string.end\",\n                regex: /[)\\]>}^|%]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === closeParen[stack[0]]) {\n                        stack.shift();\n                        this.next = stack.shift();\n                        return this.token;\n                    }\n                    this.next = '';\n                    return \"string\";\n                }\n            }, {\n                defaultToken: \"string\"\n            }],\n        \"sStateWithoutInterpolation\": [{\n                token: \"constant.other.symbol.ruby\",\n                regex: /[(\\[<{]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === stack[0]) {\n                        stack.unshift(val, state);\n                        return this.token;\n                    }\n                    return \"constant.other.symbol.ruby\";\n                }\n            }, {\n                token: \"constant.other.symbol.ruby\",\n                regex: /[)\\]>}^|%]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === closeParen[stack[0]]) {\n                        stack.shift();\n                        this.next = stack.shift();\n                        return this.token;\n                    }\n                    this.next = '';\n                    return \"constant.other.symbol.ruby\";\n                }\n            }, {\n                defaultToken: \"constant.other.symbol.ruby\"\n            }],\n        \"sStateWithInterpolation\": [{\n                token: \"constant.other.symbol.ruby\",\n                regex: /[(\\[<{]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === stack[0]) {\n                        stack.unshift(val, state);\n                        return this.token;\n                    }\n                    return \"constant.other.symbol.ruby\";\n                }\n            }, {\n                token: \"constant.language.escape\",\n                regex: escapedChars\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\\\./\n            }, {\n                token: \"paren.start\",\n                regex: /#{/,\n                push: \"start\"\n            }, {\n                token: \"constant.other.symbol.ruby\",\n                regex: /[)\\]>}^|%]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === closeParen[stack[0]]) {\n                        stack.shift();\n                        this.next = stack.shift();\n                        return this.token;\n                    }\n                    this.next = '';\n                    return \"constant.other.symbol.ruby\";\n                }\n            }, {\n                defaultToken: \"constant.other.symbol.ruby\"\n            }],\n        \"rState\": [{\n                token: \"string.regexp\",\n                regex: /[(\\[<{]/, onMatch: function (val, state, stack) {\n                    if (stack.length && val === stack[0]) {\n                        stack.unshift(val, state);\n                        return this.token;\n                    }\n                    return \"constant.language.escape\";\n                }\n            }, {\n                token: \"paren.start\",\n                regex: /#{/,\n                push: \"start\"\n            }, {\n                token: \"string.regexp\",\n                regex: /\\//\n            }, {\n                token: \"string.regexp\",\n                regex: /[)\\]>}^|%][imxouesn]*/, onMatch: function (val, state, stack) {\n                    if (stack.length && val[0] === closeParen[stack[0]]) {\n                        stack.shift();\n                        this.next = stack.shift();\n                        return this.token;\n                    }\n                    this.next = '';\n                    return \"constant.language.escape\";\n                }\n            },\n            { include: \"regex\" },\n            {\n                defaultToken: \"string.regexp\"\n            }],\n        \"regex\": [\n            {\n                token: \"regexp.keyword\",\n                regex: /\\\\[wWdDhHsS]/\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\\\[AGbBzZ]/\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\\\g<[a-zA-Z0-9]*>/\n            }, {\n                token: [\"constant.language.escape\", \"regexp.keyword\", \"constant.language.escape\"],\n                regex: /(\\\\p{\\^?)(Alnum|Alpha|Blank|Cntrl|Digit|Graph|Lower|Print|Punct|Space|Upper|XDigit|Word|ASCII|Any|Assigned|Arabic|Armenian|Balinese|Bengali|Bopomofo|Braille|Buginese|Buhid|Canadian_Aboriginal|Carian|Cham|Cherokee|Common|Coptic|Cuneiform|Cypriot|Cyrillic|Deseret|Devanagari|Ethiopic|Georgian|Glagolitic|Gothic|Greek|Gujarati|Gurmukhi|Han|Hangul|Hanunoo|Hebrew|Hiragana|Inherited|Kannada|Katakana|Kayah_Li|Kharoshthi|Khmer|Lao|Latin|Lepcha|Limbu|Linear_B|Lycian|Lydian|Malayalam|Mongolian|Myanmar|New_Tai_Lue|Nko|Ogham|Ol_Chiki|Old_Italic|Old_Persian|Oriya|Osmanya|Phags_Pa|Phoenician|Rejang|Runic|Saurashtra|Shavian|Sinhala|Sundanese|Syloti_Nagri|Syriac|Tagalog|Tagbanwa|Tai_Le|Tamil|Telugu|Thaana|Thai|Tibetan|Tifinagh|Ugaritic|Vai|Yi|Ll|Lm|Lt|Lu|Lo|Mn|Mc|Me|Nd|Nl|Pc|Pd|Ps|Pe|Pi|Pf|Po|No|Sm|Sc|Sk|So|Zs|Zl|Zp|Cc|Cf|Cn|Co|Cs|N|L|M|P|S|Z|C)(})/\n            }, {\n                token: [\"constant.language.escape\", \"invalid\", \"constant.language.escape\"],\n                regex: /(\\\\p{\\^?)([^/]*)(})/\n            }, {\n                token: \"regexp.keyword.operator\",\n                regex: \"\\\\\\\\(?:u[\\\\da-fA-F]{4}|x[\\\\da-fA-F]{2}|.)\"\n            }, {\n                token: \"string.regexp\",\n                regex: /[/][imxouesn]*/,\n                next: \"start\"\n            }, {\n                token: \"invalid\",\n                regex: /\\{\\d+\\b,?\\d*\\}[+*]|[+*$^?][+*]|[$^][?]|\\?{3,}/\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\(\\?(?:[:=!>]|<'?[a-zA-Z]*'?>|<[=!])|\\)|\\{\\d+\\b,?\\d*\\}|[+*]\\?|[()$^+*?.]/\n            }, {\n                token: \"constant.language.delimiter\",\n                regex: /\\|/\n            }, {\n                token: \"regexp.keyword\",\n                regex: /\\[\\[:(?:alnum|alpha|blank|cntrl|digit|graph|lower|print|punct|space|upper|xdigit|word|ascii):\\]\\]/\n            }, {\n                token: \"constant.language.escape\",\n                regex: /\\[\\^?/,\n                push: \"regex_character_class\"\n            }, {\n                defaultToken: \"string.regexp\"\n            }\n        ],\n        \"regex_character_class\": [\n            {\n                token: \"regexp.keyword\",\n                regex: /\\\\[wWdDhHsS]/\n            }, {\n                token: \"regexp.charclass.keyword.operator\",\n                regex: \"\\\\\\\\(?:u[\\\\da-fA-F]{4}|x[\\\\da-fA-F]{2}|.)\"\n            }, {\n                token: \"constant.language.escape\",\n                regex: /&?&?\\[\\^?/,\n                push: \"regex_character_class\"\n            }, {\n                token: \"constant.language.escape\",\n                regex: \"]\",\n                next: \"pop\"\n            }, {\n                token: \"constant.language.escape\",\n                regex: \"-\"\n            }, {\n                defaultToken: \"string.regexp.characterclass\"\n            }\n        ]\n    };\n    this.normalizeRules();\n};\noop.inherits(RubyHighlightRules, TextHighlightRules);\nexports.RubyHighlightRules = RubyHighlightRules;\n\n});\n\nace.define(\"ace/mode/matching_brace_outdent\",[\"require\",\"exports\",\"module\",\"ace/range\"], function(require, exports, module){\"use strict\";\nvar Range = require(\"../range\").Range;\nvar MatchingBraceOutdent = function () { };\n(function () {\n    this.checkOutdent = function (line, input) {\n        if (!/^\\s+$/.test(line))\n            return false;\n        return /^\\s*\\}/.test(input);\n    };\n    this.autoOutdent = function (doc, row) {\n        var line = doc.getLine(row);\n        var match = line.match(/^(\\s*\\})/);\n        if (!match)\n            return 0;\n        var column = match[1].length;\n        var openBracePos = doc.findMatchingBracket({ row: row, column: column });\n        if (!openBracePos || openBracePos.row == row)\n            return 0;\n        var indent = this.$getIndent(doc.getLine(openBracePos.row));\n        doc.replace(new Range(row, 0, row, column - 1), indent);\n    };\n    this.$getIndent = function (line) {\n        return line.match(/^\\s*/)[0];\n    };\n}).call(MatchingBraceOutdent.prototype);\nexports.MatchingBraceOutdent = MatchingBraceOutdent;\n\n});\n\nace.define(\"ace/mode/folding/ruby\",[\"require\",\"exports\",\"module\",\"ace/lib/oop\",\"ace/mode/folding/fold_mode\",\"ace/range\",\"ace/token_iterator\"], function(require, exports, module){\"use strict\";\nvar oop = require(\"../../lib/oop\");\nvar BaseFoldMode = require(\"./fold_mode\").FoldMode;\nvar Range = require(\"../../range\").Range;\nvar TokenIterator = require(\"../../token_iterator\").TokenIterator;\nvar FoldMode = exports.FoldMode = function () {\n};\noop.inherits(FoldMode, BaseFoldMode);\n(function () {\n    this.indentKeywords = {\n        \"class\": 1,\n        \"def\": 1,\n        \"module\": 1,\n        \"do\": 1,\n        \"unless\": 1,\n        \"if\": 1,\n        \"while\": 1,\n        \"for\": 1,\n        \"until\": 1,\n        \"begin\": 1,\n        \"else\": 0,\n        \"elsif\": 0,\n        \"rescue\": 0,\n        \"ensure\": 0,\n        \"when\": 0,\n        \"end\": -1,\n        \"case\": 1,\n        \"=begin\": 1,\n        \"=end\": -1\n    };\n    this.foldingStartMarker = /(?:\\s|^)(def|do|while|class|unless|module|if|for|until|begin|else|elsif|case|rescue|ensure|when)\\b|({\\s*$)|(=begin)/;\n    this.foldingStopMarker = /(=end(?=$|\\s.*$))|(^\\s*})|\\b(end)\\b/;\n    this.getFoldWidget = function (session, foldStyle, row) {\n        var line = session.getLine(row);\n        var isStart = this.foldingStartMarker.test(line);\n        var isEnd = this.foldingStopMarker.test(line);\n        if (isStart && !isEnd) {\n            var match = line.match(this.foldingStartMarker);\n            if (match[1]) {\n                if (match[1] == \"if\" || match[1] == \"else\" || match[1] == \"while\" || match[1] == \"until\" || match[1] == \"unless\") {\n                    if (match[1] == \"else\" && /^\\s*else\\s*$/.test(line) === false) {\n                        return;\n                    }\n                    if (/^\\s*(?:if|else|while|until|unless)\\s*/.test(line) === false) {\n                        return;\n                    }\n                }\n                if (match[1] == \"when\") {\n                    if (/\\sthen\\s/.test(line) === true) {\n                        return;\n                    }\n                }\n                if (session.getTokenAt(row, match.index + 2).type === \"keyword\")\n                    return \"start\";\n            }\n            else if (match[3]) {\n                if (session.getTokenAt(row, match.index + 1).type === \"comment.multiline\")\n                    return \"start\";\n            }\n            else {\n                return \"start\";\n            }\n        }\n        if (foldStyle != \"markbeginend\" || !isEnd || isStart && isEnd)\n            return \"\";\n        var match = line.match(this.foldingStopMarker);\n        if (match[3] === \"end\") {\n            if (session.getTokenAt(row, match.index + 1).type === \"keyword\")\n                return \"end\";\n        }\n        else if (match[1]) {\n            if (session.getTokenAt(row, match.index + 1).type === \"comment.multiline\")\n                return \"end\";\n        }\n        else\n            return \"end\";\n    };\n    this.getFoldWidgetRange = function (session, foldStyle, row) {\n        var line = session.doc.getLine(row);\n        var match = this.foldingStartMarker.exec(line);\n        if (match) {\n            if (match[1] || match[3])\n                return this.rubyBlock(session, row, match.index + 2);\n            return this.openingBracketBlock(session, \"{\", row, match.index);\n        }\n        var match = this.foldingStopMarker.exec(line);\n        if (match) {\n            if (match[3] === \"end\") {\n                if (session.getTokenAt(row, match.index + 1).type === \"keyword\")\n                    return this.rubyBlock(session, row, match.index + 1);\n            }\n            if (match[1] === \"=end\") {\n                if (session.getTokenAt(row, match.index + 1).type === \"comment.multiline\")\n                    return this.rubyBlock(session, row, match.index + 1);\n            }\n            return this.closingBracketBlock(session, \"}\", row, match.index + match[0].length);\n        }\n    };\n    this.rubyBlock = function (session, row, column, tokenRange) {\n        var stream = new TokenIterator(session, row, column);\n        var token = stream.getCurrentToken();\n        if (!token || (token.type != \"keyword\" && token.type != \"comment.multiline\"))\n            return;\n        var val = token.value;\n        var line = session.getLine(row);\n        switch (token.value) {\n            case \"if\":\n            case \"unless\":\n            case \"while\":\n            case \"until\":\n                var checkToken = new RegExp(\"^\\\\s*\" + token.value);\n                if (!checkToken.test(line)) {\n                    return;\n                }\n                var dir = this.indentKeywords[val];\n                break;\n            case \"when\":\n                if (/\\sthen\\s/.test(line)) {\n                    return;\n                }\n            case \"elsif\":\n            case \"rescue\":\n            case \"ensure\":\n                var dir = 1;\n                break;\n            case \"else\":\n                var checkToken = new RegExp(\"^\\\\s*\" + token.value + \"\\\\s*$\");\n                if (!checkToken.test(line)) {\n                    return;\n                }\n                var dir = 1;\n                break;\n            default:\n                var dir = this.indentKeywords[val];\n                break;\n        }\n        var stack = [val];\n        if (!dir)\n            return;\n        var startColumn = dir === -1 ? session.getLine(row - 1).length : session.getLine(row).length;\n        var startRow = row;\n        var ranges = [];\n        ranges.push(stream.getCurrentTokenRange());\n        stream.step = dir === -1 ? stream.stepBackward : stream.stepForward;\n        if (token.type == \"comment.multiline\") {\n            while (token = stream.step()) {\n                if (token.type !== \"comment.multiline\")\n                    continue;\n                if (dir == 1) {\n                    startColumn = 6;\n                    if (token.value == \"=end\") {\n                        break;\n                    }\n                }\n                else {\n                    if (token.value == \"=begin\") {\n                        break;\n                    }\n                }\n            }\n        }\n        else {\n            while (token = stream.step()) {\n                var ignore = false;\n                if (token.type !== \"keyword\")\n                    continue;\n                var level = dir * this.indentKeywords[token.value];\n                line = session.getLine(stream.getCurrentTokenRow());\n                switch (token.value) {\n                    case \"do\":\n                        for (var i = stream.$tokenIndex - 1; i >= 0; i--) {\n                            var prevToken = stream.$rowTokens[i];\n                            if (prevToken && (prevToken.value == \"while\" || prevToken.value == \"until\" || prevToken.value == \"for\")) {\n                                level = 0;\n                                break;\n                            }\n                        }\n                        break;\n                    case \"else\":\n                        var checkToken = new RegExp(\"^\\\\s*\" + token.value + \"\\\\s*$\");\n                        if (!checkToken.test(line) || val == \"case\") {\n                            level = 0;\n                            ignore = true;\n                        }\n                        break;\n                    case \"if\":\n                    case \"unless\":\n                    case \"while\":\n                    case \"until\":\n                        var checkToken = new RegExp(\"^\\\\s*\" + token.value);\n                        if (!checkToken.test(line)) {\n                            level = 0;\n                            ignore = true;\n                        }\n                        break;\n                    case \"when\":\n                        if (/\\sthen\\s/.test(line) || val == \"case\") {\n                            level = 0;\n                            ignore = true;\n                        }\n                        break;\n                }\n                if (level > 0) {\n                    stack.unshift(token.value);\n                }\n                else if (level <= 0 && ignore === false) {\n                    stack.shift();\n                    if (!stack.length) {\n                        if ((val == \"while\" || val == \"until\" || val == \"for\") && token.value != \"do\") {\n                            break;\n                        }\n                        if (token.value == \"do\" && dir == -1 && level != 0)\n                            break;\n                        if (token.value != \"do\")\n                            break;\n                    }\n                    if (level === 0) {\n                        stack.unshift(token.value);\n                    }\n                }\n            }\n        }\n        if (!token)\n            return null;\n        if (tokenRange) {\n            ranges.push(stream.getCurrentTokenRange());\n            return ranges;\n        }\n        var row = stream.getCurrentTokenRow();\n        if (dir === -1) {\n            if (token.type === \"comment.multiline\") {\n                var endColumn = 6;\n            }\n            else {\n                var endColumn = session.getLine(row).length;\n            }\n            return new Range(row, endColumn, startRow - 1, startColumn);\n        }\n        else\n            return new Range(startRow, startColumn, row - 1, session.getLine(row - 1).length);\n    };\n}).call(FoldMode.prototype);\n\n});\n\nace.define(\"ace/mode/ruby\",[\"require\",\"exports\",\"module\",\"ace/lib/oop\",\"ace/mode/text\",\"ace/mode/ruby_highlight_rules\",\"ace/mode/matching_brace_outdent\",\"ace/range\",\"ace/mode/folding/ruby\"], function(require, exports, module){\"use strict\";\nvar oop = require(\"../lib/oop\");\nvar TextMode = require(\"./text\").Mode;\nvar RubyHighlightRules = require(\"./ruby_highlight_rules\").RubyHighlightRules;\nvar MatchingBraceOutdent = require(\"./matching_brace_outdent\").MatchingBraceOutdent;\nvar Range = require(\"../range\").Range;\nvar FoldMode = require(\"./folding/ruby\").FoldMode;\nvar Mode = function () {\n    this.HighlightRules = RubyHighlightRules;\n    this.$outdent = new MatchingBraceOutdent();\n    this.$behaviour = this.$defaultBehaviour;\n    this.foldingRules = new FoldMode();\n    this.indentKeywords = this.foldingRules.indentKeywords;\n};\noop.inherits(Mode, TextMode);\n(function () {\n    this.lineCommentStart = \"#\";\n    this.getNextLineIndent = function (state, line, tab) {\n        var indent = this.$getIndent(line);\n        var tokenizedLine = this.getTokenizer().getLineTokens(line, state);\n        var tokens = tokenizedLine.tokens;\n        if (tokens.length && tokens[tokens.length - 1].type == \"comment\") {\n            return indent;\n        }\n        if (state == \"start\") {\n            var match = line.match(/^.*[\\{\\(\\[]\\s*$/);\n            var startingClassOrMethod = line.match(/^\\s*(class|def|module)\\s.*$/);\n            var startingDoBlock = line.match(/.*do(\\s*|\\s+\\|.*\\|\\s*)$/);\n            var startingConditional = line.match(/^\\s*(if|else|when|elsif|unless|while|for|begin|rescue|ensure)\\s*/);\n            if (match || startingClassOrMethod || startingDoBlock || startingConditional) {\n                indent += tab;\n            }\n        }\n        return indent;\n    };\n    this.checkOutdent = function (state, line, input) {\n        return /^\\s+(end|else|rescue|ensure)$/.test(line + input) || this.$outdent.checkOutdent(line, input);\n    };\n    this.autoOutdent = function (state, session, row) {\n        var line = session.getLine(row);\n        if (/}/.test(line))\n            return this.$outdent.autoOutdent(session, row);\n        var indent = this.$getIndent(line);\n        var prevLine = session.getLine(row - 1);\n        var prevIndent = this.$getIndent(prevLine);\n        var tab = session.getTabString();\n        if (prevIndent.length <= indent.length) {\n            if (indent.slice(-tab.length) == tab)\n                session.remove(new Range(row, indent.length - tab.length, row, indent.length));\n        }\n    };\n    this.getMatching = function (session, row, column) {\n        if (row == undefined) {\n            var pos = session.selection.lead;\n            column = pos.column;\n            row = pos.row;\n        }\n        var startToken = session.getTokenAt(row, column);\n        if (startToken && startToken.value in this.indentKeywords)\n            return this.foldingRules.rubyBlock(session, row, column, true);\n    };\n    this.$id = \"ace/mode/ruby\";\n    this.snippetFileId = \"ace/snippets/ruby\";\n}).call(Mode.prototype);\nexports.Mode = Mode;\n\n});                (function() {\n                    ace.require([\"ace/mode/ruby\"], function(m) {\n                        if (typeof module == \"object\" && typeof exports == \"object\" && module) {\n                            module.exports = m;\n                        }\n                    });\n                })();\n            "],"names":["require","exports","module","oop","TextHighlightRules","constantOtherSymbol","constantNumericHex","constantNumericBinary","constantNumericDecimal","constantNumericOctal","constantNumericRational","constantNumericComplex","constantNumericFloat","instanceVariable","RubyHighlightRules","builtinFunctions","keywords","buildinConstants","builtinVariables","keywordMapper","escapedChars","closeParen","val","state","stack","paren","value","currentState","next","tokens","Range","MatchingBraceOutdent","line","input","doc","row","match","column","openBracePos","indent","BaseFoldMode","TokenIterator","FoldMode","session","foldStyle","isStart","isEnd","tokenRange","stream","token","checkToken","dir","startColumn","startRow","ranges","ignore","level","i","prevToken","endColumn","TextMode","Mode","tab","tokenizedLine","startingClassOrMethod","startingDoBlock","startingConditional","prevLine","prevIndent","pos","startToken","m"],"mappings":"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","x_google_ignoreList":[0]}