PageRenderTime 55ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://gitlab.com/Mirros/jsdelivr
JavaScript | 883 lines | 865 code | 18 blank | 0 comment | 0 complexity | 6bcc110720e415c6e292b4ce8af274f9 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/css_highlight_rules",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/mode/text_highlight_rules"], function(require, exports, module) {
    46. 

  46. "use strict";
    47. 

  47. 

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

  49. var lang = require("../lib/lang");
    50. 

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

  51. var supportType = exports.supportType = "animation-fill-mode|alignment-adjust|alignment-baseline|animation-delay|animation-direction|animation-duration|animation-iteration-count|animation-name|animation-play-state|animation-timing-function|animation|appearance|azimuth|backface-visibility|background-attachment|background-break|background-clip|background-color|background-image|background-origin|background-position|background-repeat|background-size|background|baseline-shift|binding|bleed|bookmark-label|bookmark-level|bookmark-state|bookmark-target|border-bottom|border-bottom-color|border-bottom-left-radius|border-bottom-right-radius|border-bottom-style|border-bottom-width|border-collapse|border-color|border-image|border-image-outset|border-image-repeat|border-image-slice|border-image-source|border-image-width|border-left|border-left-color|border-left-style|border-left-width|border-radius|border-right|border-right-color|border-right-style|border-right-width|border-spacing|border-style|border-top|border-top-color|border-top-left-radius|border-top-right-radius|border-top-style|border-top-width|border-width|border|bottom|box-align|box-decoration-break|box-direction|box-flex-group|box-flex|box-lines|box-ordinal-group|box-orient|box-pack|box-shadow|box-sizing|break-after|break-before|break-inside|caption-side|clear|clip|color-profile|color|column-count|column-fill|column-gap|column-rule|column-rule-color|column-rule-style|column-rule-width|column-span|column-width|columns|content|counter-increment|counter-reset|crop|cue-after|cue-before|cue|cursor|direction|display|dominant-baseline|drop-initial-after-adjust|drop-initial-after-align|drop-initial-before-adjust|drop-initial-before-align|drop-initial-size|drop-initial-value|elevation|empty-cells|fit|fit-position|float-offset|float|font-family|font-size|font-size-adjust|font-stretch|font-style|font-variant|font-weight|font|grid-columns|grid-rows|hanging-punctuation|height|hyphenate-after|hyphenate-before|hyphenate-character|hyphenate-lines|hyphenate-resource|hyphens|icon|image-orientation|image-rendering|image-resolution|inline-box-align|left|letter-spacing|line-height|line-stacking-ruby|line-stacking-shift|line-stacking-strategy|line-stacking|list-style-image|list-style-position|list-style-type|list-style|margin-bottom|margin-left|margin-right|margin-top|margin|mark-after|mark-before|mark|marks|marquee-direction|marquee-play-count|marquee-speed|marquee-style|max-height|max-width|min-height|min-width|move-to|nav-down|nav-index|nav-left|nav-right|nav-up|opacity|orphans|outline-color|outline-offset|outline-style|outline-width|outline|overflow-style|overflow-x|overflow-y|overflow|padding-bottom|padding-left|padding-right|padding-top|padding|page-break-after|page-break-before|page-break-inside|page-policy|page|pause-after|pause-before|pause|perspective-origin|perspective|phonemes|pitch-range|pitch|play-during|pointer-events|position|presentation-level|punctuation-trim|quotes|rendering-intent|resize|rest-after|rest-before|rest|richness|right|rotation-point|rotation|ruby-align|ruby-overhang|ruby-position|ruby-span|size|speak-header|speak-numeral|speak-punctuation|speak|speech-rate|stress|string-set|table-layout|target-name|target-new|target-position|target|text-align-last|text-align|text-decoration|text-emphasis|text-height|text-indent|text-justify|text-outline|text-shadow|text-transform|text-wrap|top|transform-origin|transform-style|transform|transition-delay|transition-duration|transition-property|transition-timing-function|transition|unicode-bidi|vertical-align|visibility|voice-balance|voice-duration|voice-family|voice-pitch-range|voice-pitch|voice-rate|voice-stress|voice-volume|volume|white-space-collapse|white-space|widows|width|word-break|word-spacing|word-wrap|z-index";
    52. 

  52. var supportFunction = exports.supportFunction = "rgb|rgba|url|attr|counter|counters";
    53. 

  53. var supportConstant = exports.supportConstant = "absolute|after-edge|after|all-scroll|all|alphabetic|always|antialiased|armenian|auto|avoid-column|avoid-page|avoid|balance|baseline|before-edge|before|below|bidi-override|block-line-height|block|bold|bolder|border-box|both|bottom|box|break-all|break-word|capitalize|caps-height|caption|center|central|char|circle|cjk-ideographic|clone|close-quote|col-resize|collapse|column|consider-shifts|contain|content-box|cover|crosshair|cubic-bezier|dashed|decimal-leading-zero|decimal|default|disabled|disc|disregard-shifts|distribute-all-lines|distribute-letter|distribute-space|distribute|dotted|double|e-resize|ease-in|ease-in-out|ease-out|ease|ellipsis|end|exclude-ruby|fill|fixed|georgian|glyphs|grid-height|groove|hand|hanging|hebrew|help|hidden|hiragana-iroha|hiragana|horizontal|icon|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space|ideographic|inactive|include-ruby|inherit|initial|inline-block|inline-box|inline-line-height|inline-table|inline|inset|inside|inter-ideograph|inter-word|invert|italic|justify|katakana-iroha|katakana|keep-all|last|left|lighter|line-edge|line-through|line|linear|list-item|local|loose|lower-alpha|lower-greek|lower-latin|lower-roman|lowercase|lr-tb|ltr|mathematical|max-height|max-size|medium|menu|message-box|middle|move|n-resize|ne-resize|newspaper|no-change|no-close-quote|no-drop|no-open-quote|no-repeat|none|normal|not-allowed|nowrap|nw-resize|oblique|open-quote|outset|outside|overline|padding-box|page|pointer|pre-line|pre-wrap|pre|preserve-3d|progress|relative|repeat-x|repeat-y|repeat|replaced|reset-size|ridge|right|round|row-resize|rtl|s-resize|scroll|se-resize|separate|slice|small-caps|small-caption|solid|space|square|start|static|status-bar|step-end|step-start|steps|stretch|strict|sub|super|sw-resize|table-caption|table-cell|table-column-group|table-column|table-footer-group|table-header-group|table-row-group|table-row|table|tb-rl|text-after-edge|text-before-edge|text-bottom|text-size|text-top|text|thick|thin|transparent|underline|upper-alpha|upper-latin|upper-roman|uppercase|use-script|vertical-ideographic|vertical-text|visible|w-resize|wait|whitespace|z-index|zero";
    54. 

  54. var supportConstantColor = exports.supportConstantColor = "aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow";
    55. 

  55. var supportConstantFonts = exports.supportConstantFonts = "arial|century|comic|courier|garamond|georgia|helvetica|impact|lucida|symbol|system|tahoma|times|trebuchet|utopia|verdana|webdings|sans-serif|serif|monospace";
    56. 

  56. 

  57. var numRe = exports.numRe = "\\-?(?:(?:[0-9]+)|(?:[0-9]*\\.[0-9]+))";
    58. 

  58. var pseudoElements = exports.pseudoElements = "(\\:+)\\b(after|before|first-letter|first-line|moz-selection|selection)\\b";
    59. 

  59. var pseudoClasses  = exports.pseudoClasses =  "(:)\\b(active|checked|disabled|empty|enabled|first-child|first-of-type|focus|hover|indeterminate|invalid|last-child|last-of-type|link|not|nth-child|nth-last-child|nth-last-of-type|nth-of-type|only-child|only-of-type|required|root|target|valid|visited)\\b";
    60. 

  60. 

  61. var CssHighlightRules = function() {
    62. 

  62. 

  63.     var keywordMapper = this.createKeywordMapper({
    64. 

  64.         "support.function": supportFunction,
    65. 

  65.         "support.constant": supportConstant,
    66. 

  66.         "support.type": supportType,
    67. 

  67.         "support.constant.color": supportConstantColor,
    68. 

  68.         "support.constant.fonts": supportConstantFonts
    69. 

  69.     }, "text", true);
    70. 

  70. 

  71.     this.$rules = {
    72. 

  72.         "start" : [{
    73. 

  73.             token : "comment", // multi line comment
    74. 

  74.             regex : "\\/\\*",
    75. 

  75.             push : "comment"
    76. 

  76.         }, {
    77. 

  77.             token: "paren.lparen",
    78. 

  78.             regex: "\\{",
    79. 

  79.             push:  "ruleset"
    80. 

  80.         }, {
    81. 

  81.             token: "string",
    82. 

  82.             regex: "@.*?{",
    83. 

  83.             push:  "media"
    84. 

  84.         }, {
    85. 

  85.             token: "keyword",
    86. 

  86.             regex: "#[a-z0-9-_]+"
    87. 

  87.         }, {
    88. 

  88.             token: "variable",
    89. 

  89.             regex: "\\.[a-z0-9-_]+"
    90. 

  90.         }, {
    91. 

  91.             token: "string",
    92. 

  92.             regex: ":[a-z0-9-_]+"
    93. 

  93.         }, {
    94. 

  94.             token: "constant",
    95. 

  95.             regex: "[a-z0-9-_]+"
    96. 

  96.         }, {
    97. 

  97.             caseInsensitive: true
    98. 

  98.         }],
    99. 

  99. 

  100.         "media" : [{
    101. 

  101.             token : "comment", // multi line comment
    102. 

  102.             regex : "\\/\\*",
    103. 

  103.             push : "comment"
    104. 

  104.         }, {
    105. 

  105.             token: "paren.lparen",
    106. 

  106.             regex: "\\{",
    107. 

  107.             push:  "ruleset"
    108. 

  108.         }, {
    109. 

  109.             token: "string",
    110. 

  110.             regex: "\\}",
    111. 

  111.             next:  "pop"
    112. 

  112.         }, {
    113. 

  113.             token: "keyword",
    114. 

  114.             regex: "#[a-z0-9-_]+"
    115. 

  115.         }, {
    116. 

  116.             token: "variable",
    117. 

  117.             regex: "\\.[a-z0-9-_]+"
    118. 

  118.         }, {
    119. 

  119.             token: "string",
    120. 

  120.             regex: ":[a-z0-9-_]+"
    121. 

  121.         }, {
    122. 

  122.             token: "constant",
    123. 

  123.             regex: "[a-z0-9-_]+"
    124. 

  124.         }, {
    125. 

  125.             caseInsensitive: true
    126. 

  126.         }],
    127. 

  127. 

  128.         "comment" : [{
    129. 

  129.             token : "comment",
    130. 

  130.             regex : "\\*\\/",
    131. 

  131.             next : "pop"
    132. 

  132.         }, {
    133. 

  133.             defaultToken : "comment"
    134. 

  134.         }],
    135. 

  135. 

  136.         "ruleset" : [
    137. 

  137.         {
    138. 

  138.             token : "paren.rparen",
    139. 

  139.             regex : "\\}",
    140. 

  140.             next:   "pop"
    141. 

  141.         }, {
    142. 

  142.             token : "comment", // multi line comment
    143. 

  143.             regex : "\\/\\*",
    144. 

  144.             push : "comment"
    145. 

  145.         }, {
    146. 

  146.             token : "string", // single line
    147. 

  147.             regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
    148. 

  148.         }, {
    149. 

  149.             token : "string", // single line
    150. 

  150.             regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
    151. 

  151.         }, {
    152. 

  152.             token : ["constant.numeric", "keyword"],
    153. 

  153.             regex : "(" + numRe + ")(ch|cm|deg|em|ex|fr|gd|grad|Hz|in|kHz|mm|ms|pc|pt|px|rad|rem|s|turn|vh|vm|vw|%)"
    154. 

  154.         }, {
    155. 

  155.             token : "constant.numeric",
    156. 

  156.             regex : numRe
    157. 

  157.         }, {
    158. 

  158.             token : "constant.numeric",  // hex6 color
    159. 

  159.             regex : "#[a-f0-9]{6}"
    160. 

  160.         }, {
    161. 

  161.             token : "constant.numeric", // hex3 color
    162. 

  162.             regex : "#[a-f0-9]{3}"
    163. 

  163.         }, {
    164. 

  164.             token : ["punctuation", "entity.other.attribute-name.pseudo-element.css"],
    165. 

  165.             regex : pseudoElements
    166. 

  166.         }, {
    167. 

  167.             token : ["punctuation", "entity.other.attribute-name.pseudo-class.css"],
    168. 

  168.             regex : pseudoClasses
    169. 

  169.         }, {
    170. 

  170.             token : ["support.function", "string", "support.function"],
    171. 

  171.             regex : "(url\\()(.*)(\\))"
    172. 

  172.         }, {
    173. 

  173.             token : keywordMapper,
    174. 

  174.             regex : "\\-?[a-zA-Z_][a-zA-Z0-9_\\-]*"
    175. 

  175.         }, {
    176. 

  176.             caseInsensitive: true
    177. 

  177.         }]
    178. 

  178.     };
    179. 

  179. 

  180.     this.normalizeRules();
    181. 

  181. };
    182. 

  182. 

  183. oop.inherits(CssHighlightRules, TextHighlightRules);
    184. 

  184. 

  185. exports.CssHighlightRules = CssHighlightRules;
    186. 

  186. 

  187. });
    188. 

  188. 

  189. 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) {
    190. 

  190. "use strict";
    191. 

  191. 

  192. var oop = require("../lib/oop");
    193. 

  193. var DocCommentHighlightRules = require("./doc_comment_highlight_rules").DocCommentHighlightRules;
    194. 

  194. var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
    195. 

  195. 

  196. var JavaScriptHighlightRules = function() {
    197. 

  197.     var keywordMapper = this.createKeywordMapper({
    198. 

  198.         "variable.language":
    199. 

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

  200.             "Namespace|QName|XML|XMLList|"                                             + // E4X
    201. 

  201.             "ArrayBuffer|Float32Array|Float64Array|Int16Array|Int32Array|Int8Array|"   +
    202. 

  202.             "Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray|"                    +
    203. 

  203.             "Error|EvalError|InternalError|RangeError|ReferenceError|StopIteration|"   + // Errors
    204. 

  204.             "SyntaxError|TypeError|URIError|"                                          +
    205. 

  205.             "decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|" + // Non-constructor functions
    206. 

  206.             "isNaN|parseFloat|parseInt|"                                               +
    207. 

  207.             "JSON|Math|"                                                               + // Other
    208. 

  208.             "this|arguments|prototype|window|document"                                 , // Pseudo
    209. 

  209.         "keyword":
    210. 

  210.             "const|yield|import|get|set|" +
    211. 

  211.             "break|case|catch|continue|default|delete|do|else|finally|for|function|" +
    212. 

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

  213.             "__parent__|__count__|escape|unescape|with|__proto__|" +
    214. 

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

  215.         "storage.type":
    216. 

  216.             "const|let|var|function",
    217. 

  217.         "constant.language":
    218. 

  218.             "null|Infinity|NaN|undefined",
    219. 

  219.         "support.function":
    220. 

  220.             "alert",
    221. 

  221.         "constant.language.boolean": "true|false"
    222. 

  222.     }, "identifier");
    223. 

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

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

  225. 

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

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

  228.         "[0-2][0-7]{0,2}|" + // oct
    229. 

  229.         "3[0-6][0-7]?|" + // oct
    230. 

  230.         "37[0-7]?|" + // oct
    231. 

  231.         "[4-7][0-7]?|" + //oct
    232. 

  232.         ".)";
    233. 

  233. 

  234.     this.$rules = {
    235. 

  235.         "no_regex" : [
    236. 

  236.             {
    237. 

  237.                 token : "comment",
    238. 

  238.                 regex : "\\/\\/",
    239. 

  239.                 next : "line_comment"
    240. 

  240.             },
    241. 

  241.             DocCommentHighlightRules.getStartRule("doc-start"),
    242. 

  242.             {
    243. 

  243.                 token : "comment", // multi line comment
    244. 

  244.                 regex : /\/\*/,
    245. 

  245.                 next : "comment"
    246. 

  246.             }, {
    247. 

  247.                 token : "string",
    248. 

  248.                 regex : "'(?=.)",
    249. 

  249.                 next  : "qstring"
    250. 

  250.             }, {
    251. 

  251.                 token : "string",
    252. 

  252.                 regex : '"(?=.)',
    253. 

  253.                 next  : "qqstring"
    254. 

  254.             }, {
    255. 

  255.                 token : "constant.numeric", // hex
    256. 

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

  257.             }, {
    258. 

  258.                 token : "constant.numeric", // float
    259. 

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

  260.             }, {
    261. 

  261.                 token : [
    262. 

  262.                     "storage.type", "punctuation.operator", "support.function",
    263. 

  263.                     "punctuation.operator", "entity.name.function", "text","keyword.operator"
    264. 

  264.                 ],
    265. 

  265.                 regex : "(" + identifierRe + ")(\\.)(prototype)(\\.)(" + identifierRe +")(\\s*)(=)",
    266. 

  266.                 next: "function_arguments"
    267. 

  267.             }, {
    268. 

  268.                 token : [
    269. 

  269.                     "storage.type", "punctuation.operator", "entity.name.function", "text",
    270. 

  270.                     "keyword.operator", "text", "storage.type", "text", "paren.lparen"
    271. 

  271.                 ],
    272. 

  272.                 regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
    273. 

  273.                 next: "function_arguments"
    274. 

  274.             }, {
    275. 

  275.                 token : [
    276. 

  276.                     "entity.name.function", "text", "keyword.operator", "text", "storage.type",
    277. 

  277.                     "text", "paren.lparen"
    278. 

  278.                 ],
    279. 

  279.                 regex : "(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
    280. 

  280.                 next: "function_arguments"
    281. 

  281.             }, {
    282. 

  282.                 token : [
    283. 

  283.                     "storage.type", "punctuation.operator", "entity.name.function", "text",
    284. 

  284.                     "keyword.operator", "text",
    285. 

  285.                     "storage.type", "text", "entity.name.function", "text", "paren.lparen"
    286. 

  286.                 ],
    287. 

  287.                 regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s+)(\\w+)(\\s*)(\\()",
    288. 

  288.                 next: "function_arguments"
    289. 

  289.             }, {
    290. 

  290.                 token : [
    291. 

  291.                     "storage.type", "text", "entity.name.function", "text", "paren.lparen"
    292. 

  292.                 ],
    293. 

  293.                 regex : "(function)(\\s+)(" + identifierRe + ")(\\s*)(\\()",
    294. 

  294.                 next: "function_arguments"
    295. 

  295.             }, {
    296. 

  296.                 token : [
    297. 

  297.                     "entity.name.function", "text", "punctuation.operator",
    298. 

  298.                     "text", "storage.type", "text", "paren.lparen"
    299. 

  299.                 ],
    300. 

  300.                 regex : "(" + identifierRe + ")(\\s*)(:)(\\s*)(function)(\\s*)(\\()",
    301. 

  301.                 next: "function_arguments"
    302. 

  302.             }, {
    303. 

  303.                 token : [
    304. 

  304.                     "text", "text", "storage.type", "text", "paren.lparen"
    305. 

  305.                 ],
    306. 

  306.                 regex : "(:)(\\s*)(function)(\\s*)(\\()",
    307. 

  307.                 next: "function_arguments"
    308. 

  308.             }, {
    309. 

  309.                 token : "keyword",
    310. 

  310.                 regex : "(?:" + kwBeforeRe + ")\\b",
    311. 

  311.                 next : "start"
    312. 

  312.             }, {
    313. 

  313.                 token : ["punctuation.operator", "support.function"],
    314. 

  314.                 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(?=\()/
    315. 

  315.             }, {
    316. 

  316.                 token : ["punctuation.operator", "support.function.dom"],
    317. 

  317.                 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(?=\()/
    318. 

  318.             }, {
    319. 

  319.                 token : ["punctuation.operator", "support.constant"],
    320. 

  320.                 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/
    321. 

  321.             }, {
    322. 

  322.                 token : ["support.constant"],
    323. 

  323.                 regex : /that\b/
    324. 

  324.             }, {
    325. 

  325.                 token : ["storage.type", "punctuation.operator", "support.function.firebug"],
    326. 

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

  327.             }, {
    328. 

  328.                 token : keywordMapper,
    329. 

  329.                 regex : identifierRe
    330. 

  330.             }, {
    331. 

  331.                 token : "keyword.operator",
    332. 

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

  333.                 next  : "start"
    334. 

  334.             }, {
    335. 

  335.                 token : "punctuation.operator",
    336. 

  336.                 regex : /\?|\:|\,|\;|\./,
    337. 

  337.                 next  : "start"
    338. 

  338.             }, {
    339. 

  339.                 token : "paren.lparen",
    340. 

  340.                 regex : /[\[({]/,
    341. 

  341.                 next  : "start"
    342. 

  342.             }, {
    343. 

  343.                 token : "paren.rparen",
    344. 

  344.                 regex : /[\])}]/
    345. 

  345.             }, {
    346. 

  346.                 token : "keyword.operator",
    347. 

  347.                 regex : /\/=?/,
    348. 

  348.                 next  : "start"
    349. 

  349.             }, {
    350. 

  350.                 token: "comment",
    351. 

  351.                 regex: /^#!.*$/
    352. 

  352.             }
    353. 

  353.         ],
    354. 

  354.         "start": [
    355. 

  355.             DocCommentHighlightRules.getStartRule("doc-start"),
    356. 

  356.             {
    357. 

  357.                 token : "comment", // multi line comment
    358. 

  358.                 regex : "\\/\\*",
    359. 

  359.                 next : "comment_regex_allowed"
    360. 

  360.             }, {
    361. 

  361.                 token : "comment",
    362. 

  362.                 regex : "\\/\\/",
    363. 

  363.                 next : "line_comment_regex_allowed"
    364. 

  364.             }, {
    365. 

  365.                 token: "string.regexp",
    366. 

  366.                 regex: "\\/",
    367. 

  367.                 next: "regex"
    368. 

  368.             }, {
    369. 

  369.                 token : "text",
    370. 

  370.                 regex : "\\s+|^$",
    371. 

  371.                 next : "start"
    372. 

  372.             }, {
    373. 

  373.                 token: "empty",
    374. 

  374.                 regex: "",
    375. 

  375.                 next: "no_regex"
    376. 

  376.             }
    377. 

  377.         ],
    378. 

  378.         "regex": [
    379. 

  379.             {
    380. 

  380.                 token: "regexp.keyword.operator",
    381. 

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

  382.             }, {
    383. 

  383.                 token: "string.regexp",
    384. 

  384.                 regex: "/[sxngimy]*",
    385. 

  385.                 next: "no_regex"
    386. 

  386.             }, {
    387. 

  387.                 token : "invalid",
    388. 

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

  389.             }, {
    390. 

  390.                 token : "constant.language.escape",
    391. 

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

  392.             }, {
    393. 

  393.                 token : "constant.language.delimiter",
    394. 

  394.                 regex: /\|/
    395. 

  395.             }, {
    396. 

  396.                 token: "constant.language.escape",
    397. 

  397.                 regex: /\[\^?/,
    398. 

  398.                 next: "regex_character_class"
    399. 

  399.             }, {
    400. 

  400.                 token: "empty",
    401. 

  401.                 regex: "$",
    402. 

  402.                 next: "no_regex"
    403. 

  403.             }, {
    404. 

  404.                 defaultToken: "string.regexp"
    405. 

  405.             }
    406. 

  406.         ],
    407. 

  407.         "regex_character_class": [
    408. 

  408.             {
    409. 

  409.                 token: "regexp.keyword.operator",
    410. 

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

  411.             }, {
    412. 

  412.                 token: "constant.language.escape",
    413. 

  413.                 regex: "]",
    414. 

  414.                 next: "regex"
    415. 

  415.             }, {
    416. 

  416.                 token: "constant.language.escape",
    417. 

  417.                 regex: "-"
    418. 

  418.             }, {
    419. 

  419.                 token: "empty",
    420. 

  420.                 regex: "$",
    421. 

  421.                 next: "no_regex"
    422. 

  422.             }, {
    423. 

  423.                 defaultToken: "string.regexp.charachterclass"
    424. 

  424.             }
    425. 

  425.         ],
    426. 

  426.         "function_arguments": [
    427. 

  427.             {
    428. 

  428.                 token: "variable.parameter",
    429. 

  429.                 regex: identifierRe
    430. 

  430.             }, {
    431. 

  431.                 token: "punctuation.operator",
    432. 

  432.                 regex: "[, ]+"
    433. 

  433.             }, {
    434. 

  434.                 token: "punctuation.operator",
    435. 

  435.                 regex: "$"
    436. 

  436.             }, {
    437. 

  437.                 token: "empty",
    438. 

  438.                 regex: "",
    439. 

  439.                 next: "no_regex"
    440. 

  440.             }
    441. 

  441.         ],
    442. 

  442.         "comment_regex_allowed" : [
    443. 

  443.             {token : "comment", regex : "\\*\\/", next : "start"},
    444. 

  444.             {defaultToken : "comment"}
    445. 

  445.         ],
    446. 

  446.         "comment" : [
    447. 

  447.             {token : "comment", regex : "\\*\\/", next : "no_regex"},
    448. 

  448.             {defaultToken : "comment"}
    449. 

  449.         ],
    450. 

  450.         "line_comment_regex_allowed" : [
    451. 

  451.             {token : "comment", regex : "$|^", next : "start"},
    452. 

  452.             {defaultToken : "comment"}
    453. 

  453.         ],
    454. 

  454.         "line_comment" : [
    455. 

  455.             {token : "comment", regex : "$|^", next : "no_regex"},
    456. 

  456.             {defaultToken : "comment"}
    457. 

  457.         ],
    458. 

  458.         "qqstring" : [
    459. 

  459.             {
    460. 

  460.                 token : "constant.language.escape",
    461. 

  461.                 regex : escapedRe
    462. 

  462.             }, {
    463. 

  463.                 token : "string",
    464. 

  464.                 regex : "\\\\$",
    465. 

  465.                 next  : "qqstring"
    466. 

  466.             }, {
    467. 

  467.                 token : "string",
    468. 

  468.                 regex : '"|$',
    469. 

  469.                 next  : "no_regex"
    470. 

  470.             }, {
    471. 

  471.                 defaultToken: "string"
    472. 

  472.             }
    473. 

  473.         ],
    474. 

  474.         "qstring" : [
    475. 

  475.             {
    476. 

  476.                 token : "constant.language.escape",
    477. 

  477.                 regex : escapedRe
    478. 

  478.             }, {
    479. 

  479.                 token : "string",
    480. 

  480.                 regex : "\\\\$",
    481. 

  481.                 next  : "qstring"
    482. 

  482.             }, {
    483. 

  483.                 token : "string",
    484. 

  484.                 regex : "'|$",
    485. 

  485.                 next  : "no_regex"
    486. 

  486.             }, {
    487. 

  487.                 defaultToken: "string"
    488. 

  488.             }
    489. 

  489.         ]
    490. 

  490.     };
    491. 

  491. 

  492.     this.embedRules(DocCommentHighlightRules, "doc-",
    493. 

  493.         [ DocCommentHighlightRules.getEndRule("no_regex") ]);
    494. 

  494. };
    495. 

  495. 

  496. oop.inherits(JavaScriptHighlightRules, TextHighlightRules);
    497. 

  497. 

  498. exports.JavaScriptHighlightRules = JavaScriptHighlightRules;
    499. 

  499. });
    500. 

  500. 

  501. ace.define("ace/mode/xml_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {
    502. 

  502. "use strict";
    503. 

  503. 

  504. var oop = require("../lib/oop");
    505. 

  505. var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
    506. 

  506. 

  507. var XmlHighlightRules = function(normalize) {
    508. 

  508.     this.$rules = {
    509. 

  509.         start : [
    510. 

  510.             {token : "string.cdata.xml", regex : "<\\!\\[CDATA\\[", next : "cdata"},
    511. 

  511.             {
    512. 

  512.                 token : ["punctuation.xml-decl.xml", "keyword.xml-decl.xml"],
    513. 

  513.                 regex : "(<\\?)(xml)(?=[\\s])", next : "xml_decl", caseInsensitive: true
    514. 

  514.             },
    515. 

  515.             {
    516. 

  516.                 token : ["punctuation.instruction.xml", "keyword.instruction.xml"],
    517. 

  517.                 regex : "(<\\?)([-_a-zA-Z0-9]+)", next : "processing_instruction",
    518. 

  518.             },
    519. 

  519.             {token : "comment.xml", regex : "<\\!--", next : "comment"},
    520. 

  520.             {
    521. 

  521.                 token : ["xml-pe.doctype.xml", "xml-pe.doctype.xml"],
    522. 

  522.                 regex : "(<\\!)(DOCTYPE)(?=[\\s])", next : "doctype", caseInsensitive: true
    523. 

  523.             },
    524. 

  524.             {include : "tag"},
    525. 

  525.             {token : "text.end-tag-open.xml", regex: "</"},
    526. 

  526.             {token : "text.tag-open.xml", regex: "<"},
    527. 

  527.             {include : "reference"},
    528. 

  528.             {defaultToken : "text.xml"}
    529. 

  529.         ],
    530. 

  530. 

  531.         xml_decl : [{
    532. 

  532.             token : "entity.other.attribute-name.decl-attribute-name.xml",
    533. 

  533.             regex : "(?:[-_a-zA-Z0-9]+:)?[-_a-zA-Z0-9]+"
    534. 

  534.         }, {
    535. 

  535.             token : "keyword.operator.decl-attribute-equals.xml",
    536. 

  536.             regex : "="
    537. 

  537.         }, {
    538. 

  538.             include: "whitespace"
    539. 

  539.         }, {
    540. 

  540.             include: "string"
    541. 

  541.         }, {
    542. 

  542.             token : "punctuation.xml-decl.xml",
    543. 

  543.             regex : "\\?>",
    544. 

  544.             next : "start"
    545. 

  545.         }],
    546. 

  546. 

  547.         processing_instruction : [
    548. 

  548.             {token : "punctuation.instruction.xml", regex : "\\?>", next : "start"},
    549. 

  549.             {defaultToken : "instruction.xml"}
    550. 

  550.         ],
    551. 

  551. 

  552.         doctype : [
    553. 

  553.             {include : "whitespace"},
    554. 

  554.             {include : "string"},
    555. 

  555.             {token : "xml-pe.doctype.xml", regex : ">", next : "start"},
    556. 

  556.             {token : "xml-pe.xml", regex : "[-_a-zA-Z0-9:]+"},
    557. 

  557.             {token : "punctuation.int-subset", regex : "\\[", push : "int_subset"}
    558. 

  558.         ],
    559. 

  559. 

  560.         int_subset : [{
    561. 

  561.             token : "text.xml",
    562. 

  562.             regex : "\\s+"
    563. 

  563.         }, {
    564. 

  564.             token: "punctuation.int-subset.xml",
    565. 

  565.             regex: "]",
    566. 

  566.             next: "pop"
    567. 

  567.         }, {
    568. 

  568.             token : ["punctuation.markup-decl.xml", "keyword.markup-decl.xml"],
    569. 

  569.             regex : "(<\\!)([-_a-zA-Z0-9]+)",
    570. 

  570.             push : [{
    571. 

  571.                 token : "text",
    572. 

  572.                 regex : "\\s+"
    573. 

  573.             },
    574. 

  574.             {
    575. 

  575.                 token : "punctuation.markup-decl.xml",
    576. 

  576.                 regex : ">",
    577. 

  577.                 next : "pop"
    578. 

  578.             },
    579. 

  579.             {include : "string"}]
    580. 

  580.         }],
    581. 

  581. 

  582.         cdata : [
    583. 

  583.             {token : "string.cdata.xml", regex : "\\]\\]>", next : "start"},
    584. 

  584.             {token : "text.xml", regex : "\\s+"},
    585. 

  585.             {token : "text.xml", regex : "(?:[^\\]]|\\](?!\\]>))+"}
    586. 

  586.         ],
    587. 

  587. 

  588.         comment : [
    589. 

  589.             {token : "comment.xml", regex : "-->", next : "start"},
    590. 

  590.             {defaultToken : "comment.xml"}
    591. 

  591.         ],
    592. 

  592. 

  593.         reference : [{
    594. 

  594.             token : "constant.language.escape.reference.xml",
    595. 

  595.             regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"
    596. 

  596.         }],
    597. 

  597. 

  598.         attr_reference : [{
    599. 

  599.             token : "constant.language.escape.reference.attribute-value.xml",
    600. 

  600.             regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"
    601. 

  601.         }],
    602. 

  602. 

  603.         tag : [{
    604. 

  604.             token : ["meta.tag.punctuation.tag-open.xml", "meta.tag.punctuation.end-tag-open.xml", "meta.tag.tag-name.xml"],
    605. 

  605.             regex : "(?:(<)|(</))((?:[-_a-zA-Z0-9]+:)?[-_a-zA-Z0-9]+)",
    606. 

  606.             next: [
    607. 

  607.                 {include : "attributes"},
    608. 

  608.                 {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : "start"}
    609. 

  609.             ]
    610. 

  610.         }],
    611. 

  611. 

  612.         tag_whitespace : [
    613. 

  613.             {token : "text.tag-whitespace.xml", regex : "\\s+"}
    614. 

  614.         ],
    615. 

  615.         whitespace : [
    616. 

  616.             {token : "text.whitespace.xml", regex : "\\s+"}
    617. 

  617.         ],
    618. 

  618.         string: [{
    619. 

  619.             token : "string.xml",
    620. 

  620.             regex : "'",
    621. 

  621.             push : [
    622. 

  622.                 {token : "string.xml", regex: "'", next: "pop"},
    623. 

  623.                 {defaultToken : "string.xml"}
    624. 

  624.             ]
    625. 

  625.         }, {
    626. 

  626.             token : "string.xml",
    627. 

  627.             regex : '"',
    628. 

  628.             push : [
    629. 

  629.                 {token : "string.xml", regex: '"', next: "pop"},
    630. 

  630.                 {defaultToken : "string.xml"}
    631. 

  631.             ]
    632. 

  632.         }],
    633. 

  633. 

  634.         attributes: [{
    635. 

  635.             token : "entity.other.attribute-name.xml",
    636. 

  636.             regex : "(?:[-_a-zA-Z0-9]+:)?[-_a-zA-Z0-9]+"
    637. 

  637.         }, {
    638. 

  638.             token : "keyword.operator.attribute-equals.xml",
    639. 

  639.             regex : "="
    640. 

  640.         }, {
    641. 

  641.             include: "tag_whitespace"
    642. 

  642.         }, {
    643. 

  643.             include: "attribute_value"
    644. 

  644.         }],
    645. 

  645. 

  646.         attribute_value: [{
    647. 

  647.             token : "string.attribute-value.xml",
    648. 

  648.             regex : "'",
    649. 

  649.             push : [
    650. 

  650.                 {token : "string.attribute-value.xml", regex: "'", next: "pop"},
    651. 

  651.                 {include : "attr_reference"},
    652. 

  652.                 {defaultToken : "string.attribute-value.xml"}
    653. 

  653.             ]
    654. 

  654.         }, {
    655. 

  655.             token : "string.attribute-value.xml",
    656. 

  656.             regex : '"',
    657. 

  657.             push : [
    658. 

  658.                 {token : "string.attribute-value.xml", regex: '"', next: "pop"},
    659. 

  659.                 {include : "attr_reference"},
    660. 

  660.                 {defaultToken : "string.attribute-value.xml"}
    661. 

  661.             ]
    662. 

  662.         }]
    663. 

  663.     };
    664. 

  664. 

  665.     if (this.constructor === XmlHighlightRules)
    666. 

  666.         this.normalizeRules();
    667. 

  667. };
    668. 

  668. 

  669. 

  670. (function() {
    671. 

  671. 

  672.     this.embedTagRules = function(HighlightRules, prefix, tag){
    673. 

  673.         this.$rules.tag.unshift({
    674. 

  674.             token : ["meta.tag.punctuation.tag-open.xml", "meta.tag." + tag + ".tag-name.xml"],
    675. 

  675.             regex : "(<)(" + tag + "(?=\\s|>|$))",
    676. 

  676.             next: [
    677. 

  677.                 {include : "attributes"},
    678. 

  678.                 {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : prefix + "start"}
    679. 

  679.             ]
    680. 

  680.         });
    681. 

  681. 

  682.         this.$rules[tag + "-end"] = [
    683. 

  683.             {include : "attributes"},
    684. 

  684.             {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>",  next: "start",
    685. 

  685.                 onMatch : function(value, currentState, stack) {
    686. 

  686.                     stack.splice(0);
    687. 

  687.                     return this.token;
    688. 

  688.             }}
    689. 

  689.         ]
    690. 

  690. 

  691.         this.embedRules(HighlightRules, prefix, [{
    692. 

  692.             token: ["meta.tag.punctuation.end-tag-open.xml", "meta.tag." + tag + ".tag-name.xml"],
    693. 

  693.             regex : "(</)(" + tag + "(?=\\s|>|$))",
    694. 

  694.             next: tag + "-end"
    695. 

  695.         }, {
    696. 

  696.             token: "string.cdata.xml",
    697. 

  697.             regex : "<\\!\\[CDATA\\["
    698. 

  698.         }, {
    699. 

  699.             token: "string.cdata.xml",
    700. 

  700.             regex : "\\]\\]>"
    701. 

  701.         }]);
    702. 

  702.     };
    703. 

  703. 

  704. }).call(TextHighlightRules.prototype);
    705. 

  705. 

  706. oop.inherits(XmlHighlightRules, TextHighlightRules);
    707. 

  707. 

  708. exports.XmlHighlightRules = XmlHighlightRules;
    709. 

  709. });
    710. 

  710. 

  711. ace.define("ace/mode/html_highlight_rules",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/mode/css_highlight_rules","ace/mode/javascript_highlight_rules","ace/mode/xml_highlight_rules"], function(require, exports, module) {
    712. 

  712. "use strict";
    713. 

  713. 

  714. var oop = require("../lib/oop");
    715. 

  715. var lang = require("../lib/lang");
    716. 

  716. var CssHighlightRules = require("./css_highlight_rules").CssHighlightRules;
    717. 

  717. var JavaScriptHighlightRules = require("./javascript_highlight_rules").JavaScriptHighlightRules;
    718. 

  718. var XmlHighlightRules = require("./xml_highlight_rules").XmlHighlightRules;
    719. 

  719. 

  720. var tagMap = lang.createMap({
    721. 

  721.     a           : 'anchor',
    722. 

  722.     button 	    : 'form',
    723. 

  723.     form        : 'form',
    724. 

  724.     img         : 'image',
    725. 

  725.     input       : 'form',
    726. 

  726.     label       : 'form',
    727. 

  727.     option      : 'form',
    728. 

  728.     script      : 'script',
    729. 

  729.     select      : 'form',
    730. 

  730.     textarea    : 'form',
    731. 

  731.     style       : 'style',
    732. 

  732.     table       : 'table',
    733. 

  733.     tbody       : 'table',
    734. 

  734.     td          : 'table',
    735. 

  735.     tfoot       : 'table',
    736. 

  736.     th          : 'table',
    737. 

  737.     tr          : 'table'
    738. 

  738. });
    739. 

  739. 

  740. var HtmlHighlightRules = function() {
    741. 

  741.     XmlHighlightRules.call(this);
    742. 

  742. 

  743.     this.addRules({
    744. 

  744.         attributes: [{
    745. 

  745.             include : "tag_whitespace"
    746. 

  746.         }, {
    747. 

  747.             token : "entity.other.attribute-name.xml",
    748. 

  748.             regex : "[-_a-zA-Z0-9:]+"
    749. 

  749.         }, {
    750. 

  750.             token : "keyword.operator.attribute-equals.xml",
    751. 

  751.             regex : "=",
    752. 

  752.             push : [{
    753. 

  753.                 include: "tag_whitespace"
    754. 

  754.             }, {
    755. 

  755.                 token : "string.unquoted.attribute-value.html",
    756. 

  756.                 regex : "[^<>='\"`\\s]+",
    757. 

  757.                 next : "pop"
    758. 

  758.             }, {
    759. 

  759.                 token : "empty",
    760. 

  760.                 regex : "",
    761. 

  761.                 next : "pop"
    762. 

  762.             }]
    763. 

  763.         }, {
    764. 

  764.             include : "attribute_value"
    765. 

  765.         }],
    766. 

  766.         tag: [{
    767. 

  767.             token : function(start, tag) {
    768. 

  768.                 var group = tagMap[tag];
    769. 

  769.                 return ["meta.tag.punctuation." + (start == "<" ? "" : "end-") + "tag-open.xml",
    770. 

  770.                     "meta.tag" + (group ? "." + group : "") + ".tag-name.xml"];
    771. 

  771.             },
    772. 

  772.             regex : "(</?)([-_a-zA-Z0-9:]+)",
    773. 

  773.             next: "tag_stuff"
    774. 

  774.         }],
    775. 

  775.         tag_stuff: [
    776. 

  776.             {include : "attributes"},
    777. 

  777.             {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : "start"}
    778. 

  778.         ],
    779. 

  779.     });
    780. 

  780. 

  781.     this.embedTagRules(CssHighlightRules, "css-", "style");
    782. 

  782.     this.embedTagRules(JavaScriptHighlightRules, "js-", "script");
    783. 

  783. 

  784.     if (this.constructor === HtmlHighlightRules)
    785. 

  785.         this.normalizeRules();
    786. 

  786. };
    787. 

  787. 

  788. oop.inherits(HtmlHighlightRules, XmlHighlightRules);
    789. 

  789. 

  790. exports.HtmlHighlightRules = HtmlHighlightRules;
    791. 

  791. });
    792. 

  792. 

  793. ace.define("ace/mode/php_highlight_rules",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/mode/doc_comment_highlight_rules","ace/mode/text_highlight_rules","ace/mode/html_highlight_rules"], function(require, exports, module) {
    794. 

  794. "use strict";
    795. 

  795. 

  796. var oop = require("../lib/oop");
    797. 

  797. var lang = require("../lib/lang");
    798. 

  798. var DocCommentHighlightRules = require("./doc_comment_highlight_rules").DocCommentHighlightRules;
    799. 

  799. var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
    800. 

  800. var HtmlHighlightRules = require("./html_highlight_rules").HtmlHighlightRules;
    801. 

  801. 

  802. var PhpLangHighlightRules = function() {
    803. 

  803.     var docComment = DocCommentHighlightRules;
    804. 

  804.     var builtinFunctions = lang.arrayToMap(
    805. 

  805.         ('abs|acos|acosh|addcslashes|addslashes|aggregate|aggregate_info|aggregate_methods|aggregate_methods_by_list|aggregate_methods_by_regexp|' +
    806. 

  806.         'aggregate_properties|aggregate_properties_by_list|aggregate_properties_by_regexp|aggregation_info|amqpconnection|amqpexchange|amqpqueue|' +
    807. 

  807.         'apache_child_terminate|apache_get_modules|apache_get_version|apache_getenv|apache_lookup_uri|apache_note|apache_request_headers|' +
    808. 

  808.         'apache_reset_timeout|apache_response_headers|apache_setenv|apc_add|apc_bin_dump|apc_bin_dumpfile|apc_bin_load|apc_bin_loadfile|' +
    809. 

  809.         'apc_cache_info|apc_cas|apc_clear_cache|apc_compile_file|apc_dec|apc_define_constants|apc_delete|apc_delete_file|apc_exists|apc_fetch|' +
    810. 

  810.         'apc_inc|apc_load_constants|apc_sma_info|apc_store|apciterator|apd_breakpoint|apd_callstack|apd_clunk|apd_continue|apd_croak|' +
    811. 

  811.         'apd_dump_function_table|apd_dump_persistent_resources|apd_dump_regular_resources|apd_echo|apd_get_active_symbols|apd_set_pprof_trace|' +
    812. 

  812.         'apd_set_session|apd_set_session_trace|apd_set_session_trace_socket|appenditerator|array|array_change_key_case|array_chunk|array_combine|' +
    813. 

  813.         'array_count_values|array_diff|array_diff_assoc|array_diff_key|array_diff_uassoc|array_diff_ukey|array_fill|array_fill_keys|array_filter|' +
    814. 

  814.         'array_flip|array_intersect|array_intersect_assoc|array_intersect_key|array_intersect_uassoc|array_intersect_ukey|array_key_exists|' +
    815. 

  815.         'array_keys|array_map|array_merge|array_merge_recursive|array_multisort|array_pad|array_pop|array_product|array_push|array_rand|' +
    816. 

  816.         'array_reduce|array_replace|array_replace_recursive|array_reverse|array_search|array_shift|array_slice|array_splice|array_sum|array_udiff|' +
    817. 

  817.         'array_udiff_assoc|array_udiff_uassoc|array_uintersect|array_uintersect_assoc|array_uintersect_uassoc|array_unique|array_unshift|' +
    818. 

  818.         'array_values|array_walk|array_walk_recursive|arrayaccess|arrayiterator|arrayobject|arsort|asin|asinh|asort|assert|assert_options|atan|' +
    819. 

  819.         'atan2|atanh|audioproperties|badfunctioncallexception|badmethodcallexception|base64_decode|base64_encode|base_convert|basename|' +
    820. 

  820.         'bbcode_add_element|bbcode_add_smiley|bbcode_create|bbcode_destroy|bbcode_parse|bbcode_set_arg_parser|bbcode_set_flags|bcadd|bccomp|bcdiv|' +
    821. 

  821.         'bcmod|bcmul|bcompiler_load|bcompiler_load_exe|bcompiler_parse_class|bcompiler_read|bcompiler_write_class|bcompiler_write_constant|' +
    822. 

  822.         'bcompiler_write_exe_footer|bcompiler_write_file|bcompiler_write_footer|bcompiler_write_function|bcompiler_write_functions_from_file|' +
    823. 

  823.         'bcompiler_write_header|bcompiler_write_included_filename|bcpow|bcpowmod|bcscale|bcsqrt|bcsub|bin2hex|bind_textdomain_codeset|bindec|' +
    824. 

  824.         'bindtextdomain|bson_decode|bson_encode|bumpValue|bzclose|bzcompress|bzdecompress|bzerrno|bzerror|bzerrstr|bzflush|bzopen|bzread|bzwrite|' +
    825. 

  825.         'cachingiterator|cairo|cairo_create|cairo_font_face_get_type|cairo_font_face_status|cairo_font_options_create|cairo_font_options_equal|' +
    826. 

  826.         'cairo_font_options_get_antialias|cairo_font_options_get_hint_metrics|cairo_font_options_get_hint_style|' +
    827. 

  827.         'cairo_font_options_get_subpixel_order|cairo_font_options_hash|cairo_font_options_merge|cairo_font_options_set_antialias|' +
    828. 

  828.         'cairo_font_options_set_hint_metrics|cairo_font_options_set_hint_style|cairo_font_options_set_subpixel_order|cairo_font_options_status|' +
    829. 

  829.         'cairo_format_stride_for_width|cairo_image_surface_create|cairo_image_surface_create_for_data|cairo_image_surface_create_from_png|' +
    830. 

  830.         'cairo_image_surface_get_data|cairo_image_surface_get_format|cairo_image_surface_get_height|cairo_image_surface_get_stride|' +
    831. 

  831.         'cairo_image_surface_get_width|cairo_matrix_create_scale|cairo_matrix_create_translate|cairo_matrix_invert|cairo_matrix_multiply|' +
    832. 

  832.         'cairo_matrix_rotate|cairo_matrix_transform_distance|cairo_matrix_transform_point|cairo_matrix_translate|cairo_pattern_add_color_stop_rgb|' +
    833. 

  833.         'cairo_pattern_add_color_stop_rgba|cairo_pattern_create_for_surface|cairo_pattern_create_linear|cairo_pattern_create_radial|' +
    834. 

  834.         'cairo_pattern_create_rgb|cairo_pattern_create_rgba|cairo_pattern_get_color_stop_count|cairo_pattern_get_color_stop_rgba|' +
    835. 

  835.         'cairo_pattern_get_extend|cairo_pattern_get_filter|cairo_pattern_get_linear_points|cairo_pattern_get_matrix|' +
    836. 

  836.         'cairo_pattern_get_radial_circles|cairo_pattern_get_rgba|cairo_pattern_get_surface|cairo_pattern_get_type|cairo_pattern_set_extend|' +
    837. 

  837.         'cairo_pattern_set_filter|cairo_pattern_set_matrix|cairo_pattern_status|cairo_pdf_surface_create|cairo_pdf_surface_set_size|' +
    838. 

  838.         'cairo_ps_get_levels|cairo_ps_level_to_string|cairo_ps_surface_create|cairo_ps_surface_dsc_begin_page_setup|' +
    839. 

  839.         'cairo_ps_surface_dsc_begin_setup|cairo_ps_surface_dsc_comment|cairo_ps_surface_get_eps|cairo_ps_surface_restrict_to_level|' +
    840. 

  840.         'cairo_ps_surface_set_eps|cairo_ps_surface_set_size|cairo_scaled_font_create|cairo_scaled_font_extents|cairo_scaled_font_get_ctm|' +
    841. 

  841.         'cairo_scaled_font_get_font_face|cairo_scaled_font_get_font_matrix|cairo_scaled_font_get_font_options|cairo_scaled_font_get_scale_matrix|' +
    842. 

  842.         'cairo_scaled_font_get_type|cairo_scaled_font_glyph_extents|cairo_scaled_font_status|cairo_scaled_font_text_extents|' +
    843. 

  843.         'cairo_surface_copy_page|cairo_surface_create_similar|cairo_surface_finish|cairo_surface_flush|cairo_surface_get_content|' +
    844. 

  844.         'cairo_surface_get_device_offset|cairo_surface_get_font_options|cairo_surface_get_type|cairo_surface_mark_dirty|' +
    845. 

  845.         'cairo_surface_mark_dirty_rectangle|cairo_surface_set_device_offset|cairo_surface_set_fallback_resolution|cairo_surface_show_page|' +
    846. 

  846.         'cairo_surface_status|cairo_surface_write_to_png|cairo_svg_surface_create|cairo_svg_surface_restrict_to_version|' +
    847. 

  847.         'cairo_svg_version_to_string|cairoantialias|cairocontent|cairocontext|cairoexception|cairoextend|cairofillrule|cairofilter|cairofontface|' +
    848. 

  848.         'cairofontoptions|cairofontslant|cairofonttype|cairofontweight|cairoformat|cairogradientpattern|cairohintmetrics|cairohintstyle|' +
    849. 

  849.         'cairoimagesurface|cairolineargradient|cairolinecap|cairolinejoin|cairomatrix|cairooperator|cairopath|cairopattern|cairopatterntype|' +
    850. 

  850.         'cairopdfsurface|cairopslevel|cairopssurface|cairoradialgradient|cairoscaledfont|cairosolidpattern|cairostatus|cairosubpixelorder|' +
    851. 

  851.         'cairosurface|cairosurfacepattern|cairosurfacetype|cairosvgsurface|cairosvgversion|cairotoyfontface|cal_days_in_month|cal_from_jd|cal_info|' +
    852. 

  852.         'cal_to_jd|calcul_hmac|calculhmac|call_user_func|call_user_func_array|call_user_method|call_user_method_array|callbackfilteriterator|ceil|' +
    853. 

  853.         'chdb|chdb_create|chdir|checkdate|checkdnsrr|chgrp|chmod|chop|chown|chr|chroot|chunk_split|class_alias|class_exists|class_implements|' +
    854. 

  854.         'class_parents|classkit_import|classkit_method_add|classkit_method_copy|classkit_method_redefine|classkit_method_remove|' +
    855. 

  855.         'classkit_method_rename|clearstatcache|clone|closedir|closelog|collator|com|com_addref|com_create_guid|com_event_sink|com_get|' +
    856. 

  856.         'com_get_active_object|com_invoke|com_isenum|com_load|com_load_typelib|com_message_pump|com_print_typeinfo|com_propget|com_propput|' +
    857. 

  857.         'com_propset|com_release|com_set|compact|connection_aborted|connection_status|connection_timeout|constant|construct|construct|construct|' +
    858. 

  858.         'convert_cyr_string|convert_uudecode|convert_uuencode|copy|cos|cosh|count|count_chars|countable|counter_bump|counter_bump_value|' +
    859. 

  859.         'counter_create|counter_get|counter_get_meta|counter_get_named|counter_get_value|counter_reset|counter_reset_value|crack_check|' +
    860. 

  860.         'crack_closedict|crack_getlastmessage|crack_opendict|crc32|create_function|crypt|ctype_alnum|ctype_alpha|ctype_cntrl|ctype_digit|' +
    861. 

  861.         'ctype_graph|ctype_lower|ctype_print|ctype_punct|ctype_space|ctype_upper|ctype_xdigit|cubrid_affected_rows|cubrid_bind|' +
    862. 

  862.         'cubrid_client_encoding|cubrid_close|cubrid_close_prepare|cubrid_close_request|cubrid_col_get|cubrid_col_size|cubrid_column_names|' +
    863. 

  863.         'cubrid_column_types|cubrid_commit|cubrid_connect|cubrid_connect_with_url|cubrid_current_oid|cubrid_data_seek|cubrid_db_name|' +
    864. 

  864.         'cubrid_disconnect|cubrid_drop|cubrid_errno|cubrid_error|cubrid_error_code|cubrid_error_code_facility|cubrid_error_msg|cubrid_execute|' +
    865. 

  865.         'cubrid_fetch|cubrid_fetch_array|cubrid_fetch_assoc|cubrid_fetch_field|cubrid_fetch_lengths|cubrid_fetch_object|cubrid_fetch_row|' +
    866. 

  866.         'cubrid_field_flags|cubrid_field_len|cubrid_field_name|cubrid_field_seek|cubrid_field_table|cubrid_field_type|cubrid_free_result|' +
    867. 

  867.         'cubrid_get|cubrid_get_autocommit|cubrid_get_charset|cubrid_get_class_name|cubrid_get_client_info|cubrid_get_db_parameter|' +
    868. 

  868.         'cubrid_get_server_info|cubrid_insert_id|cubrid_is_instance|cubrid_list_dbs|cubrid_load_from_glo|cubrid_lob_close|cubrid_lob_export|' +
    869. 

  869.         'cubrid_lob_get|cubrid_lob_send|cubrid_lob_size|cubrid_lock_read|cubrid_lock_write|cubrid_move_cursor|cubrid_new_glo|cubrid_next_result|' +
    870. 

  870.         'cubrid_num_cols|cubrid_num_fields|cubrid_num_rows|cubrid_ping|cubrid_prepare|cubrid_put|cubrid_query|cubrid_real_escape_string|' +
    871. 

  871.         'cubrid_result|cubrid_rollback|cubrid_save_to_glo|cubrid_schema|cubrid_send_glo|cubrid_seq_drop|cubrid_seq_insert|cubrid_seq_put|' +
    872. 

  872.         'cubrid_set_add|cubrid_set_autocommit|cubrid_set_db_parameter|cubrid_set_drop|cubrid_unbuffered_query|cubrid_version|curl_close|' +
    873. 

  873.         'curl_copy_handle|curl_errno|curl_error|curl_exec|curl_getinfo|curl_init|curl_multi_add_handle|curl_multi_close|curl_multi_exec|' +
    874. 

  874.         'curl_multi_getcontent|curl_multi_info_read|curl_multi_init|curl_multi_remove_handle|curl_multi_select|curl_setopt|curl_setopt_array|' +
    875. 

  875.         'curl_version|current|cyrus_authenticate|cyrus_bind|cyrus_close|cyrus_connect|cyrus_query|cyrus_unbind|date|date_add|date_create|' +
    876. 

  876.         'date_create_from_format|date_date_set|date_default_timezone_get|date_default_timezone_set|date_diff|date_format|date_get_last_errors|' +
    877. 

  877.         'date_interval_create_from_date_string|date_interval_format|date_isodate_set|date_modify|date_offset_get|date_parse|date_parse_from_format|' +
    878. 

  878.         'date_sub|date_sun_info|date_sunrise|date_sunset|date_time_set|date_timestamp_get|date_timestamp_set|date_timezone_get|date_timezone_set|' +
    879. 

  879.         'dateinterval|dateperiod|datetime|datetimezone|db2_autocommit|db2_bind_param|db2_client_info|db2_close|db2_column_privileges|db2_columns|' +
    880. 

  880.         'db2_commit|db2_conn_error|db2_conn_errormsg|db2_connect|db2_cursor_type|db2_escape_string|db2_exec|db2_execute|db2_fetch_array|' +
    881. 

  881.         'db2_fetch_assoc|db2_fetch_both|db2_fetch_object|db2_fetch_row|db2_field_display_size|db2_field_name|db2_field_num|db2_field_precision|' +
    882. 

  882.         'db2_field_scale|db2_field_type|db2_field_width|db2_foreign_keys|db2_free_result|db2_free_stmt|db2_get_option|db2_last_insert_id|' +
    883. 

  883.         'db2_lob_read|db2_next_result|db2_num_fields|db
    884.