PageRenderTime 38ms CodeModel.GetById 13ms RepoModel.GetById 0ms app.codeStats 0ms

/files/ace/1.1.5/noconflict/mode-typescript.js

https://gitlab.com/Mirros/jsdelivr
JavaScript | 1018 lines | 946 code | 72 blank | 0 comment | 124 complexity | aa89c43cc2328b8f7c5097b8cc92274f MD5 | raw file
    

  1. ace.define("ace/mode/doc_comment_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {
    2. 

  2. "use strict";
    3. 

  3. 

  4. var oop = require("../lib/oop");
    5. 

  5. var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
    6. 

  6. 

  7. var DocCommentHighlightRules = function() {
    8. 

  8. 

  9.     this.$rules = {
    10. 

  10.         "start" : [ {
    11. 

  11.             token : "comment.doc.tag",
    12. 

  12.             regex : "@[\\w\\d_]+" // TODO: fix email addresses
    13. 

  13.         }, {
    14. 

  14.             token : "comment.doc.tag",
    15. 

  15.             regex : "\\bTODO\\b"
    16. 

  16.         }, {
    17. 

  17.             defaultToken : "comment.doc"
    18. 

  18.         }]
    19. 

  19.     };
    20. 

  20. };
    21. 

  21. 

  22. oop.inherits(DocCommentHighlightRules, TextHighlightRules);
    23. 

  23. 

  24. DocCommentHighlightRules.getStartRule = function(start) {
    25. 

  25.     return {
    26. 

  26.         token : "comment.doc", // doc comment
    27. 

  27.         regex : "\\/\\*(?=\\*)",
    28. 

  28.         next  : start
    29. 

  29.     };
    30. 

  30. };
    31. 

  31. 

  32. DocCommentHighlightRules.getEndRule = function (start) {
    33. 

  33.     return {
    34. 

  34.         token : "comment.doc", // closing comment
    35. 

  35.         regex : "\\*\\/",
    36. 

  36.         next  : start
    37. 

  37.     };
    38. 

  38. };
    39. 

  39. 

  40. 

  41. exports.DocCommentHighlightRules = DocCommentHighlightRules;
    42. 

  42. 

  43. });
    44. 

  44. 

  45. ace.define("ace/mode/javascript_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/doc_comment_highlight_rules","ace/mode/text_highlight_rules"], function(require, exports, module) {
    46. 

  46. "use strict";
    47. 

  47. 

  48. var oop = require("../lib/oop");
    49. 

  49. var DocCommentHighlightRules = require("./doc_comment_highlight_rules").DocCommentHighlightRules;
    50. 

  50. var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
    51. 

  51. 

  52. var JavaScriptHighlightRules = function() {
    53. 

  53.     var keywordMapper = this.createKeywordMapper({
    54. 

  54.         "variable.language":
    55. 

  55.             "Array|Boolean|Date|Function|Iterator|Number|Object|RegExp|String|Proxy|"  + // Constructors
    56. 

  56.             "Namespace|QName|XML|XMLList|"                                             + // E4X
    57. 

  57.             "ArrayBuffer|Float32Array|Float64Array|Int16Array|Int32Array|Int8Array|"   +
    58. 

  58.             "Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray|"                    +
    59. 

  59.             "Error|EvalError|InternalError|RangeError|ReferenceError|StopIteration|"   + // Errors
    60. 

  60.             "SyntaxError|TypeError|URIError|"                                          +
    61. 

  61.             "decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|" + // Non-constructor functions
    62. 

  62.             "isNaN|parseFloat|parseInt|"                                               +
    63. 

  63.             "JSON|Math|"                                                               + // Other
    64. 

  64.             "this|arguments|prototype|window|document"                                 , // Pseudo
    65. 

  65.         "keyword":
    66. 

  66.             "const|yield|import|get|set|" +
    67. 

  67.             "break|case|catch|continue|default|delete|do|else|finally|for|function|" +
    68. 

  68.             "if|in|instanceof|new|return|switch|throw|try|typeof|let|var|while|with|debugger|" +
    69. 

  69.             "__parent__|__count__|escape|unescape|with|__proto__|" +
    70. 

  70.             "class|enum|extends|super|export|implements|private|public|interface|package|protected|static",
    71. 

  71.         "storage.type":
    72. 

  72.             "const|let|var|function",
    73. 

  73.         "constant.language":
    74. 

  74.             "null|Infinity|NaN|undefined",
    75. 

  75.         "support.function":
    76. 

  76.             "alert",
    77. 

  77.         "constant.language.boolean": "true|false"
    78. 

  78.     }, "identifier");
    79. 

  79.     var kwBeforeRe = "case|do|else|finally|in|instanceof|return|throw|try|typeof|yield|void";
    80. 

  80.     var identifierRe = "[a-zA-Z\\$_\u00a1-\uffff][a-zA-Z\\d\\$_\u00a1-\uffff]*\\b";
    81. 

  81. 

  82.     var escapedRe = "\\\\(?:x[0-9a-fA-F]{2}|" + // hex
    83. 

  83.         "u[0-9a-fA-F]{4}|" + // unicode
    84. 

  84.         "[0-2][0-7]{0,2}|" + // oct
    85. 

  85.         "3[0-6][0-7]?|" + // oct
    86. 

  86.         "37[0-7]?|" + // oct
    87. 

  87.         "[4-7][0-7]?|" + //oct
    88. 

  88.         ".)";
    89. 

  89. 

  90.     this.$rules = {
    91. 

  91.         "no_regex" : [
    92. 

  92.             {
    93. 

  93.                 token : "comment",
    94. 

  94.                 regex : "\\/\\/",
    95. 

  95.                 next : "line_comment"
    96. 

  96.             },
    97. 

  97.             DocCommentHighlightRules.getStartRule("doc-start"),
    98. 

  98.             {
    99. 

  99.                 token : "comment", // multi line comment
    100. 

  100.                 regex : /\/\*/,
    101. 

  101.                 next : "comment"
    102. 

  102.             }, {
    103. 

  103.                 token : "string",
    104. 

  104.                 regex : "'(?=.)",
    105. 

  105.                 next  : "qstring"
    106. 

  106.             }, {
    107. 

  107.                 token : "string",
    108. 

  108.                 regex : '"(?=.)',
    109. 

  109.                 next  : "qqstring"
    110. 

  110.             }, {
    111. 

  111.                 token : "constant.numeric", // hex
    112. 

  112.                 regex : /0[xX][0-9a-fA-F]+\b/
    113. 

  113.             }, {
    114. 

  114.                 token : "constant.numeric", // float
    115. 

  115.                 regex : /[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/
    116. 

  116.             }, {
    117. 

  117.                 token : [
    118. 

  118.                     "storage.type", "punctuation.operator", "support.function",
    119. 

  119.                     "punctuation.operator", "entity.name.function", "text","keyword.operator"
    120. 

  120.                 ],
    121. 

  121.                 regex : "(" + identifierRe + ")(\\.)(prototype)(\\.)(" + identifierRe +")(\\s*)(=)",
    122. 

  122.                 next: "function_arguments"
    123. 

  123.             }, {
    124. 

  124.                 token : [
    125. 

  125.                     "storage.type", "punctuation.operator", "entity.name.function", "text",
    126. 

  126.                     "keyword.operator", "text", "storage.type", "text", "paren.lparen"
    127. 

  127.                 ],
    128. 

  128.                 regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
    129. 

  129.                 next: "function_arguments"
    130. 

  130.             }, {
    131. 

  131.                 token : [
    132. 

  132.                     "entity.name.function", "text", "keyword.operator", "text", "storage.type",
    133. 

  133.                     "text", "paren.lparen"
    134. 

  134.                 ],
    135. 

  135.                 regex : "(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
    136. 

  136.                 next: "function_arguments"
    137. 

  137.             }, {
    138. 

  138.                 token : [
    139. 

  139.                     "storage.type", "punctuation.operator", "entity.name.function", "text",
    140. 

  140.                     "keyword.operator", "text",
    141. 

  141.                     "storage.type", "text", "entity.name.function", "text", "paren.lparen"
    142. 

  142.                 ],
    143. 

  143.                 regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s+)(\\w+)(\\s*)(\\()",
    144. 

  144.                 next: "function_arguments"
    145. 

  145.             }, {
    146. 

  146.                 token : [
    147. 

  147.                     "storage.type", "text", "entity.name.function", "text", "paren.lparen"
    148. 

  148.                 ],
    149. 

  149.                 regex : "(function)(\\s+)(" + identifierRe + ")(\\s*)(\\()",
    150. 

  150.                 next: "function_arguments"
    151. 

  151.             }, {
    152. 

  152.                 token : [
    153. 

  153.                     "entity.name.function", "text", "punctuation.operator",
    154. 

  154.                     "text", "storage.type", "text", "paren.lparen"
    155. 

  155.                 ],
    156. 

  156.                 regex : "(" + identifierRe + ")(\\s*)(:)(\\s*)(function)(\\s*)(\\()",
    157. 

  157.                 next: "function_arguments"
    158. 

  158.             }, {
    159. 

  159.                 token : [
    160. 

  160.                     "text", "text", "storage.type", "text", "paren.lparen"
    161. 

  161.                 ],
    162. 

  162.                 regex : "(:)(\\s*)(function)(\\s*)(\\()",
    163. 

  163.                 next: "function_arguments"
    164. 

  164.             }, {
    165. 

  165.                 token : "keyword",
    166. 

  166.                 regex : "(?:" + kwBeforeRe + ")\\b",
    167. 

  167.                 next : "start"
    168. 

  168.             }, {
    169. 

  169.                 token : ["punctuation.operator", "support.function"],
    170. 

  170.                 regex : /(\.)(s(?:h(?:ift|ow(?:Mod(?:elessDialog|alDialog)|Help))|croll(?:X|By(?:Pages|Lines)?|Y|To)?|t(?:op|rike)|i(?:n|zeToContent|debar|gnText)|ort|u(?:p|b(?:str(?:ing)?)?)|pli(?:ce|t)|e(?:nd|t(?:Re(?:sizable|questHeader)|M(?:i(?:nutes|lliseconds)|onth)|Seconds|Ho(?:tKeys|urs)|Year|Cursor|Time(?:out)?|Interval|ZOptions|Date|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Date|FullYear)|FullYear|Active)|arch)|qrt|lice|avePreferences|mall)|h(?:ome|andleEvent)|navigate|c(?:har(?:CodeAt|At)|o(?:s|n(?:cat|textual|firm)|mpile)|eil|lear(?:Timeout|Interval)?|a(?:ptureEvents|ll)|reate(?:StyleSheet|Popup|EventObject))|t(?:o(?:GMTString|S(?:tring|ource)|U(?:TCString|pperCase)|Lo(?:caleString|werCase))|est|a(?:n|int(?:Enabled)?))|i(?:s(?:NaN|Finite)|ndexOf|talics)|d(?:isableExternalCapture|ump|etachEvent)|u(?:n(?:shift|taint|escape|watch)|pdateCommands)|j(?:oin|avaEnabled)|p(?:o(?:p|w)|ush|lugins.refresh|a(?:ddings|rse(?:Int|Float)?)|r(?:int|ompt|eference))|e(?:scape|nableExternalCapture|val|lementFromPoint|x(?:p|ec(?:Script|Command)?))|valueOf|UTC|queryCommand(?:State|Indeterm|Enabled|Value)|f(?:i(?:nd|le(?:ModifiedDate|Size|CreatedDate|UpdatedDate)|xed)|o(?:nt(?:size|color)|rward)|loor|romCharCode)|watch|l(?:ink|o(?:ad|g)|astIndexOf)|a(?:sin|nchor|cos|t(?:tachEvent|ob|an(?:2)?)|pply|lert|b(?:s|ort))|r(?:ou(?:nd|teEvents)|e(?:size(?:By|To)|calc|turnValue|place|verse|l(?:oad|ease(?:Capture|Events)))|andom)|g(?:o|et(?:ResponseHeader|M(?:i(?:nutes|lliseconds)|onth)|Se(?:conds|lection)|Hours|Year|Time(?:zoneOffset)?|Da(?:y|te)|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Da(?:y|te)|FullYear)|FullYear|A(?:ttention|llResponseHeaders)))|m(?:in|ove(?:B(?:y|elow)|To(?:Absolute)?|Above)|ergeAttributes|a(?:tch|rgins|x))|b(?:toa|ig|o(?:ld|rderWidths)|link|ack))\b(?=\()/
    171. 

  171.             }, {
    172. 

  172.                 token : ["punctuation.operator", "support.function.dom"],
    173. 

  173.                 regex : /(\.)(s(?:ub(?:stringData|mit)|plitText|e(?:t(?:NamedItem|Attribute(?:Node)?)|lect))|has(?:ChildNodes|Feature)|namedItem|c(?:l(?:ick|o(?:se|neNode))|reate(?:C(?:omment|DATASection|aption)|T(?:Head|extNode|Foot)|DocumentFragment|ProcessingInstruction|E(?:ntityReference|lement)|Attribute))|tabIndex|i(?:nsert(?:Row|Before|Cell|Data)|tem)|open|delete(?:Row|C(?:ell|aption)|T(?:Head|Foot)|Data)|focus|write(?:ln)?|a(?:dd|ppend(?:Child|Data))|re(?:set|place(?:Child|Data)|move(?:NamedItem|Child|Attribute(?:Node)?)?)|get(?:NamedItem|Element(?:sBy(?:Name|TagName)|ById)|Attribute(?:Node)?)|blur)\b(?=\()/
    174. 

  174.             }, {
    175. 

  175.                 token : ["punctuation.operator", "support.constant"],
    176. 

  176.                 regex : /(\.)(s(?:ystemLanguage|cr(?:ipts|ollbars|een(?:X|Y|Top|Left))|t(?:yle(?:Sheets)?|atus(?:Text|bar)?)|ibling(?:Below|Above)|ource|uffixes|e(?:curity(?:Policy)?|l(?:ection|f)))|h(?:istory|ost(?:name)?|as(?:h|Focus))|y|X(?:MLDocument|SLDocument)|n(?:ext|ame(?:space(?:s|URI)|Prop))|M(?:IN_VALUE|AX_VALUE)|c(?:haracterSet|o(?:n(?:structor|trollers)|okieEnabled|lorDepth|mp(?:onents|lete))|urrent|puClass|l(?:i(?:p(?:boardData)?|entInformation)|osed|asses)|alle(?:e|r)|rypto)|t(?:o(?:olbar|p)|ext(?:Transform|Indent|Decoration|Align)|ags)|SQRT(?:1_2|2)|i(?:n(?:ner(?:Height|Width)|put)|ds|gnoreCase)|zIndex|o(?:scpu|n(?:readystatechange|Line)|uter(?:Height|Width)|p(?:sProfile|ener)|ffscreenBuffering)|NEGATIVE_INFINITY|d(?:i(?:splay|alog(?:Height|Top|Width|Left|Arguments)|rectories)|e(?:scription|fault(?:Status|Ch(?:ecked|arset)|View)))|u(?:ser(?:Profile|Language|Agent)|n(?:iqueID|defined)|pdateInterval)|_content|p(?:ixelDepth|ort|ersonalbar|kcs11|l(?:ugins|atform)|a(?:thname|dding(?:Right|Bottom|Top|Left)|rent(?:Window|Layer)?|ge(?:X(?:Offset)?|Y(?:Offset)?))|r(?:o(?:to(?:col|type)|duct(?:Sub)?|mpter)|e(?:vious|fix)))|e(?:n(?:coding|abledPlugin)|x(?:ternal|pando)|mbeds)|v(?:isibility|endor(?:Sub)?|Linkcolor)|URLUnencoded|P(?:I|OSITIVE_INFINITY)|f(?:ilename|o(?:nt(?:Size|Family|Weight)|rmName)|rame(?:s|Element)|gColor)|E|whiteSpace|l(?:i(?:stStyleType|n(?:eHeight|kColor))|o(?:ca(?:tion(?:bar)?|lName)|wsrc)|e(?:ngth|ft(?:Context)?)|a(?:st(?:M(?:odified|atch)|Index|Paren)|yer(?:s|X)|nguage))|a(?:pp(?:MinorVersion|Name|Co(?:deName|re)|Version)|vail(?:Height|Top|Width|Left)|ll|r(?:ity|guments)|Linkcolor|bove)|r(?:ight(?:Context)?|e(?:sponse(?:XML|Text)|adyState))|global|x|m(?:imeTypes|ultiline|enubar|argin(?:Right|Bottom|Top|Left))|L(?:N(?:10|2)|OG(?:10E|2E))|b(?:o(?:ttom|rder(?:Width|RightWidth|BottomWidth|Style|Color|TopWidth|LeftWidth))|ufferDepth|elow|ackground(?:Color|Image)))\b/
    177. 

  177.             }, {
    178. 

  178.                 token : ["support.constant"],
    179. 

  179.                 regex : /that\b/
    180. 

  180.             }, {
    181. 

  181.                 token : ["storage.type", "punctuation.operator", "support.function.firebug"],
    182. 

  182.                 regex : /(console)(\.)(warn|info|log|error|time|trace|timeEnd|assert)\b/
    183. 

  183.             }, {
    184. 

  184.                 token : keywordMapper,
    185. 

  185.                 regex : identifierRe
    186. 

  186.             }, {
    187. 

  187.                 token : "keyword.operator",
    188. 

  188.                 regex : /--|\+\+|[!$%&*+\-~]|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\|\||\?\:|\*=|%=|\+=|\-=|&=|\^=/,
    189. 

  189.                 next  : "start"
    190. 

  190.             }, {
    191. 

  191.                 token : "punctuation.operator",
    192. 

  192.                 regex : /\?|\:|\,|\;|\./,
    193. 

  193.                 next  : "start"
    194. 

  194.             }, {
    195. 

  195.                 token : "paren.lparen",
    196. 

  196.                 regex : /[\[({]/,
    197. 

  197.                 next  : "start"
    198. 

  198.             }, {
    199. 

  199.                 token : "paren.rparen",
    200. 

  200.                 regex : /[\])}]/
    201. 

  201.             }, {
    202. 

  202.                 token : "keyword.operator",
    203. 

  203.                 regex : /\/=?/,
    204. 

  204.                 next  : "start"
    205. 

  205.             }, {
    206. 

  206.                 token: "comment",
    207. 

  207.                 regex: /^#!.*$/
    208. 

  208.             }
    209. 

  209.         ],
    210. 

  210.         "start": [
    211. 

  211.             DocCommentHighlightRules.getStartRule("doc-start"),
    212. 

  212.             {
    213. 

  213.                 token : "comment", // multi line comment
    214. 

  214.                 regex : "\\/\\*",
    215. 

  215.                 next : "comment_regex_allowed"
    216. 

  216.             }, {
    217. 

  217.                 token : "comment",
    218. 

  218.                 regex : "\\/\\/",
    219. 

  219.                 next : "line_comment_regex_allowed"
    220. 

  220.             }, {
    221. 

  221.                 token: "string.regexp",
    222. 

  222.                 regex: "\\/",
    223. 

  223.                 next: "regex"
    224. 

  224.             }, {
    225. 

  225.                 token : "text",
    226. 

  226.                 regex : "\\s+|^$",
    227. 

  227.                 next : "start"
    228. 

  228.             }, {
    229. 

  229.                 token: "empty",
    230. 

  230.                 regex: "",
    231. 

  231.                 next: "no_regex"
    232. 

  232.             }
    233. 

  233.         ],
    234. 

  234.         "regex": [
    235. 

  235.             {
    236. 

  236.                 token: "regexp.keyword.operator",
    237. 

  237.                 regex: "\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"
    238. 

  238.             }, {
    239. 

  239.                 token: "string.regexp",
    240. 

  240.                 regex: "/[sxngimy]*",
    241. 

  241.                 next: "no_regex"
    242. 

  242.             }, {
    243. 

  243.                 token : "invalid",
    244. 

  244.                 regex: /\{\d+\b,?\d*\}[+*]|[+*$^?][+*]|[$^][?]|\?{3,}/
    245. 

  245.             }, {
    246. 

  246.                 token : "constant.language.escape",
    247. 

  247.                 regex: /\(\?[:=!]|\)|\{\d+\b,?\d*\}|[+*]\?|[()$^+*?.]/
    248. 

  248.             }, {
    249. 

  249.                 token : "constant.language.delimiter",
    250. 

  250.                 regex: /\|/
    251. 

  251.             }, {
    252. 

  252.                 token: "constant.language.escape",
    253. 

  253.                 regex: /\[\^?/,
    254. 

  254.                 next: "regex_character_class"
    255. 

  255.             }, {
    256. 

  256.                 token: "empty",
    257. 

  257.                 regex: "$",
    258. 

  258.                 next: "no_regex"
    259. 

  259.             }, {
    260. 

  260.                 defaultToken: "string.regexp"
    261. 

  261.             }
    262. 

  262.         ],
    263. 

  263.         "regex_character_class": [
    264. 

  264.             {
    265. 

  265.                 token: "regexp.keyword.operator",
    266. 

  266.                 regex: "\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"
    267. 

  267.             }, {
    268. 

  268.                 token: "constant.language.escape",
    269. 

  269.                 regex: "]",
    270. 

  270.                 next: "regex"
    271. 

  271.             }, {
    272. 

  272.                 token: "constant.language.escape",
    273. 

  273.                 regex: "-"
    274. 

  274.             }, {
    275. 

  275.                 token: "empty",
    276. 

  276.                 regex: "$",
    277. 

  277.                 next: "no_regex"
    278. 

  278.             }, {
    279. 

  279.                 defaultToken: "string.regexp.charachterclass"
    280. 

  280.             }
    281. 

  281.         ],
    282. 

  282.         "function_arguments": [
    283. 

  283.             {
    284. 

  284.                 token: "variable.parameter",
    285. 

  285.                 regex: identifierRe
    286. 

  286.             }, {
    287. 

  287.                 token: "punctuation.operator",
    288. 

  288.                 regex: "[, ]+"
    289. 

  289.             }, {
    290. 

  290.                 token: "punctuation.operator",
    291. 

  291.                 regex: "$"
    292. 

  292.             }, {
    293. 

  293.                 token: "empty",
    294. 

  294.                 regex: "",
    295. 

  295.                 next: "no_regex"
    296. 

  296.             }
    297. 

  297.         ],
    298. 

  298.         "comment_regex_allowed" : [
    299. 

  299.             {token : "comment", regex : "\\*\\/", next : "start"},
    300. 

  300.             {defaultToken : "comment"}
    301. 

  301.         ],
    302. 

  302.         "comment" : [
    303. 

  303.             {token : "comment", regex : "\\*\\/", next : "no_regex"},
    304. 

  304.             {defaultToken : "comment"}
    305. 

  305.         ],
    306. 

  306.         "line_comment_regex_allowed" : [
    307. 

  307.             {token : "comment", regex : "$|^", next : "start"},
    308. 

  308.             {defaultToken : "comment"}
    309. 

  309.         ],
    310. 

  310.         "line_comment" : [
    311. 

  311.             {token : "comment", regex : "$|^", next : "no_regex"},
    312. 

  312.             {defaultToken : "comment"}
    313. 

  313.         ],
    314. 

  314.         "qqstring" : [
    315. 

  315.             {
    316. 

  316.                 token : "constant.language.escape",
    317. 

  317.                 regex : escapedRe
    318. 

  318.             }, {
    319. 

  319.                 token : "string",
    320. 

  320.                 regex : "\\\\$",
    321. 

  321.                 next  : "qqstring"
    322. 

  322.             }, {
    323. 

  323.                 token : "string",
    324. 

  324.                 regex : '"|$',
    325. 

  325.                 next  : "no_regex"
    326. 

  326.             }, {
    327. 

  327.                 defaultToken: "string"
    328. 

  328.             }
    329. 

  329.         ],
    330. 

  330.         "qstring" : [
    331. 

  331.             {
    332. 

  332.                 token : "constant.language.escape",
    333. 

  333.                 regex : escapedRe
    334. 

  334.             }, {
    335. 

  335.                 token : "string",
    336. 

  336.                 regex : "\\\\$",
    337. 

  337.                 next  : "qstring"
    338. 

  338.             }, {
    339. 

  339.                 token : "string",
    340. 

  340.                 regex : "'|$",
    341. 

  341.                 next  : "no_regex"
    342. 

  342.             }, {
    343. 

  343.                 defaultToken: "string"
    344. 

  344.             }
    345. 

  345.         ]
    346. 

  346.     };
    347. 

  347. 

  348.     this.embedRules(DocCommentHighlightRules, "doc-",
    349. 

  349.         [ DocCommentHighlightRules.getEndRule("no_regex") ]);
    350. 

  350. };
    351. 

  351. 

  352. oop.inherits(JavaScriptHighlightRules, TextHighlightRules);
    353. 

  353. 

  354. exports.JavaScriptHighlightRules = JavaScriptHighlightRules;
    355. 

  355. });
    356. 

  356. 

  357. ace.define("ace/mode/matching_brace_outdent",["require","exports","module","ace/range"], function(require, exports, module) {
    358. 

  358. "use strict";
    359. 

  359. 

  360. var Range = require("../range").Range;
    361. 

  361. 

  362. var MatchingBraceOutdent = function() {};
    363. 

  363. 

  364. (function() {
    365. 

  365. 

  366.     this.checkOutdent = function(line, input) {
    367. 

  367.         if (! /^\s+$/.test(line))
    368. 

  368.             return false;
    369. 

  369. 

  370.         return /^\s*\}/.test(input);
    371. 

  371.     };
    372. 

  372. 

  373.     this.autoOutdent = function(doc, row) {
    374. 

  374.         var line = doc.getLine(row);
    375. 

  375.         var match = line.match(/^(\s*\})/);
    376. 

  376. 

  377.         if (!match) return 0;
    378. 

  378. 

  379.         var column = match[1].length;
    380. 

  380.         var openBracePos = doc.findMatchingBracket({row: row, column: column});
    381. 

  381. 

  382.         if (!openBracePos || openBracePos.row == row) return 0;
    383. 

  383. 

  384.         var indent = this.$getIndent(doc.getLine(openBracePos.row));
    385. 

  385.         doc.replace(new Range(row, 0, row, column-1), indent);
    386. 

  386.     };
    387. 

  387. 

  388.     this.$getIndent = function(line) {
    389. 

  389.         return line.match(/^\s*/)[0];
    390. 

  390.     };
    391. 

  391. 

  392. }).call(MatchingBraceOutdent.prototype);
    393. 

  393. 

  394. exports.MatchingBraceOutdent = MatchingBraceOutdent;
    395. 

  395. });
    396. 

  396. 

  397. ace.define("ace/mode/behaviour/cstyle",["require","exports","module","ace/lib/oop","ace/mode/behaviour","ace/token_iterator","ace/lib/lang"], function(require, exports, module) {
    398. 

  398. "use strict";
    399. 

  399. 

  400. var oop = require("../../lib/oop");
    401. 

  401. var Behaviour = require("../behaviour").Behaviour;
    402. 

  402. var TokenIterator = require("../../token_iterator").TokenIterator;
    403. 

  403. var lang = require("../../lib/lang");
    404. 

  404. 

  405. var SAFE_INSERT_IN_TOKENS =
    406. 

  406.     ["text", "paren.rparen", "punctuation.operator"];
    407. 

  407. var SAFE_INSERT_BEFORE_TOKENS =
    408. 

  408.     ["text", "paren.rparen", "punctuation.operator", "comment"];
    409. 

  409. 

  410. var context;
    411. 

  411. var contextCache = {}
    412. 

  412. var initContext = function(editor) {
    413. 

  413.     var id = -1;
    414. 

  414.     if (editor.multiSelect) {
    415. 

  415.         id = editor.selection.id;
    416. 

  416.         if (contextCache.rangeCount != editor.multiSelect.rangeCount)
    417. 

  417.             contextCache = {rangeCount: editor.multiSelect.rangeCount};
    418. 

  418.     }
    419. 

  419.     if (contextCache[id])
    420. 

  420.         return context = contextCache[id];
    421. 

  421.     context = contextCache[id] = {
    422. 

  422.         autoInsertedBrackets: 0,
    423. 

  423.         autoInsertedRow: -1,
    424. 

  424.         autoInsertedLineEnd: "",
    425. 

  425.         maybeInsertedBrackets: 0,
    426. 

  426.         maybeInsertedRow: -1,
    427. 

  427.         maybeInsertedLineStart: "",
    428. 

  428.         maybeInsertedLineEnd: ""
    429. 

  429.     };
    430. 

  430. };
    431. 

  431. 

  432. var CstyleBehaviour = function() {
    433. 

  433.     this.add("braces", "insertion", function(state, action, editor, session, text) {
    434. 

  434.         var cursor = editor.getCursorPosition();
    435. 

  435.         var line = session.doc.getLine(cursor.row);
    436. 

  436.         if (text == '{') {
    437. 

  437.             initContext(editor);
    438. 

  438.             var selection = editor.getSelectionRange();
    439. 

  439.             var selected = session.doc.getTextRange(selection);
    440. 

  440.             if (selected !== "" && selected !== "{" && editor.getWrapBehavioursEnabled()) {
    441. 

  441.                 return {
    442. 

  442.                     text: '{' + selected + '}',
    443. 

  443.                     selection: false
    444. 

  444.                 };
    445. 

  445.             } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
    446. 

  446.                 if (/[\]\}\)]/.test(line[cursor.column]) || editor.inMultiSelectMode) {
    447. 

  447.                     CstyleBehaviour.recordAutoInsert(editor, session, "}");
    448. 

  448.                     return {
    449. 

  449.                         text: '{}',
    450. 

  450.                         selection: [1, 1]
    451. 

  451.                     };
    452. 

  452.                 } else {
    453. 

  453.                     CstyleBehaviour.recordMaybeInsert(editor, session, "{");
    454. 

  454.                     return {
    455. 

  455.                         text: '{',
    456. 

  456.                         selection: [1, 1]
    457. 

  457.                     };
    458. 

  458.                 }
    459. 

  459.             }
    460. 

  460.         } else if (text == '}') {
    461. 

  461.             initContext(editor);
    462. 

  462.             var rightChar = line.substring(cursor.column, cursor.column + 1);
    463. 

  463.             if (rightChar == '}') {
    464. 

  464.                 var matching = session.$findOpeningBracket('}', {column: cursor.column + 1, row: cursor.row});
    465. 

  465.                 if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
    466. 

  466.                     CstyleBehaviour.popAutoInsertedClosing();
    467. 

  467.                     return {
    468. 

  468.                         text: '',
    469. 

  469.                         selection: [1, 1]
    470. 

  470.                     };
    471. 

  471.                 }
    472. 

  472.             }
    473. 

  473.         } else if (text == "\n" || text == "\r\n") {
    474. 

  474.             initContext(editor);
    475. 

  475.             var closing = "";
    476. 

  476.             if (CstyleBehaviour.isMaybeInsertedClosing(cursor, line)) {
    477. 

  477.                 closing = lang.stringRepeat("}", context.maybeInsertedBrackets);
    478. 

  478.                 CstyleBehaviour.clearMaybeInsertedClosing();
    479. 

  479.             }
    480. 

  480.             var rightChar = line.substring(cursor.column, cursor.column + 1);
    481. 

  481.             if (rightChar === '}') {
    482. 

  482.                 var openBracePos = session.findMatchingBracket({row: cursor.row, column: cursor.column+1}, '}');
    483. 

  483.                 if (!openBracePos)
    484. 

  484.                      return null;
    485. 

  485.                 var next_indent = this.$getIndent(session.getLine(openBracePos.row));
    486. 

  486.             } else if (closing) {
    487. 

  487.                 var next_indent = this.$getIndent(line);
    488. 

  488.             } else {
    489. 

  489.                 CstyleBehaviour.clearMaybeInsertedClosing();
    490. 

  490.                 return;
    491. 

  491.             }
    492. 

  492.             var indent = next_indent + session.getTabString();
    493. 

  493. 

  494.             return {
    495. 

  495.                 text: '\n' + indent + '\n' + next_indent + closing,
    496. 

  496.                 selection: [1, indent.length, 1, indent.length]
    497. 

  497.             };
    498. 

  498.         } else {
    499. 

  499.             CstyleBehaviour.clearMaybeInsertedClosing();
    500. 

  500.         }
    501. 

  501.     });
    502. 

  502. 

  503.     this.add("braces", "deletion", function(state, action, editor, session, range) {
    504. 

  504.         var selected = session.doc.getTextRange(range);
    505. 

  505.         if (!range.isMultiLine() && selected == '{') {
    506. 

  506.             initContext(editor);
    507. 

  507.             var line = session.doc.getLine(range.start.row);
    508. 

  508.             var rightChar = line.substring(range.end.column, range.end.column + 1);
    509. 

  509.             if (rightChar == '}') {
    510. 

  510.                 range.end.column++;
    511. 

  511.                 return range;
    512. 

  512.             } else {
    513. 

  513.                 context.maybeInsertedBrackets--;
    514. 

  514.             }
    515. 

  515.         }
    516. 

  516.     });
    517. 

  517. 

  518.     this.add("parens", "insertion", function(state, action, editor, session, text) {
    519. 

  519.         if (text == '(') {
    520. 

  520.             initContext(editor);
    521. 

  521.             var selection = editor.getSelectionRange();
    522. 

  522.             var selected = session.doc.getTextRange(selection);
    523. 

  523.             if (selected !== "" && editor.getWrapBehavioursEnabled()) {
    524. 

  524.                 return {
    525. 

  525.                     text: '(' + selected + ')',
    526. 

  526.                     selection: false
    527. 

  527.                 };
    528. 

  528.             } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
    529. 

  529.                 CstyleBehaviour.recordAutoInsert(editor, session, ")");
    530. 

  530.                 return {
    531. 

  531.                     text: '()',
    532. 

  532.                     selection: [1, 1]
    533. 

  533.                 };
    534. 

  534.             }
    535. 

  535.         } else if (text == ')') {
    536. 

  536.             initContext(editor);
    537. 

  537.             var cursor = editor.getCursorPosition();
    538. 

  538.             var line = session.doc.getLine(cursor.row);
    539. 

  539.             var rightChar = line.substring(cursor.column, cursor.column + 1);
    540. 

  540.             if (rightChar == ')') {
    541. 

  541.                 var matching = session.$findOpeningBracket(')', {column: cursor.column + 1, row: cursor.row});
    542. 

  542.                 if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
    543. 

  543.                     CstyleBehaviour.popAutoInsertedClosing();
    544. 

  544.                     return {
    545. 

  545.                         text: '',
    546. 

  546.                         selection: [1, 1]
    547. 

  547.                     };
    548. 

  548.                 }
    549. 

  549.             }
    550. 

  550.         }
    551. 

  551.     });
    552. 

  552. 

  553.     this.add("parens", "deletion", function(state, action, editor, session, range) {
    554. 

  554.         var selected = session.doc.getTextRange(range);
    555. 

  555.         if (!range.isMultiLine() && selected == '(') {
    556. 

  556.             initContext(editor);
    557. 

  557.             var line = session.doc.getLine(range.start.row);
    558. 

  558.             var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
    559. 

  559.             if (rightChar == ')') {
    560. 

  560.                 range.end.column++;
    561. 

  561.                 return range;
    562. 

  562.             }
    563. 

  563.         }
    564. 

  564.     });
    565. 

  565. 

  566.     this.add("brackets", "insertion", function(state, action, editor, session, text) {
    567. 

  567.         if (text == '[') {
    568. 

  568.             initContext(editor);
    569. 

  569.             var selection = editor.getSelectionRange();
    570. 

  570.             var selected = session.doc.getTextRange(selection);
    571. 

  571.             if (selected !== "" && editor.getWrapBehavioursEnabled()) {
    572. 

  572.                 return {
    573. 

  573.                     text: '[' + selected + ']',
    574. 

  574.                     selection: false
    575. 

  575.                 };
    576. 

  576.             } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
    577. 

  577.                 CstyleBehaviour.recordAutoInsert(editor, session, "]");
    578. 

  578.                 return {
    579. 

  579.                     text: '[]',
    580. 

  580.                     selection: [1, 1]
    581. 

  581.                 };
    582. 

  582.             }
    583. 

  583.         } else if (text == ']') {
    584. 

  584.             initContext(editor);
    585. 

  585.             var cursor = editor.getCursorPosition();
    586. 

  586.             var line = session.doc.getLine(cursor.row);
    587. 

  587.             var rightChar = line.substring(cursor.column, cursor.column + 1);
    588. 

  588.             if (rightChar == ']') {
    589. 

  589.                 var matching = session.$findOpeningBracket(']', {column: cursor.column + 1, row: cursor.row});
    590. 

  590.                 if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
    591. 

  591.                     CstyleBehaviour.popAutoInsertedClosing();
    592. 

  592.                     return {
    593. 

  593.                         text: '',
    594. 

  594.                         selection: [1, 1]
    595. 

  595.                     };
    596. 

  596.                 }
    597. 

  597.             }
    598. 

  598.         }
    599. 

  599.     });
    600. 

  600. 

  601.     this.add("brackets", "deletion", function(state, action, editor, session, range) {
    602. 

  602.         var selected = session.doc.getTextRange(range);
    603. 

  603.         if (!range.isMultiLine() && selected == '[') {
    604. 

  604.             initContext(editor);
    605. 

  605.             var line = session.doc.getLine(range.start.row);
    606. 

  606.             var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
    607. 

  607.             if (rightChar == ']') {
    608. 

  608.                 range.end.column++;
    609. 

  609.                 return range;
    610. 

  610.             }
    611. 

  611.         }
    612. 

  612.     });
    613. 

  613. 

  614.     this.add("string_dquotes", "insertion", function(state, action, editor, session, text) {
    615. 

  615.         if (text == '"' || text == "'") {
    616. 

  616.             initContext(editor);
    617. 

  617.             var quote = text;
    618. 

  618.             var selection = editor.getSelectionRange();
    619. 

  619.             var selected = session.doc.getTextRange(selection);
    620. 

  620.             if (selected !== "" && selected !== "'" && selected != '"' && editor.getWrapBehavioursEnabled()) {
    621. 

  621.                 return {
    622. 

  622.                     text: quote + selected + quote,
    623. 

  623.                     selection: false
    624. 

  624.                 };
    625. 

  625.             } else {
    626. 

  626.                 var cursor = editor.getCursorPosition();
    627. 

  627.                 var line = session.doc.getLine(cursor.row);
    628. 

  628.                 var leftChar = line.substring(cursor.column-1, cursor.column);
    629. 

  629.                 if (leftChar == '\\') {
    630. 

  630.                     return null;
    631. 

  631.                 }
    632. 

  632.                 var tokens = session.getTokens(selection.start.row);
    633. 

  633.                 var col = 0, token;
    634. 

  634.                 var quotepos = -1; // Track whether we're inside an open quote.
    635. 

  635. 

  636.                 for (var x = 0; x < tokens.length; x++) {
    637. 

  637.                     token = tokens[x];
    638. 

  638.                     if (token.type == "string") {
    639. 

  639.                       quotepos = -1;
    640. 

  640.                     } else if (quotepos < 0) {
    641. 

  641.                       quotepos = token.value.indexOf(quote);
    642. 

  642.                     }
    643. 

  643.                     if ((token.value.length + col) > selection.start.column) {
    644. 

  644.                         break;
    645. 

  645.                     }
    646. 

  646.                     col += tokens[x].value.length;
    647. 

  647.                 }
    648. 

  648.                 if (!token || (quotepos < 0 && token.type !== "comment" && (token.type !== "string" || ((selection.start.column !== token.value.length+col-1) && token.value.lastIndexOf(quote) === token.value.length-1)))) {
    649. 

  649.                     if (!CstyleBehaviour.isSaneInsertion(editor, session))
    650. 

  650.                         return;
    651. 

  651.                     return {
    652. 

  652.                         text: quote + quote,
    653. 

  653.                         selection: [1,1]
    654. 

  654.                     };
    655. 

  655.                 } else if (token && token.type === "string") {
    656. 

  656.                     var rightChar = line.substring(cursor.column, cursor.column + 1);
    657. 

  657.                     if (rightChar == quote) {
    658. 

  658.                         return {
    659. 

  659.                             text: '',
    660. 

  660.                             selection: [1, 1]
    661. 

  661.                         };
    662. 

  662.                     }
    663. 

  663.                 }
    664. 

  664.             }
    665. 

  665.         }
    666. 

  666.     });
    667. 

  667. 

  668.     this.add("string_dquotes", "deletion", function(state, action, editor, session, range) {
    669. 

  669.         var selected = session.doc.getTextRange(range);
    670. 

  670.         if (!range.isMultiLine() && (selected == '"' || selected == "'")) {
    671. 

  671.             initContext(editor);
    672. 

  672.             var line = session.doc.getLine(range.start.row);
    673. 

  673.             var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
    674. 

  674.             if (rightChar == selected) {
    675. 

  675.                 range.end.column++;
    676. 

  676.                 return range;
    677. 

  677.             }
    678. 

  678.         }
    679. 

  679.     });
    680. 

  680. 

  681. };
    682. 

  682. 

  683.     
    684. 

  684. CstyleBehaviour.isSaneInsertion = function(editor, session) {
    685. 

  685.     var cursor = editor.getCursorPosition();
    686. 

  686.     var iterator = new TokenIterator(session, cursor.row, cursor.column);
    687. 

  687.     if (!this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) {
    688. 

  688.         var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1);
    689. 

  689.         if (!this.$matchTokenType(iterator2.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS))
    690. 

  690.             return false;
    691. 

  691.     }
    692. 

  692.     iterator.stepForward();
    693. 

  693.     return iterator.getCurrentTokenRow() !== cursor.row ||
    694. 

  694.         this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_BEFORE_TOKENS);
    695. 

  695. };
    696. 

  696. 

  697. CstyleBehaviour.$matchTokenType = function(token, types) {
    698. 

  698.     return types.indexOf(token.type || token) > -1;
    699. 

  699. };
    700. 

  700. 

  701. CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) {
    702. 

  702.     var cursor = editor.getCursorPosition();
    703. 

  703.     var line = session.doc.getLine(cursor.row);
    704. 

  704.     if (!this.isAutoInsertedClosing(cursor, line, context.autoInsertedLineEnd[0]))
    705. 

  705.         context.autoInsertedBrackets = 0;
    706. 

  706.     context.autoInsertedRow = cursor.row;
    707. 

  707.     context.autoInsertedLineEnd = bracket + line.substr(cursor.column);
    708. 

  708.     context.autoInsertedBrackets++;
    709. 

  709. };
    710. 

  710. 

  711. CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) {
    712. 

  712.     var cursor = editor.getCursorPosition();
    713. 

  713.     var line = session.doc.getLine(cursor.row);
    714. 

  714.     if (!this.isMaybeInsertedClosing(cursor, line))
    715. 

  715.         context.maybeInsertedBrackets = 0;
    716. 

  716.     context.maybeInsertedRow = cursor.row;
    717. 

  717.     context.maybeInsertedLineStart = line.substr(0, cursor.column) + bracket;
    718. 

  718.     context.maybeInsertedLineEnd = line.substr(cursor.column);
    719. 

  719.     context.maybeInsertedBrackets++;
    720. 

  720. };
    721. 

  721. 

  722. CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) {
    723. 

  723.     return context.autoInsertedBrackets > 0 &&
    724. 

  724.         cursor.row === context.autoInsertedRow &&
    725. 

  725.         bracket === context.autoInsertedLineEnd[0] &&
    726. 

  726.         line.substr(cursor.column) === context.autoInsertedLineEnd;
    727. 

  727. };
    728. 

  728. 

  729. CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) {
    730. 

  730.     return context.maybeInsertedBrackets > 0 &&
    731. 

  731.         cursor.row === context.maybeInsertedRow &&
    732. 

  732.         line.substr(cursor.column) === context.maybeInsertedLineEnd &&
    733. 

  733.         line.substr(0, cursor.column) == context.maybeInsertedLineStart;
    734. 

  734. };
    735. 

  735. 

  736. CstyleBehaviour.popAutoInsertedClosing = function() {
    737. 

  737.     context.autoInsertedLineEnd = context.autoInsertedLineEnd.substr(1);
    738. 

  738.     context.autoInsertedBrackets--;
    739. 

  739. };
    740. 

  740. 

  741. CstyleBehaviour.clearMaybeInsertedClosing = function() {
    742. 

  742.     if (context) {
    743. 

  743.         context.maybeInsertedBrackets = 0;
    744. 

  744.         context.maybeInsertedRow = -1;
    745. 

  745.     }
    746. 

  746. };
    747. 

  747. 

  748. 

  749. 

  750. oop.inherits(CstyleBehaviour, Behaviour);
    751. 

  751. 

  752. exports.CstyleBehaviour = CstyleBehaviour;
    753. 

  753. });
    754. 

  754. 

  755. ace.define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"], function(require, exports, module) {
    756. 

  756. "use strict";
    757. 

  757. 

  758. var oop = require("../../lib/oop");
    759. 

  759. var Range = require("../../range").Range;
    760. 

  760. var BaseFoldMode = require("./fold_mode").FoldMode;
    761. 

  761. 

  762. var FoldMode = exports.FoldMode = function(commentRegex) {
    763. 

  763.     if (commentRegex) {
    764. 

  764.         this.foldingStartMarker = new RegExp(
    765. 

  765.             this.foldingStartMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.start)
    766. 

  766.         );
    767. 

  767.         this.foldingStopMarker = new RegExp(
    768. 

  768.             this.foldingStopMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.end)
    769. 

  769.         );
    770. 

  770.     }
    771. 

  771. };
    772. 

  772. oop.inherits(FoldMode, BaseFoldMode);
    773. 

  773. 

  774. (function() {
    775. 

  775. 

  776.     this.foldingStartMarker = /(\{|\[)[^\}\]]*$|^\s*(\/\*)/;
    777. 

  777.     this.foldingStopMarker = /^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/;
    778. 

  778. 

  779.     this.getFoldWidgetRange = function(session, foldStyle, row, forceMultiline) {
    780. 

  780.         var line = session.getLine(row);
    781. 

  781.         var match = line.match(this.foldingStartMarker);
    782. 

  782.         if (match) {
    783. 

  783.             var i = match.index;
    784. 

  784. 

  785.             if (match[1])
    786. 

  786.                 return this.openingBracketBlock(session, match[1], row, i);
    787. 

  787.                 
    788. 

  788.             var range = session.getCommentFoldRange(row, i + match[0].length, 1);
    789. 

  789.             
    790. 

  790.             if (range && !range.isMultiLine()) {
    791. 

  791.                 if (forceMultiline) {
    792. 

  792.                     range = this.getSectionRange(session, row);
    793. 

  793.                 } else if (foldStyle != "all")
    794. 

  794.                     range = null;
    795. 

  795.             }
    796. 

  796.             
    797. 

  797.             return range;
    798. 

  798.         }
    799. 

  799. 

  800.         if (foldStyle === "markbegin")
    801. 

  801.             return;
    802. 

  802. 

  803.         var match = line.match(this.foldingStopMarker);
    804. 

  804.         if (match) {
    805. 

  805.             var i = match.index + match[0].length;
    806. 

  806. 

  807.             if (match[1])
    808. 

  808.                 return this.closingBracketBlock(session, match[1], row, i);
    809. 

  809. 

  810.             return session.getCommentFoldRange(row, i, -1);
    811. 

  811.         }
    812. 

  812.     };
    813. 

  813.     
    814. 

  814.     this.getSectionRange = function(session, row) {
    815. 

  815.         var line = session.getLine(row);
    816. 

  816.         var startIndent = line.search(/\S/);
    817. 

  817.         var startRow = row;
    818. 

  818.         var startColumn = line.length;
    819. 

  819.         row = row + 1;
    820. 

  820.         var endRow = row;
    821. 

  821.         var maxRow = session.getLength();
    822. 

  822.         while (++row < maxRow) {
    823. 

  823.             line = session.getLine(row);
    824. 

  824.             var indent = line.search(/\S/);
    825. 

  825.             if (indent === -1)
    826. 

  826.                 continue;
    827. 

  827.             if  (startIndent > indent)
    828. 

  828.                 break;
    829. 

  829.             var subRange = this.getFoldWidgetRange(session, "all", row);
    830. 

  830.             
    831. 

  831.             if (subRange) {
    832. 

  832.                 if (subRange.start.row <= startRow) {
    833. 

  833.                     break;
    834. 

  834.                 } else if (subRange.isMultiLine()) {
    835. 

  835.                     row = subRange.end.row;
    836. 

  836.                 } else if (startIndent == indent) {
    837. 

  837.                     break;
    838. 

  838.                 }
    839. 

  839.             }
    840. 

  840.             endRow = row;
    841. 

  841.         }
    842. 

  842.         
    843. 

  843.         return new Range(startRow, startColumn, endRow, session.getLine(endRow).length);
    844. 

  844.     };
    845. 

  845. 

  846. }).call(FoldMode.prototype);
    847. 

  847. 

  848. });
    849. 

  849. 

  850. ace.define("ace/mode/javascript",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/javascript_highlight_rules","ace/mode/matching_brace_outdent","ace/range","ace/worker/worker_client","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle"], function(require, exports, module) {
    851. 

  851. "use strict";
    852. 

  852. 

  853. var oop = require("../lib/oop");
    854. 

  854. var TextMode = require("./text").Mode;
    855. 

  855. var JavaScriptHighlightRules = require("./javascript_highlight_rules").JavaScriptHighlightRules;
    856. 

  856. var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;
    857. 

  857. var Range = require("../range").Range;
    858. 

  858. var WorkerClient = require("../worker/worker_client").WorkerClient;
    859. 

  859. var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;
    860. 

  860. var CStyleFoldMode = require("./folding/cstyle").FoldMode;
    861. 

  861. 

  862. var Mode = function() {
    863. 

  863.     this.HighlightRules = JavaScriptHighlightRules;
    864. 

  864.     
    865. 

  865.     this.$outdent = new MatchingBraceOutdent();
    866. 

  866.     this.$behaviour = new CstyleBehaviour();
    867. 

  867.     this.foldingRules = new CStyleFoldMode();
    868. 

  868. };
    869. 

  869. oop.inherits(Mode, TextMode);
    870. 

  870. 

  871. (function() {
    872. 

  872. 

  873.     this.lineCommentStart = "//";
    874. 

  874.     this.blockComment = {start: "/*", end: "*/"};
    875. 

  875. 

  876.     this.getNextLineIndent = function(state, line, tab) {
    877. 

  877.         var indent = this.$getIndent(line);
    878. 

  878. 

  879.         var tokenizedLine = this.getTokenizer().getLineTokens(line, state);
    880. 

  880.         var tokens = tokenizedLine.tokens;
    881. 

  881.         var endState = tokenizedLine.state;
    882. 

  882. 

  883.         if (tokens.length && tokens[tokens.length-1].type == "comment") {
    884. 

  884.             return indent;
    885. 

  885.         }
    886. 

  886. 

  887.         if (state == "start" || state == "no_regex") {
    888. 

  888.             var match = line.match(/^.*(?:\bcase\b.*\:|[\{\(\[])\s*$/);
    889. 

  889.             if (match) {
    890. 

  890.                 indent += tab;
    891. 

  891.             }
    892. 

  892.         } else if (state == "doc-start") {
    893. 

  893.             if (endState == "start" || endState == "no_regex") {
    894. 

  894.                 return "";
    895. 

  895.             }
    896. 

  896.             var match = line.match(/^\s*(\/?)\*/);
    897. 

  897.             if (match) {
    898. 

  898.                 if (match[1]) {
    899. 

  899.                     indent += " ";
    900. 

  900.                 }
    901. 

  901.                 indent += "* ";
    902. 

  902.             }
    903. 

  903.         }
    904. 

  904. 

  905.         return indent;
    906. 

  906.     };
    907. 

  907. 

  908.     this.checkOutdent = function(state, line, input) {
    909. 

  909.         return this.$outdent.checkOutdent(line, input);
    910. 

  910.     };
    911. 

  911. 

  912.     this.autoOutdent = function(state, doc, row) {
    913. 

  913.         this.$outdent.autoOutdent(doc, row);
    914. 

  914.     };
    915. 

  915. 

  916.     this.createWorker = function(session) {
    917. 

  917.         var worker = new WorkerClient(["ace"], "ace/mode/javascript_worker", "JavaScriptWorker");
    918. 

  918.         worker.attachToDocument(session.getDocument());
    919. 

  919. 

  920.         worker.on("jslint", function(results) {
    921. 

  921.             session.setAnnotations(results.data);
    922. 

  922.         });
    923. 

  923. 

  924.         worker.on("terminate", function() {
    925. 

  925.             session.clearAnnotations();
    926. 

  926.         });
    927. 

  927. 

  928.         return worker;
    929. 

  929.     };
    930. 

  930. 

  931.     this.$id = "ace/mode/javascript";
    932. 

  932. }).call(Mode.prototype);
    933. 

  933. 

  934. exports.Mode = Mode;
    935. 

  935. });
    936. 

  936. 

  937. ace.define("ace/mode/typescript_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/javascript_highlight_rules"], function(require, exports, module) {
    938. 

  938. "use strict";
    939. 

  939. 

  940. var oop = require("../lib/oop");
    941. 

  941. var JavaScriptHighlightRules = require("./javascript_highlight_rules").JavaScriptHighlightRules;
    942. 

  942. 

  943. var TypeScriptHighlightRules = function() {
    944. 

  944. 

  945.     var tsRules =  [
    946. 

  946.         {
    947. 

  947.             token: ["keyword.operator.ts", "text", "variable.parameter.function.ts", "text"],
    948. 

  948.             regex: "\\b(module)(\\s*)([a-zA-Z0-9_?.$][\\w?.$]*)(\\s*\\{)"
    949. 

  949.         }, 
    950. 

  950.         {
    951. 

  951.             token: ["storage.type.variable.ts", "text", "keyword.other.ts", "text"],
    952. 

  952.             regex: "(super)(\\s*\\()([a-zA-Z0-9,_?.$\\s]+\\s*)(\\))"
    953. 

  953.         },
    954. 

  954.         {
    955. 

  955.             token: ["entity.name.function.ts","paren.lparen", "paren.rparen"],
    956. 

  956.             regex: "([a-zA-Z_?.$][\\w?.$]*)(\\()(\\))"
    957. 

  957.         },
    958. 

  958.         {
    959. 

  959.             token: ["variable.parameter.function.ts", "text", "variable.parameter.function.ts"],
    960. 

  960.             regex: "([a-zA-Z0-9_?.$][\\w?.$]*)(\\s*:\\s*)([a-zA-Z0-9_?.$][\\w?.$]*)"
    961. 

  961.         },  
    962. 

  962.         {
    963. 

  963.             token: ["keyword.operator.ts"],
    964. 

  964.             regex: "(?:\\b(constructor|declare|interface|as|AS|public|private|class|extends|export|super)\\b)"
    965. 

  965.         }, 
    966. 

  966.         {
    967. 

  967.             token: ["storage.type.variable.ts"],
    968. 

  968.             regex: "(?:\\b(this\\.|string\\b|bool\\b|number)\\b)"
    969. 

  969.         }, 
    970. 

  970.         {
    971. 

  971.             token: ["keyword.operator.ts", "storage.type.variable.ts", "keyword.operator.ts", "storage.type.variable.ts"],
    972. 

  972.             regex: "(class)(\\s+[a-zA-Z0-9_?.$][\\w?.$]*\\s+)(extends)(\\s+[a-zA-Z0-9_?.$][\\w?.$]*\\s+)?"
    973. 

  973.         },
    974. 

  974.         {
    975. 

  975.             token: "keyword",
    976. 

  976.             regex: "(?:super|export|class|extends|import)\\b"
    977. 

  977.         }
    978. 

  978.     ];
    979. 

  979. 

  980.     var JSRules = new JavaScriptHighlightRules().getRules();
    981. 

  981.     
    982. 

  982.     JSRules.start = tsRules.concat(JSRules.start);
    983. 

  983.     this.$rules = JSRules;
    984. 

  984. };
    985. 

  985. 

  986. oop.inherits(TypeScriptHighlightRules, JavaScriptHighlightRules);
    987. 

  987. 

  988. exports.TypeScriptHighlightRules = TypeScriptHighlightRules;
    989. 

  989. });
    990. 

  990. 

  991. ace.define("ace/mode/typescript",["require","exports","module","ace/lib/oop","ace/mode/javascript","ace/mode/typescript_highlight_rules","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle","ace/mode/matching_brace_outdent"], function(require, exports, module) {
    992. 

  992. "use strict";
    993. 

  993. 

  994. var oop = require("../lib/oop");
    995. 

  995. var jsMode = require("./javascript").Mode;
    996. 

  996. var TypeScriptHighlightRules = require("./typescript_highlight_rules").TypeScriptHighlightRules;
    997. 

  997. var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;
    998. 

  998. var CStyleFoldMode = require("./folding/cstyle").FoldMode;
    999. 

  999. var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;
    1000. 

  1000. 

  1001. var Mode = function() {
    1002. 

  1002.     this.HighlightRules = TypeScriptHighlightRules;
    1003. 

  1003.     
    1004. 

  1004.     this.$outdent = new MatchingBraceOutdent();
    1005. 

  1005.     this.$behaviour = new CstyleBehaviour();
    1006. 

  1006.     this.foldingRules = new CStyleFoldMode();
    1007. 

  1007. };
    1008. 

  1008. oop.inherits(Mode, jsMode);
    1009. 

  1009. 

  1010. (function() {
    1011. 

  1011.     this.createWorker = function(session) {
    1012. 

  1012.         return null;
    1013. 

  1013.     };
    1014. 

  1014.     this.$id = "ace/mode/typescript";
    1015. 

  1015. }).call(Mode.prototype);
    1016. 

  1016. 

  1017. exports.Mode = Mode;
    1018. 

  1018. });
    1019. 

  1019.