WebSVN – corrade-nucleus-nucleons – Blame – Rev 20 – /script-kiddie/002_script_kiddie/script-kiddie/node_modules/ace-builds/src-noconflict/mode-html

office

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) {

2

"use strict";

3

4

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

5

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

6

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

7

var supportType = exports.supportType = "align-content|align-items|align-self|all|animation|animation-delay|animation-direction|animation-duration|animation-fill-mode|animation-iteration-count|animation-name|animation-play-state|animation-timing-function|backface-visibility|background|background-attachment|background-blend-mode|background-clip|background-color|background-image|background-origin|background-position|background-repeat|background-size|border|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|bottom|box-shadow|box-sizing|caption-side|clear|clip|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|cursor|direction|display|empty-cells|filter|flex|flex-basis|flex-direction|flex-flow|flex-grow|flex-shrink|flex-wrap|float|font|font-family|font-size|font-size-adjust|font-stretch|font-style|font-variant|font-weight|hanging-punctuation|height|justify-content|left|letter-spacing|line-height|list-style|list-style-image|list-style-position|list-style-type|margin|margin-bottom|margin-left|margin-right|margin-top|max-height|max-width|min-height|min-width|nav-down|nav-index|nav-left|nav-right|nav-up|opacity|order|outline|outline-color|outline-offset|outline-style|outline-width|overflow|overflow-x|overflow-y|padding|padding-bottom|padding-left|padding-right|padding-top|page-break-after|page-break-before|page-break-inside|perspective|perspective-origin|position|quotes|resize|right|tab-size|table-layout|text-align|text-align-last|text-decoration|text-decoration-color|text-decoration-line|text-decoration-style|text-indent|text-justify|text-overflow|text-shadow|text-transform|top|transform|transform-origin|transform-style|transition|transition-delay|transition-duration|transition-property|transition-timing-function|unicode-bidi|vertical-align|visibility|white-space|width|word-break|word-spacing|word-wrap|z-index";

8

9

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";

10

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

11

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

12

13

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

14

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

15

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";

16

17

var CssHighlightRules = function() {

18

19

var keywordMapper = this.createKeywordMapper({

20

"support.function": supportFunction,

21

"support.constant": supportConstant,

22

"support.type": supportType,

23

"support.constant.color": supportConstantColor,

24

"support.constant.fonts": supportConstantFonts

}, "text", true);

this.$rules = {

"start" : [{

token : "comment", // multi line comment

regex : "\\/\\*",

push : "comment"

}, {

token: "paren.lparen",

regex: "\\{",

push: "ruleset"

}, {

token: "string",

regex: "@.*?{",

push: "media"

}, {

token: "keyword",

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

43

}, {

44

token: "variable",

45

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

46

}, {

47

token: "string",

48

regex: ":[a-z0-9-_]+"

49

}, {

50

token: "constant",

51

regex: "[a-z0-9-_]+"

52

}, {

53

caseInsensitive: true

}],

"media" : [{

token : "comment", // multi line comment

regex : "\\/\\*",

push : "comment"

}, {

token: "paren.lparen",

regex: "\\{",

push: "ruleset"

}, {

token: "string",

regex: "\\}",

next: "pop"

}, {

token: "keyword",

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

71

}, {

72

token: "variable",

73

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

74

}, {

75

token: "string",

76

regex: ":[a-z0-9-_]+"

77

}, {

78

token: "constant",

79

regex: "[a-z0-9-_]+"

80

}, {

81

caseInsensitive: true

}],

"comment" : [{

token : "comment",

regex : "\\*\\/",

next : "pop"

}, {

defaultToken : "comment"

}],

"ruleset" : [

{

token : "paren.rparen",

regex : "\\}",

next: "pop"

}, {

token : "comment", // multi line comment

regex : "\\/\\*",

push : "comment"

}, {

token : "string", // single line

103

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

104

}, {

105

token : "string", // single line

106

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

107

}, {

108

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

109

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|%)"

110

}, {

111

token : "constant.numeric",

112

regex : numRe

113

}, {

114

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

115

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

116

}, {

117

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

118

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

119

}, {

120

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

121

regex : pseudoElements

122

}, {

123

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

124

regex : pseudoClasses

125

}, {

126

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

127

regex : "(url\$)(.*)(\$)"

128

}, {

129

token : keywordMapper,

130

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

131

}, {

132

caseInsensitive: true

}]

};

this.normalizeRules();

137

};

138

139

oop.inherits(CssHighlightRules, TextHighlightRules);

140

141

exports.CssHighlightRules = CssHighlightRules;

});

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

146

"use strict";

147

148

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

149

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

150

151

var DocCommentHighlightRules = function() {

152

this.$rules = {

153

"start" : [ {

154

token : "comment.doc.tag",

155

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

156

},

157

DocCommentHighlightRules.getTagRule(),

158

{

159

defaultToken : "comment.doc",

160

caseInsensitive: true

}]

};

};

oop.inherits(DocCommentHighlightRules, TextHighlightRules);

166

167

DocCommentHighlightRules.getTagRule = function(start) {

168

return {

169

token : "comment.doc.tag.storage.type",

170

regex : "\\b(?:TODO|FIXME|XXX|HACK)\\b"

};

}

DocCommentHighlightRules.getStartRule = function(start) {

175

return {

176

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

177

regex : "\\/\\*(?=\\*)",

next : start

};

};

DocCommentHighlightRules.getEndRule = function (start) {

183

return {

184

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

regex : "\\*\\/",

next : start

};

};

exports.DocCommentHighlightRules = DocCommentHighlightRules;

});

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) {

196

"use strict";

197

198

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

199

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

200

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

201

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

202

203

var JavaScriptHighlightRules = function(options) {

204

var keywordMapper = this.createKeywordMapper({

205

"variable.language":

206

207

"Namespace|QName|XML|XMLList|" + // E4X

208

209

"Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray|" +

210

211

"SyntaxError|TypeError|URIError|" +

212

213

"isNaN|parseFloat|parseInt|" +

214

"JSON|Math|" + // Other

215

"this|arguments|prototype|window|document" , // Pseudo

"keyword":

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

"storage.type":

"const|let|var|function",

224

"constant.language":

225

"null|Infinity|NaN|undefined",

226

"support.function":

227

"alert",

228

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

}, "identifier");

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

233

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

234

"u{[0-9a-fA-F]{1,6}}|" + // es6 unicode

235

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

236

"3[0-7][0-7]?|" + // oct

237

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

".)";

this.$rules = {

"no_regex" : [

DocCommentHighlightRules.getStartRule("doc-start"),

243

comments("no_regex"),

{

token : "string",

regex : "'(?=.)",

next : "qstring"

}, {

token : "string",

regex : '"(?=.)',

next : "qqstring"

}, {

token : "constant.numeric", // hex

254

regex : /0(?:[xX][0-9a-fA-F]+|[bB][01]+)\b/

255

}, {

256

token : "constant.numeric", // float

257

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

258

}, {

259

token : [

260

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

261

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

262

],

263

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

264

next: "function_arguments"

265

}, {

266

token : [

267

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

268

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

269

],

270

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

271

next: "function_arguments"

272

}, {

273

token : [

274

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

275

"text", "paren.lparen"

276

],

277

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

278

next: "function_arguments"

279

}, {

280

token : [

281

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

282

"keyword.operator", "text",

283

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

284

],

285

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

286

next: "function_arguments"

287

}, {

288

token : [

289

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

290

],

291

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

292

next: "function_arguments"

293

}, {

294

token : [

295

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

296

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

297

],

298

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

299

next: "function_arguments"

300

}, {

301

token : [

302

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

303

],

304

regex : "(:)(\\s*)(function)(\\s*)(\\()",

305

next: "function_arguments"

306

}, {

307

token : "keyword",

308

regex : "(?:" + kwBeforeRe + ")\\b",

309

next : "start"

310

}, {

311

token : ["support.constant"],

312

regex : /that\b/

313

}, {

314

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

315

316

}, {

317

token : keywordMapper,

318

regex : identifierRe

319

}, {

320

token : "punctuation.operator",

321

regex : /[.](?![.])/,

322

next : "property"

323

}, {

324

token : "keyword.operator",

325

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

326

<+=?|> next : "start"

327

<+=?|> }, {

328

<+=?|> token : "punctuation.operator",

329

<+=?|> regex : /[?:,;.]/,

330

<+=?|> next : "start"

331

<+=?|> }, {

332

<+=?|> token : "paren.lparen",

333

<+=?|> regex : /[\[({]/,

334

<+=?|> next : "start"

335

<+=?|> }, {

336

<+=?|> token : "paren.rparen",

337

<+=?|> regex : /[\])}]/

338

<+=?|> }, {

339

<+=?|> token: "comment",

340

<+=?|> regex: /^#!.*$/

341

<+=?|> }

342

<+=?|> ],

343

<+=?|> property: [{

344

<+=?|> token : "text",

345

<+=?|> regex : "\\s+"

346

<+=?|> }, {

347

<+=?|> token : [

348

<+=?|> "storage.type", "punctuation.operator", "entity.name.function", "text",

349

<+=?|> "keyword.operator", "text",

350

<+=?|> "storage.type", "text", "entity.name.function", "text", "paren.lparen"

351

<+=?|> ],

352

<+=?|>                regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(?:(\\s+)(\\w+))?(\\s*)(\\()",

353

<+=?|> next: "function_arguments"

354

<+=?|> }, {

355

<+=?|> token : "punctuation.operator",

356

<+=?|> regex : /[.](?![.])/

357

<+=?|> }, {

358

<+=?|> token : "support.function",

359

<+=?|>                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(?=\()/

360

<+=?|> }, {

361

<+=?|> token : "support.function.dom",

362

<+=?|>                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|ClassName)|ById)|Attribute(?:Node)?)|blur)\b(?=\()/

363

<+=?|> }, {

364

<+=?|> token : "support.constant",

365

<+=?|>                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/

366

<+=?|> }, {

367

<+=?|> token : "identifier",

368

<+=?|> regex : identifierRe

369

<+=?|> }, {

370

<+=?|> regex: "",

371

<+=?|> token: "empty",

372

<+=?|> next: "no_regex"

<+=?|> }

<+=?|> ],

<+=?|> "start": [

<+=?|> DocCommentHighlightRules.getStartRule("doc-start"),

377

<+=?|> comments("start"),

378

<+=?|> {

379

<+=?|> token: "string.regexp",

380

<+=?|> regex: "\\/",

381

<+=?|> next: "regex"

382

<+=?|> }, {

383

<+=?|> token : "text",

384

<+=?|> regex : "\\s+|^$",

385

<+=?|> next : "start"

386

<+=?|> }, {

387

<+=?|> token: "empty",

388

<+=?|> regex: "",

389

<+=?|> next: "no_regex"

<+=?|> }

<+=?|> ],

<+=?|> "regex": [

<+=?|> {

<+=?|> token: "regexp.keyword.operator",

395

<+=?|> regex: "\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"

396

<+=?|> }, {

397

<+=?|> token: "string.regexp",

398

<+=?|> regex: "/[sxngimy]*",

399

<+=?|> next: "no_regex"

400

<+=?|> }, {

401

<+=?|> token : "invalid",

402

<+=?|> regex: /\{\d+\b,?\d*\}[+*]|[+*$^?][+*]|[$^][?]|\?{3,}/

403

<+=?|> }, {

404

<+=?|> token : "constant.language.escape",

405

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

406

<+=?|> }, {

407

<+=?|> token : "constant.language.delimiter",

408

<+=?|> regex: /\|/

409

<+=?|> }, {

410

<+=?|> token: "constant.language.escape",

411

<+=?|> regex: /\[\^?/,

412

<+=?|> next: "regex_character_class"

413

<+=?|> }, {

414

<+=?|> token: "empty",

415

<+=?|> regex: "$",

416

<+=?|> next: "no_regex"

417

<+=?|> }, {

418

<+=?|> defaultToken: "string.regexp"

419

<+=?|> }

420

<+=?|> ],

421

<+=?|> "regex_character_class": [

422

<+=?|> {

423

<+=?|> token: "regexp.charclass.keyword.operator",

424

<+=?|> regex: "\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"

425

<+=?|> }, {

426

<+=?|> token: "constant.language.escape",

427

<+=?|> regex: "]",

428

<+=?|> next: "regex"

429

<+=?|> }, {

430

<+=?|> token: "constant.language.escape",

431

<+=?|> regex: "-"

432

<+=?|> }, {

433

<+=?|> token: "empty",

434

<+=?|> regex: "$",

435

<+=?|> next: "no_regex"

436

<+=?|> }, {

437

<+=?|> defaultToken: "string.regexp.charachterclass"

438

<+=?|> }

439

<+=?|> ],

440

<+=?|> "function_arguments": [

441

<+=?|> {

442

<+=?|> token: "variable.parameter",

443

<+=?|> regex: identifierRe

444

<+=?|> }, {

445

<+=?|> token: "punctuation.operator",

446

<+=?|> regex: "[, ]+"

447

<+=?|> }, {

448

<+=?|> token: "punctuation.operator",

449

<+=?|> regex: "$"

450

<+=?|> }, {

451

<+=?|> token: "empty",

452

<+=?|> regex: "",

453

<+=?|> next: "no_regex"

454

<+=?|> }

455

<+=?|> ],

456

<+=?|> "qqstring" : [

457

<+=?|> {

458

<+=?|> token : "constant.language.escape",

459

<+=?|> regex : escapedRe

460

<+=?|> }, {

461

<+=?|> token : "string",

462

<+=?|> regex : "\\\\$",

463

<+=?|> next : "qqstring"

464

<+=?|> }, {

465

<+=?|> token : "string",

466

<+=?|> regex : '"|$',

467

<+=?|> next : "no_regex"

468

<+=?|> }, {

469

<+=?|> defaultToken: "string"

470

<+=?|> }

471

<+=?|> ],

472

<+=?|> "qstring" : [

473

<+=?|> {

474

<+=?|> token : "constant.language.escape",

475

<+=?|> regex : escapedRe

476

<+=?|> }, {

477

<+=?|> token : "string",

478

<+=?|> regex : "\\\\$",

479

<+=?|> next : "qstring"

480

<+=?|> }, {

481

<+=?|> token : "string",

482

<+=?|> regex : "'|$",

483

<+=?|> next : "no_regex"

484

<+=?|> }, {

485

<+=?|> defaultToken: "string"

<+=?|> }

<+=?|> ]

<+=?|> };

<+=?|> if (!options || !options.noES6) {

492

<+=?|> this.$rules.no_regex.unshift({

493

<+=?|> regex: "[{}]", onMatch: function(val, state, stack) {

494

<+=?|> this.next = val == "{" ? this.nextState : "";

495

<+=?|> if (val == "{" && stack.length) {

496

<+=?|> stack.unshift("start", state);

497

<+=?|> }

498

<+=?|> else if (val == "}" && stack.length) {

499

<+=?|> stack.shift();

500

<+=?|> this.next = stack.shift();

501

<+=?|> if (this.next.indexOf("string") != -1 || this.next.indexOf("jsx") != -1)

502

<+=?|> return "paren.quasi.end";

503

<+=?|> }

504

<+=?|> return val == "{" ? "paren.lparen" : "paren.rparen";

505

<+=?|> },

506

<+=?|> nextState: "start"

507

<+=?|> }, {

508

<+=?|> token : "string.quasi.start",

509

<+=?|> regex : /`/,

510

<+=?|> push : [{

511

<+=?|> token : "constant.language.escape",

512

<+=?|> regex : escapedRe

513

<+=?|> }, {

514

<+=?|> token : "paren.quasi.start",

515

<+=?|> regex : /\${/,

516

<+=?|> push : "start"

517

<+=?|> }, {

518

<+=?|> token : "string.quasi.end",

519

<+=?|> regex : /`/,

520

<+=?|> next : "pop"

521

<+=?|> }, {

522

<+=?|> defaultToken: "string.quasi"

<+=?|> }]

<+=?|> });

<+=?|> if (!options || options.jsx != false)

527

<+=?|> JSX.call(this);

528

<+=?|> }

529

530

<+=?|> this.embedRules(DocCommentHighlightRules, "doc-",

531

<+=?|> [ DocCommentHighlightRules.getEndRule("no_regex") ]);

532

533

<+=?|> this.normalizeRules();

534

<+=?|>};

535

536

<+=?|>oop.inherits(JavaScriptHighlightRules, TextHighlightRules);

537

538

<+=?|>function JSX() {

539

<+=?|> var tagRegex = identifierRe.replace("\\d", "\\d\\-");

540

<+=?|> var jsxTag = {

541

<+=?|> onMatch : function(val, state, stack) {

542

<+=?|> var offset = val.charAt(1) == "/" ? 2 : 1;

543

<+=?|> if (offset == 1) {

544

<+=?|> if (state != this.nextState)

545

<+=?|> stack.unshift(this.next, this.nextState, 0);

546

<+=?|> else

547

<+=?|> stack.unshift(this.next);

548

<+=?|> stack[2]++;

549

<+=?|> } else if (offset == 2) {

550

<+=?|> if (state == this.nextState) {

551

<+=?|> stack[1]--;

552

<+=?|> if (!stack[1] || stack[1] < 0) {

553

<+=?|> stack.shift();

554

<+=?|> stack.shift();

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> return [{

<+=?|> type: "meta.tag.punctuation." + (offset == 1 ? "" : "end-") + "tag-open.xml",

560

<+=?|> value: val.slice(0, offset)

561

<+=?|> }, {

562

<+=?|> type: "meta.tag.tag-name.xml",

563

<+=?|> value: val.substr(offset)

564

<+=?|> }];

565

<+=?|> },

566

<+=?|> regex : "</?" + tagRegex + "",

567

<+=?|> next: "jsxAttributes",

568

<+=?|> nextState: "jsx"

569

<+=?|> };

570

<+=?|> this.$rules.start.unshift(jsxTag);

571

<+=?|> var jsxJsRule = {

572

<+=?|> regex: "{",

573

<+=?|> token: "paren.quasi.start",

574

<+=?|> push: "start"

575

<+=?|> };

576

<+=?|> this.$rules.jsx = [

577

<+=?|> jsxJsRule,

578

<+=?|> jsxTag,

579

<+=?|> {include : "reference"},

580

<+=?|> {defaultToken: "string"}

581

<+=?|> ];

582

<+=?|> this.$rules.jsxAttributes = [{

583

<+=?|> token : "meta.tag.punctuation.tag-close.xml",

584

<+=?|> regex : "/?>",

585

<+=?|> onMatch : function(value, currentState, stack) {

586

<+=?|> if (currentState == stack[0])

587

<+=?|> stack.shift();

588

<+=?|> if (value.length == 2) {

589

<+=?|> if (stack[0] == this.nextState)

590

<+=?|> stack[1]--;

591

<+=?|> if (!stack[1] || stack[1] < 0) {

592

<+=?|> stack.splice(0, 2);

593

<+=?|> }

594

<+=?|> }

595

<+=?|> this.next = stack[0] || "start";

596

<+=?|> return [{type: this.token, value: value}];

597

<+=?|> },

598

<+=?|> nextState: "jsx"

599

<+=?|> },

600

<+=?|> jsxJsRule,

601

<+=?|> comments("jsxAttributes"),

602

<+=?|> {

603

<+=?|> token : "entity.other.attribute-name.xml",

604

<+=?|> regex : tagRegex

605

<+=?|> }, {

606

<+=?|> token : "keyword.operator.attribute-equals.xml",

607

<+=?|> regex : "="

608

<+=?|> }, {

609

<+=?|> token : "text.tag-whitespace.xml",

610

<+=?|> regex : "\\s+"

611

<+=?|> }, {

612

<+=?|> token : "string.attribute-value.xml",

613

<+=?|> regex : "'",

614

<+=?|> stateName : "jsx_attr_q",

615

<+=?|> push : [

616

<+=?|> {token : "string.attribute-value.xml", regex: "'", next: "pop"},

617

<+=?|> {include : "reference"},

618

<+=?|> {defaultToken : "string.attribute-value.xml"}

619

<+=?|> ]

620

<+=?|> }, {

621

<+=?|> token : "string.attribute-value.xml",

622

<+=?|> regex : '"',

623

<+=?|> stateName : "jsx_attr_qq",

624

<+=?|> push : [

625

<+=?|> {token : "string.attribute-value.xml", regex: '"', next: "pop"},

626

<+=?|> {include : "reference"},

627

<+=?|> {defaultToken : "string.attribute-value.xml"}

<+=?|> ]

<+=?|> },

<+=?|> jsxTag

<+=?|> ];

<+=?|> this.$rules.reference = [{

633

<+=?|> token : "constant.language.escape.reference.xml",

634

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

<+=?|> }];

<+=?|>}

<+=?|>function comments(next) {

639

<+=?|> return [

640

<+=?|> {

641

<+=?|> token : "comment", // multi line comment

642

<+=?|> regex : /\/\*/,

643

<+=?|> next: [

644

<+=?|> DocCommentHighlightRules.getTagRule(),

645

<+=?|> {token : "comment", regex : "\\*\\/", next : next || "pop"},

646

<+=?|> {defaultToken : "comment", caseInsensitive: true}

647

<+=?|> ]

648

<+=?|> }, {

649

<+=?|> token : "comment",

650

<+=?|> regex : "\\/\\/",

651

<+=?|> next: [

652

<+=?|> DocCommentHighlightRules.getTagRule(),

653

<+=?|> {token : "comment", regex : "$|^", next : next || "pop"},

654

<+=?|> {defaultToken : "comment", caseInsensitive: true}

<+=?|> ]

<+=?|> }

<+=?|> ];

<+=?|>}

<+=?|>exports.JavaScriptHighlightRules = JavaScriptHighlightRules;

660

<+=?|>});

661

662

<+=?|>ace.define("ace/mode/xml_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {

663

<+=?|>"use strict";

664

665

<+=?|>var oop = require("../lib/oop");

666

<+=?|>var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;

667

668

<+=?|>var XmlHighlightRules = function(normalize) {

669

<+=?|> var tagRegex = "[_:a-zA-Z\xc0-\uffff][-_:.a-zA-Z0-9\xc0-\uffff]*";

670

671

<+=?|> this.$rules = {

672

<+=?|> start : [

673

<+=?|> {token : "string.cdata.xml", regex : "<\\!\\[CDATA\\[", next : "cdata"},

674

<+=?|> {

675

<+=?|> token : ["punctuation.xml-decl.xml", "keyword.xml-decl.xml"],

676

<+=?|> regex : "(<\\?)(xml)(?=[\\s])", next : "xml_decl", caseInsensitive: true

677

<+=?|> },

678

<+=?|> {

679

<+=?|> token : ["punctuation.instruction.xml", "keyword.instruction.xml"],

680

<+=?|> regex : "(<\\?)(" + tagRegex + ")", next : "processing_instruction"

681

<+=?|> },

682

<+=?|> {token : "comment.xml", regex : "<\\!--", next : "comment"},

683

<+=?|> {

684

<+=?|> token : ["xml-pe.doctype.xml", "xml-pe.doctype.xml"],

685

<+=?|> regex : "(<\\!)(DOCTYPE)(?=[\\s])", next : "doctype", caseInsensitive: true

686

<+=?|> },

687

<+=?|> {include : "tag"},

688

<+=?|> {token : "text.end-tag-open.xml", regex: "</"},

689

<+=?|> {token : "text.tag-open.xml", regex: "<"},

690

<+=?|> {include : "reference"},

691

<+=?|> {defaultToken : "text.xml"}

692

<+=?|> ],

693

694

<+=?|> xml_decl : [{

695

<+=?|> token : "entity.other.attribute-name.decl-attribute-name.xml",

696

<+=?|> regex : "(?:" + tagRegex + ":)?" + tagRegex + ""

697

<+=?|> }, {

698

<+=?|> token : "keyword.operator.decl-attribute-equals.xml",

699

<+=?|> regex : "="

700

<+=?|> }, {

701

<+=?|> include: "whitespace"

702

<+=?|> }, {

703

<+=?|> include: "string"

704

<+=?|> }, {

705

<+=?|> token : "punctuation.xml-decl.xml",

706

<+=?|> regex : "\\?>",

707

<+=?|> next : "start"

708

<+=?|> }],

709

710

<+=?|> processing_instruction : [

711

<+=?|> {token : "punctuation.instruction.xml", regex : "\\?>", next : "start"},

712

<+=?|> {defaultToken : "instruction.xml"}

<+=?|> ],

<+=?|> doctype : [

<+=?|> {include : "whitespace"},

717

<+=?|> {include : "string"},

718

<+=?|> {token : "xml-pe.doctype.xml", regex : ">", next : "start"},

719

<+=?|> {token : "xml-pe.xml", regex : "[-_a-zA-Z0-9:]+"},

720

<+=?|> {token : "punctuation.int-subset", regex : "\\[", push : "int_subset"}

721

<+=?|> ],

722

723

<+=?|> int_subset : [{

724

<+=?|> token : "text.xml",

725

<+=?|> regex : "\\s+"

726

<+=?|> }, {

727

<+=?|> token: "punctuation.int-subset.xml",

<+=?|> regex: "]",

<+=?|> next: "pop"

<+=?|> }, {

<+=?|> token : ["punctuation.markup-decl.xml", "keyword.markup-decl.xml"],

732

<+=?|> regex : "(<\\!)(" + tagRegex + ")",

733

<+=?|> push : [{

734

<+=?|> token : "text",

735

<+=?|> regex : "\\s+"

736

<+=?|> },

737

<+=?|> {

738

<+=?|> token : "punctuation.markup-decl.xml",

739

<+=?|> regex : ">",

740

<+=?|> next : "pop"

741

<+=?|> },

742

<+=?|> {include : "string"}]

<+=?|> }],

<+=?|> cdata : [

<+=?|> {token : "string.cdata.xml", regex : "\\]\\]>", next : "start"},

747

<+=?|> {token : "text.xml", regex : "\\s+"},

748

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

<+=?|> ],

<+=?|> comment : [

<+=?|> {token : "comment.xml", regex : "-->", next : "start"},

753

<+=?|> {defaultToken : "comment.xml"}

754

<+=?|> ],

755

756

<+=?|> reference : [{

757

<+=?|> token : "constant.language.escape.reference.xml",

758

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

759

<+=?|> }],

760

761

<+=?|> attr_reference : [{

762

<+=?|> token : "constant.language.escape.reference.attribute-value.xml",

763

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

<+=?|> }],

<+=?|> tag : [{

<+=?|>            token : ["meta.tag.punctuation.tag-open.xml", "meta.tag.punctuation.end-tag-open.xml", "meta.tag.tag-name.xml"],

768

<+=?|> regex : "(?:(<)|(</))((?:" + tagRegex + ":)?" + tagRegex + ")",

769

<+=?|> next: [

770

<+=?|> {include : "attributes"},

771

<+=?|> {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : "start"}

<+=?|> ]

<+=?|> }],

<+=?|> tag_whitespace : [

776

<+=?|> {token : "text.tag-whitespace.xml", regex : "\\s+"}

777

<+=?|> ],

778

<+=?|> whitespace : [

779

<+=?|> {token : "text.whitespace.xml", regex : "\\s+"}

780

<+=?|> ],

781

<+=?|> string: [{

782

<+=?|> token : "string.xml",

783

<+=?|> regex : "'",

784

<+=?|> push : [

785

<+=?|> {token : "string.xml", regex: "'", next: "pop"},

786

<+=?|> {defaultToken : "string.xml"}

787

<+=?|> ]

788

<+=?|> }, {

789

<+=?|> token : "string.xml",

790

<+=?|> regex : '"',

791

<+=?|> push : [

792

<+=?|> {token : "string.xml", regex: '"', next: "pop"},

793

<+=?|> {defaultToken : "string.xml"}

<+=?|> ]

<+=?|> }],

<+=?|> attributes: [{

798

<+=?|> token : "entity.other.attribute-name.xml",

799

<+=?|> regex : "(?:" + tagRegex + ":)?" + tagRegex + ""

800

<+=?|> }, {

801

<+=?|> token : "keyword.operator.attribute-equals.xml",

802

<+=?|> regex : "="

803

<+=?|> }, {

804

<+=?|> include: "tag_whitespace"

805

<+=?|> }, {

806

<+=?|> include: "attribute_value"

807

<+=?|> }],

808

809

<+=?|> attribute_value: [{

810

<+=?|> token : "string.attribute-value.xml",

811

<+=?|> regex : "'",

812

<+=?|> push : [

813

<+=?|> {token : "string.attribute-value.xml", regex: "'", next: "pop"},

814

<+=?|> {include : "attr_reference"},

815

<+=?|> {defaultToken : "string.attribute-value.xml"}

816

<+=?|> ]

817

<+=?|> }, {

818

<+=?|> token : "string.attribute-value.xml",

819

<+=?|> regex : '"',

820

<+=?|> push : [

821

<+=?|> {token : "string.attribute-value.xml", regex: '"', next: "pop"},

822

<+=?|> {include : "attr_reference"},

823

<+=?|> {defaultToken : "string.attribute-value.xml"}

<+=?|> ]

<+=?|> }]

<+=?|> };

<+=?|> if (this.constructor === XmlHighlightRules)

829

<+=?|> this.normalizeRules();

<+=?|>};

<+=?|>(function() {

834

835

<+=?|> this.embedTagRules = function(HighlightRules, prefix, tag){

836

<+=?|> this.$rules.tag.unshift({

837

<+=?|> token : ["meta.tag.punctuation.tag-open.xml", "meta.tag." + tag + ".tag-name.xml"],

838

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

839

<+=?|> next: [

840

<+=?|> {include : "attributes"},

841

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

<+=?|> ]

<+=?|> });

<+=?|> this.$rules[tag + "-end"] = [

846

<+=?|> {include : "attributes"},

847

<+=?|> {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next: "start",

848

<+=?|> onMatch : function(value, currentState, stack) {

849

<+=?|> stack.splice(0);

850

<+=?|> return this.token;

<+=?|> }}

<+=?|> ]

<+=?|> this.embedRules(HighlightRules, prefix, [{

855

<+=?|> token: ["meta.tag.punctuation.end-tag-open.xml", "meta.tag." + tag + ".tag-name.xml"],

856

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

857

<+=?|> next: tag + "-end"

858

<+=?|> }, {

859

<+=?|> token: "string.cdata.xml",

860

<+=?|> regex : "<\\!\\[CDATA\\["

861

<+=?|> }, {

862

<+=?|> token: "string.cdata.xml",

863

<+=?|> regex : "\\]\\]>"

<+=?|> }]);

<+=?|> };

<+=?|>}).call(TextHighlightRules.prototype);

868

869

<+=?|>oop.inherits(XmlHighlightRules, TextHighlightRules);

870

871

<+=?|>exports.XmlHighlightRules = XmlHighlightRules;

872

<+=?|>});

873

874

<+=?|>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) {

875

<+=?|>"use strict";

876

877

<+=?|>var oop = require("../lib/oop");

878

<+=?|>var lang = require("../lib/lang");

879

<+=?|>var CssHighlightRules = require("./css_highlight_rules").CssHighlightRules;

880

<+=?|>var JavaScriptHighlightRules = require("./javascript_highlight_rules").JavaScriptHighlightRules;

881

<+=?|>var XmlHighlightRules = require("./xml_highlight_rules").XmlHighlightRules;

882

883

<+=?|>var tagMap = lang.createMap({

884

<+=?|> a : 'anchor',

885

<+=?|> button : 'form',

886

<+=?|> form : 'form',

887

<+=?|> img : 'image',

888

<+=?|> input : 'form',

889

<+=?|> label : 'form',

890

<+=?|> option : 'form',

891

<+=?|> script : 'script',

892

<+=?|> select : 'form',

893

<+=?|> textarea : 'form',

894

<+=?|> style : 'style',

895

<+=?|> table : 'table',

896

<+=?|> tbody : 'table',

897

<+=?|> td : 'table',

898

<+=?|> tfoot : 'table',

899

<+=?|> th : 'table',

900

<+=?|> tr : 'table'

901

<+=?|>});

902

903

<+=?|>var HtmlHighlightRules = function() {

904

<+=?|> XmlHighlightRules.call(this);

905

906

<+=?|> this.addRules({

907

<+=?|> attributes: [{

908

<+=?|> include : "tag_whitespace"

909

<+=?|> }, {

910

<+=?|> token : "entity.other.attribute-name.xml",

911

<+=?|> regex : "[-_a-zA-Z0-9:.]+"

912

<+=?|> }, {

913

<+=?|> token : "keyword.operator.attribute-equals.xml",

914

<+=?|> regex : "=",

915

<+=?|> push : [{

916

<+=?|> include: "tag_whitespace"

917

<+=?|> }, {

918

<+=?|> token : "string.unquoted.attribute-value.html",

919

<+=?|> regex : "[^<>='\"`\\s]+",

920

<+=?|> next : "pop"

921

<+=?|> }, {

922

<+=?|> token : "empty",

923

<+=?|> regex : "",

924

<+=?|> next : "pop"

925

<+=?|> }]

926

<+=?|> }, {

927

<+=?|> include : "attribute_value"

928

<+=?|> }],

929

<+=?|> tag: [{

930

<+=?|> token : function(start, tag) {

931

<+=?|> var group = tagMap[tag];

932

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

933

<+=?|> "meta.tag" + (group ? "." + group : "") + ".tag-name.xml"];

934

<+=?|> },

935

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

936

<+=?|> next: "tag_stuff"

937

<+=?|> }],

938

<+=?|> tag_stuff: [

939

<+=?|> {include : "attributes"},

940

<+=?|> {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : "start"}

<+=?|> ]

<+=?|> });

<+=?|> this.embedTagRules(CssHighlightRules, "css-", "style");

945

<+=?|> this.embedTagRules(new JavaScriptHighlightRules({jsx: false}).getRules(), "js-", "script");

946

947

<+=?|> if (this.constructor === HtmlHighlightRules)

948

<+=?|> this.normalizeRules();

949

<+=?|>};

950

951

<+=?|>oop.inherits(HtmlHighlightRules, XmlHighlightRules);

952

953

<+=?|>exports.HtmlHighlightRules = HtmlHighlightRules;

954

<+=?|>});

955

956

<+=?|>ace.define("ace/mode/ruby_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {

957

<+=?|>"use strict";

958

959

<+=?|>var oop = require("../lib/oop");

960

<+=?|>var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;

961

<+=?|>var constantOtherSymbol = exports.constantOtherSymbol = {

962

<+=?|> token : "constant.other.symbol.ruby", // symbol

963

<+=?|> regex : "[:](?:[A-Za-z_]|[@$](?=[a-zA-Z0-9_]))[a-zA-Z0-9_]*[!=?]?"

964

<+=?|>};

965

966

<+=?|>var qString = exports.qString = {

967

<+=?|> token : "string", // single line

968

<+=?|> regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"

969

<+=?|>};

970

971

<+=?|>var qqString = exports.qqString = {

972

<+=?|> token : "string", // single line

973

<+=?|> regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'

974

<+=?|>};

975

976

<+=?|>var tString = exports.tString = {

977

<+=?|> token : "string", // backtick string

978

<+=?|> regex : "[`](?:(?:\\\\.)|(?:[^'\\\\]))*?[`]"

979

<+=?|>};

980

981

<+=?|>var constantNumericHex = exports.constantNumericHex = {

982

<+=?|> token : "constant.numeric", // hex

983

<+=?|> regex : "0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_(?=[0-9a-fA-F]))*\\b"

984

<+=?|>};

985

986

<+=?|>var constantNumericFloat = exports.constantNumericFloat = {

987

<+=?|> token : "constant.numeric", // float

988

<+=?|> regex : "[+-]?\\d(?:\\d|_(?=\\d))*(?:(?:\\.\\d(?:\\d|_(?=\\d))*)?(?:[eE][+-]?\\d+)?)?\\b"

989

<+=?|>};

990

991

<+=?|>var RubyHighlightRules = function() {

992

993

<+=?|> var builtinFunctions = (

<+=?|> "throw|trace_var|trap|untrace_var|atan2|cos|exp|frexp|ldexp|log|log10|sin|sqrt|tan|" +

<+=?|> "authenticate_or_request_with_http_basic|authenticate_or_request_with_http_digest|" +

<+=?|> "has_many|has_one|belongs_to|has_and_belongs_to_many"

1024

<+=?|> );

1025

1026

<+=?|> var keywords = (

1027

<+=?|> "alias|and|BEGIN|begin|break|case|class|def|defined|do|else|elsif|END|end|ensure|" +

1028

<+=?|> "__FILE__|finally|for|gem|if|in|__LINE__|module|next|not|or|private|protected|public|" +

<+=?|> );

<+=?|> var buildinConstants = (

<+=?|> );

<+=?|> var builtinVariables = (

<+=?|> );

<+=?|> var keywordMapper = this.$keywords = this.createKeywordMapper({

1043

<+=?|> "keyword": keywords,

1044

<+=?|> "constant.language": buildinConstants,

1045

<+=?|> "variable.language": builtinVariables,

1046

<+=?|> "support.function": builtinFunctions,

1047

<+=?|> "invalid.deprecated": "debugger" // TODO is this a remnant from js mode?

1048

<+=?|> }, "identifier");

1049

1050

<+=?|> this.$rules = {

1051

<+=?|> "start" : [

1052

<+=?|> {

1053

<+=?|> token : "comment",

1054

<+=?|> regex : "#.*$"

1055

<+=?|> }, {

1056

<+=?|> token : "comment", // multi line comment

1057

<+=?|> regex : "^=begin(?:$|\\s.*$)",

1058

<+=?|> next : "comment"

1059

<+=?|> }, {

1060

<+=?|> token : "string.regexp",

1061

<+=?|> regex : "[/](?:(?:\\[(?:\\\\]|[^\\]])+\\])|(?:\\\\/|[^\\]/]))*[/]\\w*\\s*(?=[).,;]|$)"

<+=?|> },

<+=?|> [{

<+=?|> regex: "[{}]", onMatch: function(val, state, stack) {

1066

<+=?|> this.next = val == "{" ? this.nextState : "";

1067

<+=?|> if (val == "{" && stack.length) {

1068

<+=?|> stack.unshift("start", state);

1069

<+=?|> return "paren.lparen";

1070

<+=?|> }

1071

<+=?|> if (val == "}" && stack.length) {

1072

<+=?|> stack.shift();

1073

<+=?|> this.next = stack.shift();

1074

<+=?|> if (this.next.indexOf("string") != -1)

1075

<+=?|> return "paren.end";

1076

<+=?|> }

1077

<+=?|> return val == "{" ? "paren.lparen" : "paren.rparen";

1078

<+=?|> },

1079

<+=?|> nextState: "start"

1080

<+=?|> }, {

1081

<+=?|> token : "string.start",

1082

<+=?|> regex : /"/,

1083

<+=?|> push : [{

1084

<+=?|> token : "constant.language.escape",

1085

<+=?|> regex : /\\(?:[nsrtvfbae'"\\]|c.|C-.|M-.(?:\\C-.)?|[0-7]{3}|x[\da-fA-F]{2}|u[\da-fA-F]{4})/

1086

<+=?|> }, {

1087

<+=?|> token : "paren.start",

1088

<+=?|> regex : /#{/,

1089

<+=?|> push : "start"

1090

<+=?|> }, {

1091

<+=?|> token : "string.end",

1092

<+=?|> regex : /"/,

1093

<+=?|> next : "pop"

1094

<+=?|> }, {

1095

<+=?|> defaultToken: "string"

1096

<+=?|> }]

1097

<+=?|> }, {

1098

<+=?|> token : "string.start",

1099

<+=?|> regex : /`/,

1100

<+=?|> push : [{

1101

<+=?|> token : "constant.language.escape",

1102

<+=?|> regex : /\\(?:[nsrtvfbae'"\\]|c.|C-.|M-.(?:\\C-.)?|[0-7]{3}|x[\da-fA-F]{2}|u[\da-fA-F]{4})/

1103

<+=?|> }, {

1104

<+=?|> token : "paren.start",

1105

<+=?|> regex : /#{/,

1106

<+=?|> push : "start"

1107

<+=?|> }, {

1108

<+=?|> token : "string.end",

1109

<+=?|> regex : /`/,

1110

<+=?|> next : "pop"

1111

<+=?|> }, {

1112

<+=?|> defaultToken: "string"

1113

<+=?|> }]

1114

<+=?|> }, {

1115

<+=?|> token : "string.start",

1116

<+=?|> regex : /'/,

1117

<+=?|> push : [{

1118

<+=?|> token : "constant.language.escape",

1119

<+=?|> regex : /\\['\\]/

1120

<+=?|> }, {

1121

<+=?|> token : "string.end",

1122

<+=?|> regex : /'/,

1123

<+=?|> next : "pop"

1124

<+=?|> }, {

1125

<+=?|> defaultToken: "string"

<+=?|> }]

<+=?|> }],

<+=?|> {

<+=?|> token : "text", // namespaces aren't symbols

1131

<+=?|> regex : "::"

1132

<+=?|> }, {

1133

<+=?|> token : "variable.instance", // instance variable

1134

<+=?|> regex : "@{1,2}[a-zA-Z_\\d]+"

1135

<+=?|> }, {

1136

<+=?|> token : "support.class", // class name

1137

<+=?|> regex : "[A-Z][a-zA-Z_\\d]+"

1138

<+=?|> },

1139

1140

<+=?|> constantOtherSymbol,

1141

<+=?|> constantNumericHex,

1142

<+=?|> constantNumericFloat,

1143

1144

<+=?|> {

1145

<+=?|> token : "constant.language.boolean",

1146

<+=?|> regex : "(?:true|false)\\b"

1147

<+=?|> }, {

1148

<+=?|> token : keywordMapper,

1149

<+=?|> regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"

1150

<+=?|> }, {

1151

<+=?|> token : "punctuation.separator.key-value",

1152

<+=?|> regex : "=>"

1153

<+=?|> }, {

1154

<+=?|> stateName: "heredoc",

1155

<+=?|> onMatch : function(value, currentState, stack) {

1156

<+=?|> var next = value[2] == '-' ? "indentedHeredoc" : "heredoc";

1157

<+=?|> var tokens = value.split(this.splitRegex);

1158

<+=?|> stack.push(next, tokens[3]);

1159

<+=?|> return [

1160

<+=?|> {type:"constant", value: tokens[1]},

1161

<+=?|> {type:"string", value: tokens[2]},

1162

<+=?|> {type:"support.class", value: tokens[3]},

1163

<+=?|> {type:"string", value: tokens[4]}

1164

<+=?|> ];

1165

<+=?|> },

1166

<+=?|> regex : "(<<-?)(['\"`]?)([\\w]+)(['\"`]?)",

1167

<+=?|> rules: {

1168

<+=?|> heredoc: [{

1169

<+=?|> onMatch: function(value, currentState, stack) {

1170

<+=?|> if (value === stack[1]) {

1171

<+=?|> stack.shift();

1172

<+=?|> stack.shift();

1173

<+=?|> this.next = stack[0] || "start";

1174

<+=?|> return "support.class";

1175

<+=?|> }

1176

<+=?|> this.next = "";

1177

<+=?|> return "string";

1178

<+=?|> },

1179

<+=?|> regex: ".*$",

1180

<+=?|> next: "start"

1181

<+=?|> }],

1182

<+=?|> indentedHeredoc: [{

1183

<+=?|> token: "string",

1184

<+=?|> regex: "^ +"

1185

<+=?|> }, {

1186

<+=?|> onMatch: function(value, currentState, stack) {

1187

<+=?|> if (value === stack[1]) {

1188

<+=?|> stack.shift();

1189

<+=?|> stack.shift();

1190

<+=?|> this.next = stack[0] || "start";

1191

<+=?|> return "support.class";

1192

<+=?|> }

1193

<+=?|> this.next = "";

1194

<+=?|> return "string";

1195

<+=?|> },

1196

<+=?|> regex: ".*$",

1197

<+=?|> next: "start"

<+=?|> }]

<+=?|> }

<+=?|> }, {

<+=?|> regex : "$",

1202

<+=?|> token : "empty",

1203

<+=?|> next : function(currentState, stack) {

1204

<+=?|> if (stack[0] === "heredoc" || stack[0] === "indentedHeredoc")

1205

<+=?|> return stack[0];

1206

<+=?|> return currentState;

1207

<+=?|> }

1208

<+=?|> }, {

1209

<+=?|> token : "string.character",

1210

<+=?|> regex : "\\B\\?."

1211

<+=?|> }, {

1212

<+=?|> token : "keyword.operator",

1213

<+=?|>                regex : "!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|~|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\\|\\||\\?\\:|\\*=|%=|\\+=|\\-=|&=|\\^=|\\b(?:in|instanceof|new|delete|typeof|void)"

1214

<+=?|> }, {

1215

<+=?|> token : "paren.lparen",

1216

<+=?|> regex : "[[({]"

1217

<+=?|> }, {

1218

<+=?|> token : "paren.rparen",

1219

<+=?|> regex : "[\\])}]"

1220

<+=?|> }, {

1221

<+=?|> token : "text",

1222

<+=?|> regex : "\\s+"

1223

<+=?|> }

1224

<+=?|> ],

1225

<+=?|> "comment" : [

1226

<+=?|> {

1227

<+=?|> token : "comment", // closing comment

1228

<+=?|> regex : "^=end(?:$|\\s.*$)",

1229

<+=?|> next : "start"

1230

<+=?|> }, {

1231

<+=?|> token : "comment", // comment spanning whole line

1232

<+=?|> regex : ".+"

<+=?|> }

<+=?|> ]

<+=?|> };

<+=?|> this.normalizeRules();

1238

<+=?|>};

1239

1240

<+=?|>oop.inherits(RubyHighlightRules, TextHighlightRules);

1241

1242

<+=?|>exports.RubyHighlightRules = RubyHighlightRules;

1243

<+=?|>});

1244

1245

<+=?|>ace.define("ace/mode/html_ruby_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/html_highlight_rules","ace/mode/ruby_highlight_rules"], function(require, exports, module) {

1246

<+=?|> "use strict";

1247

1248

<+=?|> var oop = require("../lib/oop");

1249

<+=?|> var HtmlHighlightRules = require("./html_highlight_rules").HtmlHighlightRules;

1250

<+=?|> var RubyHighlightRules = require("./ruby_highlight_rules").RubyHighlightRules;

1251

1252

<+=?|> var HtmlRubyHighlightRules = function() {

1253

<+=?|> HtmlHighlightRules.call(this);

1254

1255

<+=?|> var startRules = [

1256

<+=?|> {

1257

<+=?|> regex: "<%%|%%>",

1258

<+=?|> token: "constant.language.escape"

1259

<+=?|> }, {

1260

<+=?|> token : "comment.start.erb",

1261

<+=?|> regex : "<%#",

1262

<+=?|> push : [{

1263

<+=?|> token : "comment.end.erb",

1264

<+=?|> regex: "%>",

1265

<+=?|> next: "pop",

1266

<+=?|> defaultToken:"comment"

1267

<+=?|> }]

1268

<+=?|> }, {

1269

<+=?|> token : "support.ruby_tag",

1270

<+=?|> regex : "<%+(?!>)[-=]?",

1271

<+=?|> push : "ruby-start"

<+=?|> }

<+=?|> ];

<+=?|> var endRules = [

1276

<+=?|> {

1277

<+=?|> token : "support.ruby_tag",

1278

<+=?|> regex : "%>",

1279

<+=?|> next : "pop"

1280

<+=?|> }, {

1281

<+=?|> token: "comment",

1282

<+=?|> regex: "#(?:[^%]|%[^>])*"

<+=?|> }

<+=?|> ];

<+=?|> for (var key in this.$rules)

1287

<+=?|> this.$rules[key].unshift.apply(this.$rules[key], startRules);

1288

1289

<+=?|> this.embedRules(RubyHighlightRules, "ruby-", endRules, ["start"]);

1290

1291

<+=?|> this.normalizeRules();

<+=?|> };

<+=?|> oop.inherits(HtmlRubyHighlightRules, HtmlHighlightRules);

1296

1297

<+=?|> exports.HtmlRubyHighlightRules = HtmlRubyHighlightRules;

1298

<+=?|>});

1299

1300

<+=?|>ace.define("ace/mode/matching_brace_outdent",["require","exports","module","ace/range"], function(require, exports, module) {

1301

<+=?|>"use strict";

1302

1303

<+=?|>var Range = require("../range").Range;

1304

1305

<+=?|>var MatchingBraceOutdent = function() {};

1306

1307

<+=?|>(function() {

1308

1309

<+=?|> this.checkOutdent = function(line, input) {

1310

<+=?|> if (! /^\s+$/.test(line))

1311

<+=?|> return false;

1312

1313

<+=?|> return /^\s*\}/.test(input);

1314

<+=?|> };

1315

1316

<+=?|> this.autoOutdent = function(doc, row) {

1317

<+=?|> var line = doc.getLine(row);

1318

<+=?|> var match = line.match(/^(\s*\})/);

1319

1320

<+=?|> if (!match) return 0;

1321

1322

<+=?|> var column = match[1].length;

1323

<+=?|> var openBracePos = doc.findMatchingBracket({row: row, column: column});

1324

1325

<+=?|> if (!openBracePos || openBracePos.row == row) return 0;

1326

1327

<+=?|> var indent = this.$getIndent(doc.getLine(openBracePos.row));

1328

<+=?|> doc.replace(new Range(row, 0, row, column-1), indent);

1329

<+=?|> };

1330

1331

<+=?|> this.$getIndent = function(line) {

1332

<+=?|> return line.match(/^\s*/)[0];

1333

<+=?|> };

1334

1335

<+=?|>}).call(MatchingBraceOutdent.prototype);

1336

1337

<+=?|>exports.MatchingBraceOutdent = MatchingBraceOutdent;

1338

<+=?|>});

1339

1340

<+=?|>ace.define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"], function(require, exports, module) {

1341

<+=?|>"use strict";

1342

1343

<+=?|>var oop = require("../../lib/oop");

1344

<+=?|>var Range = require("../../range").Range;

1345

<+=?|>var BaseFoldMode = require("./fold_mode").FoldMode;

1346

1347

<+=?|>var FoldMode = exports.FoldMode = function(commentRegex) {

1348

<+=?|> if (commentRegex) {

1349

<+=?|> this.foldingStartMarker = new RegExp(

1350

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

1351

<+=?|> );

1352

<+=?|> this.foldingStopMarker = new RegExp(

1353

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

<+=?|> );

<+=?|> }

<+=?|>};

<+=?|>oop.inherits(FoldMode, BaseFoldMode);

1358

1359

<+=?|>(function() {

1360

1361

<+=?|> this.foldingStartMarker = /(\{|\[)[^\}\]]*$|^\s*(\/\*)/;

1362

<+=?|> this.foldingStopMarker = /^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/;

1363

<+=?|> this.singleLineBlockCommentRe= /^\s*(\/\*).*\*\/\s*$/;

1364

<+=?|> this.tripleStarBlockCommentRe = /^\s*(\/\*\*\*).*\*\/\s*$/;

1365

<+=?|> this.startRegionRe = /^\s*(\/\*|\/\/)#?region\b/;

1366

<+=?|> this._getFoldWidgetBase = this.getFoldWidget;

1367

<+=?|> this.getFoldWidget = function(session, foldStyle, row) {

1368

<+=?|> var line = session.getLine(row);

1369

1370

<+=?|> if (this.singleLineBlockCommentRe.test(line)) {

1371

<+=?|> if (!this.startRegionRe.test(line) && !this.tripleStarBlockCommentRe.test(line))

<+=?|> return "";

<+=?|> }

<+=?|> var fw = this._getFoldWidgetBase(session, foldStyle, row);

1376

1377

<+=?|> if (!fw && this.startRegionRe.test(line))

1378

<+=?|> return "start"; // lineCommentRegionStart

<+=?|> return fw;

<+=?|> };

<+=?|> this.getFoldWidgetRange = function(session, foldStyle, row, forceMultiline) {

1384

<+=?|> var line = session.getLine(row);

1385

1386

<+=?|> if (this.startRegionRe.test(line))

1387

<+=?|> return this.getCommentRegionBlock(session, line, row);

1388

1389

<+=?|> var match = line.match(this.foldingStartMarker);

1390

<+=?|> if (match) {

1391

<+=?|> var i = match.index;

1392

1393

<+=?|> if (match[1])

1394

<+=?|> return this.openingBracketBlock(session, match[1], row, i);

1395

1396

<+=?|> var range = session.getCommentFoldRange(row, i + match[0].length, 1);

1397

1398

<+=?|> if (range && !range.isMultiLine()) {

1399

<+=?|> if (forceMultiline) {

1400

<+=?|> range = this.getSectionRange(session, row);

1401

<+=?|> } else if (foldStyle != "all")

1402

<+=?|> range = null;

1403

<+=?|> }

1404

1405

<+=?|> return range;

1406

<+=?|> }

1407

1408

<+=?|> if (foldStyle === "markbegin")

1409

<+=?|> return;

1410

1411

<+=?|> var match = line.match(this.foldingStopMarker);

1412

<+=?|> if (match) {

1413

<+=?|> var i = match.index + match[0].length;

1414

1415

<+=?|> if (match[1])

1416

<+=?|> return this.closingBracketBlock(session, match[1], row, i);

1417

1418

<+=?|> return session.getCommentFoldRange(row, i, -1);

<+=?|> }

<+=?|> };

<+=?|> this.getSectionRange = function(session, row) {

1423

<+=?|> var line = session.getLine(row);

1424

<+=?|> var startIndent = line.search(/\S/);

1425

<+=?|> var startRow = row;

1426

<+=?|> var startColumn = line.length;

1427

<+=?|> row = row + 1;

1428

<+=?|> var endRow = row;

1429

<+=?|> var maxRow = session.getLength();

1430

<+=?|> while (++row < maxRow) {

1431

<+=?|> line = session.getLine(row);

1432

<+=?|> var indent = line.search(/\S/);

1433

<+=?|> if (indent === -1)

1434

<+=?|> continue;

1435

<+=?|> if (startIndent > indent)

1436

<+=?|> break;

1437

<+=?|> var subRange = this.getFoldWidgetRange(session, "all", row);

1438

1439

<+=?|> if (subRange) {

1440

<+=?|> if (subRange.start.row <= startRow) {

1441

<+=?|> break;

1442

<+=?|> } else if (subRange.isMultiLine()) {

1443

<+=?|> row = subRange.end.row;

1444

<+=?|> } else if (startIndent == indent) {

<+=?|> break;

<+=?|> }

<+=?|> }

<+=?|> endRow = row;

1449

<+=?|> }

1450

1451

<+=?|> return new Range(startRow, startColumn, endRow, session.getLine(endRow).length);

1452

<+=?|> };

1453

<+=?|> this.getCommentRegionBlock = function(session, line, row) {

1454

<+=?|> var startColumn = line.search(/\s*$/);

1455

<+=?|> var maxRow = session.getLength();

1456

<+=?|> var startRow = row;

1457

1458

<+=?|> var re = /^\s*(?:\/\*|\/\/|--)#?(end)?region\b/;

1459

<+=?|> var depth = 1;

1460

<+=?|> while (++row < maxRow) {

1461

<+=?|> line = session.getLine(row);

1462

<+=?|> var m = re.exec(line);

1463

<+=?|> if (!m) continue;

1464

<+=?|> if (m[1]) depth--;

1465

<+=?|> else depth++;

1466

1467

<+=?|> if (!depth) break;

1468

<+=?|> }

1469

1470

<+=?|> var endRow = row;

1471

<+=?|> if (endRow > startRow) {

1472

<+=?|> return new Range(startRow, startColumn, endRow, line.length);

<+=?|> }

<+=?|> };

<+=?|>}).call(FoldMode.prototype);

<+=?|>});

<+=?|>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/worker/worker_client","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle"], function(require, exports, module) {

1481

<+=?|>"use strict";

1482

1483

<+=?|>var oop = require("../lib/oop");

1484

<+=?|>var TextMode = require("./text").Mode;

1485

<+=?|>var JavaScriptHighlightRules = require("./javascript_highlight_rules").JavaScriptHighlightRules;

1486

<+=?|>var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;

1487

<+=?|>var WorkerClient = require("../worker/worker_client").WorkerClient;

1488

<+=?|>var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;

1489

<+=?|>var CStyleFoldMode = require("./folding/cstyle").FoldMode;

1490

1491

<+=?|>var Mode = function() {

1492

<+=?|> this.HighlightRules = JavaScriptHighlightRules;

1493

1494

<+=?|> this.$outdent = new MatchingBraceOutdent();

1495

<+=?|> this.$behaviour = new CstyleBehaviour();

1496

<+=?|> this.foldingRules = new CStyleFoldMode();

1497

<+=?|>};

1498

<+=?|>oop.inherits(Mode, TextMode);

1499

1500

<+=?|>(function() {

1501

1502

<+=?|> this.lineCommentStart = "//";

1503

<+=?|> this.blockComment = {start: "/*", end: "*/"};

1504

1505

<+=?|> this.getNextLineIndent = function(state, line, tab) {

1506

<+=?|> var indent = this.$getIndent(line);

1507

1508

<+=?|> var tokenizedLine = this.getTokenizer().getLineTokens(line, state);

1509

<+=?|> var tokens = tokenizedLine.tokens;

1510

<+=?|> var endState = tokenizedLine.state;

1511

1512

<+=?|> if (tokens.length && tokens[tokens.length-1].type == "comment") {

1513

<+=?|> return indent;

1514

<+=?|> }

1515

1516

<+=?|> if (state == "start" || state == "no_regex") {

1517

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

1518

<+=?|> if (match) {

1519

<+=?|> indent += tab;

1520

<+=?|> }

1521

<+=?|> } else if (state == "doc-start") {

1522

<+=?|> if (endState == "start" || endState == "no_regex") {

1523

<+=?|> return "";

1524

<+=?|> }

1525

<+=?|> var match = line.match(/^\s*(\/?)\*/);

1526

<+=?|> if (match) {

1527

<+=?|> if (match[1]) {

1528

<+=?|> indent += " ";

1529

<+=?|> }

1530

<+=?|> indent += "* ";

<+=?|> }

<+=?|> }

<+=?|> return indent;

1535

<+=?|> };

1536

1537

<+=?|> this.checkOutdent = function(state, line, input) {

1538

<+=?|> return this.$outdent.checkOutdent(line, input);

1539

<+=?|> };

1540

1541

<+=?|> this.autoOutdent = function(state, doc, row) {

1542

<+=?|> this.$outdent.autoOutdent(doc, row);

1543

<+=?|> };

1544

1545

<+=?|> this.createWorker = function(session) {

1546

<+=?|> var worker = new WorkerClient(["ace"], "ace/mode/javascript_worker", "JavaScriptWorker");

1547

<+=?|> worker.attachToDocument(session.getDocument());

1548

1549

<+=?|> worker.on("annotate", function(results) {

1550

<+=?|> session.setAnnotations(results.data);

1551

<+=?|> });

1552

1553

<+=?|> worker.on("terminate", function() {

1554

<+=?|> session.clearAnnotations();

1555

<+=?|> });

1556

1557

<+=?|> return worker;

1558

<+=?|> };

1559

1560

<+=?|> this.$id = "ace/mode/javascript";

1561

<+=?|>}).call(Mode.prototype);

1562

1563

<+=?|>exports.Mode = Mode;

1564

<+=?|>});

1565

1566

<+=?|>ace.define("ace/mode/css_completions",["require","exports","module"], function(require, exports, module) {

1567

<+=?|>"use strict";

1568

1569

<+=?|>var propertyMap = {

1570

<+=?|> "background": {"#$0": 1},

1571

<+=?|> "background-color": {"#$0": 1, "transparent": 1, "fixed": 1},

1572

<+=?|> "background-image": {"url('/$0')": 1},

1573

<+=?|> "background-repeat": {"repeat": 1, "repeat-x": 1, "repeat-y": 1, "no-repeat": 1, "inherit": 1},

1574

<+=?|> "background-position": {"bottom":2, "center":2, "left":2, "right":2, "top":2, "inherit":2},

1575

<+=?|> "background-attachment": {"scroll": 1, "fixed": 1},

1576

<+=?|> "background-size": {"cover": 1, "contain": 1},

1577

<+=?|> "background-clip": {"border-box": 1, "padding-box": 1, "content-box": 1},

1578

<+=?|> "background-origin": {"border-box": 1, "padding-box": 1, "content-box": 1},

1579

<+=?|> "border": {"solid $0": 1, "dashed $0": 1, "dotted $0": 1, "#$0": 1},

1580

<+=?|> "border-color": {"#$0": 1},

1581

<+=?|>    "border-style": {"solid":2, "dashed":2, "dotted":2, "double":2, "groove":2, "hidden":2, "inherit":2, "inset":2, "none":2, "outset":2, "ridged":2},

1582

<+=?|> "border-collapse": {"collapse": 1, "separate": 1},

1583

<+=?|> "bottom": {"px": 1, "em": 1, "%": 1},

1584

<+=?|> "clear": {"left": 1, "right": 1, "both": 1, "none": 1},

1585

<+=?|> "color": {"#$0": 1, "rgb(#$00,0,0)": 1},

1586

<+=?|>    "cursor": {"default": 1, "pointer": 1, "move": 1, "text": 1, "wait": 1, "help": 1, "progress": 1, "n-resize": 1, "ne-resize": 1, "e-resize": 1, "se-resize": 1, "s-resize": 1, "sw-resize": 1, "w-resize": 1, "nw-resize": 1},

1587

<+=?|> "display": {"none": 1, "block": 1, "inline": 1, "inline-block": 1, "table-cell": 1},

1588

<+=?|> "empty-cells": {"show": 1, "hide": 1},

1589

<+=?|> "float": {"left": 1, "right": 1, "none": 1},

1590

<+=?|>    "font-family": {"Arial":2,"Comic Sans MS":2,"Consolas":2,"Courier New":2,"Courier":2,"Georgia":2,"Monospace":2,"Sans-Serif":2, "Segoe UI":2,"Tahoma":2,"Times New Roman":2,"Trebuchet MS":2,"Verdana": 1},

1591

<+=?|> "font-size": {"px": 1, "em": 1, "%": 1},

1592

<+=?|> "font-weight": {"bold": 1, "normal": 1},

1593

<+=?|> "font-style": {"italic": 1, "normal": 1},

1594

<+=?|> "font-variant": {"normal": 1, "small-caps": 1},

1595

<+=?|> "height": {"px": 1, "em": 1, "%": 1},

1596

<+=?|> "left": {"px": 1, "em": 1, "%": 1},

1597

<+=?|> "letter-spacing": {"normal": 1},

1598

<+=?|> "line-height": {"normal": 1},

1599

<+=?|>    "list-style-type": {"none": 1, "disc": 1, "circle": 1, "square": 1, "decimal": 1, "decimal-leading-zero": 1, "lower-roman": 1, "upper-roman": 1, "lower-greek": 1, "lower-latin": 1, "upper-latin": 1, "georgian": 1, "lower-alpha": 1, "upper-alpha": 1},

1600

<+=?|> "margin": {"px": 1, "em": 1, "%": 1},

1601

<+=?|> "margin-right": {"px": 1, "em": 1, "%": 1},

1602

<+=?|> "margin-left": {"px": 1, "em": 1, "%": 1},

1603

<+=?|> "margin-top": {"px": 1, "em": 1, "%": 1},

1604

<+=?|> "margin-bottom": {"px": 1, "em": 1, "%": 1},

1605

<+=?|> "max-height": {"px": 1, "em": 1, "%": 1},

1606

<+=?|> "max-width": {"px": 1, "em": 1, "%": 1},

1607

<+=?|> "min-height": {"px": 1, "em": 1, "%": 1},

1608

<+=?|> "min-width": {"px": 1, "em": 1, "%": 1},

1609

<+=?|> "overflow": {"hidden": 1, "visible": 1, "auto": 1, "scroll": 1},

1610

<+=?|> "overflow-x": {"hidden": 1, "visible": 1, "auto": 1, "scroll": 1},

1611

<+=?|> "overflow-y": {"hidden": 1, "visible": 1, "auto": 1, "scroll": 1},

1612

<+=?|> "padding": {"px": 1, "em": 1, "%": 1},

1613

<+=?|> "padding-top": {"px": 1, "em": 1, "%": 1},

1614

<+=?|> "padding-right": {"px": 1, "em": 1, "%": 1},

1615

<+=?|> "padding-bottom": {"px": 1, "em": 1, "%": 1},

1616

<+=?|> "padding-left": {"px": 1, "em": 1, "%": 1},

1617

<+=?|> "page-break-after": {"auto": 1, "always": 1, "avoid": 1, "left": 1, "right": 1},

1618

<+=?|> "page-break-before": {"auto": 1, "always": 1, "avoid": 1, "left": 1, "right": 1},

1619

<+=?|> "position": {"absolute": 1, "relative": 1, "fixed": 1, "static": 1},

1620

<+=?|> "right": {"px": 1, "em": 1, "%": 1},

1621

<+=?|> "table-layout": {"fixed": 1, "auto": 1},

1622

<+=?|> "text-decoration": {"none": 1, "underline": 1, "line-through": 1, "blink": 1},

1623

<+=?|> "text-align": {"left": 1, "right": 1, "center": 1, "justify": 1},

1624

<+=?|> "text-transform": {"capitalize": 1, "uppercase": 1, "lowercase": 1, "none": 1},

1625

<+=?|> "top": {"px": 1, "em": 1, "%": 1},

1626

<+=?|> "vertical-align": {"top": 1, "bottom": 1},

1627

<+=?|> "visibility": {"hidden": 1, "visible": 1},

1628

<+=?|> "white-space": {"nowrap": 1, "normal": 1, "pre": 1, "pre-line": 1, "pre-wrap": 1},

1629

<+=?|> "width": {"px": 1, "em": 1, "%": 1},

1630

<+=?|> "word-spacing": {"normal": 1},

1631

<+=?|> "filter": {"alpha(opacity=$0100)": 1},

1632

1633

<+=?|> "text-shadow": {"$02px 2px 2px #777": 1},

1634

<+=?|> "text-overflow": {"ellipsis-word": 1, "clip": 1, "ellipsis": 1},

1635

<+=?|> "-moz-border-radius": 1,

1636

<+=?|> "-moz-border-radius-topright": 1,

1637

<+=?|> "-moz-border-radius-bottomright": 1,

1638

<+=?|> "-moz-border-radius-topleft": 1,

1639

<+=?|> "-moz-border-radius-bottomleft": 1,

1640

<+=?|> "-webkit-border-radius": 1,

1641

<+=?|> "-webkit-border-top-right-radius": 1,

1642

<+=?|> "-webkit-border-top-left-radius": 1,

1643

<+=?|> "-webkit-border-bottom-right-radius": 1,

1644

<+=?|> "-webkit-border-bottom-left-radius": 1,

1645

<+=?|> "-moz-box-shadow": 1,

1646

<+=?|> "-webkit-box-shadow": 1,

1647

<+=?|> "transform": {"rotate($00deg)": 1, "skew($00deg)": 1},

1648

<+=?|> "-moz-transform": {"rotate($00deg)": 1, "skew($00deg)": 1},

1649

<+=?|> "-webkit-transform": {"rotate($00deg)": 1, "skew($00deg)": 1 }

1650

<+=?|>};

1651

1652

<+=?|>var CssCompletions = function() {

<+=?|>};

<+=?|>(function() {

1657

1658

<+=?|> this.completionsDefined = false;

1659

1660

<+=?|> this.defineCompletions = function() {

1661

<+=?|> if (document) {

1662

<+=?|> var style = document.createElement('c').style;

1663

1664

<+=?|> for (var i in style) {

1665

<+=?|> if (typeof style[i] !== 'string')

1666

<+=?|> continue;

1667

1668

<+=?|> var name = i.replace(/[A-Z]/g, function(x) {

1669

<+=?|> return '-' + x.toLowerCase();

1670

<+=?|> });

1671

1672

<+=?|> if (!propertyMap.hasOwnProperty(name))

1673

<+=?|> propertyMap[name] = 1;

<+=?|> }

<+=?|> }

<+=?|> this.completionsDefined = true;

1678

<+=?|> }

1679

1680

<+=?|> this.getCompletions = function(state, session, pos, prefix) {

1681

<+=?|> if (!this.completionsDefined) {

1682

<+=?|> this.defineCompletions();

1683

<+=?|> }

1684

1685

<+=?|> var token = session.getTokenAt(pos.row, pos.column);

<+=?|> if (!token)

<+=?|> return [];

<+=?|> if (state==='ruleset'){

1690

<+=?|> var line = session.getLine(pos.row).substr(0, pos.column);

1691

<+=?|> if (/:[^;]+$/.test(line)) {

1692

<+=?|> /([\w\-]+):[^:]*$/.test(line);

1693

1694

<+=?|> return this.getPropertyValueCompletions(state, session, pos, prefix);

1695

<+=?|> } else {

1696

<+=?|> return this.getPropertyCompletions(state, session, pos, prefix);

<+=?|> }

<+=?|> }

<+=?|> return [];

<+=?|> };

<+=?|> this.getPropertyCompletions = function(state, session, pos, prefix) {

1704

<+=?|> var properties = Object.keys(propertyMap);

1705

<+=?|> return properties.map(function(property){

1706

<+=?|> return {

1707

<+=?|> caption: property,

1708

<+=?|> snippet: property + ': $0',

1709

<+=?|> meta: "property",

1710

<+=?|> score: Number.MAX_VALUE

<+=?|> };

<+=?|> });

<+=?|> };

<+=?|> this.getPropertyValueCompletions = function(state, session, pos, prefix) {

1716

<+=?|> var line = session.getLine(pos.row).substr(0, pos.column);

1717

<+=?|> var property = (/([\w\-]+):[^:]*$/.exec(line) || {})[1];

1718

1719

<+=?|> if (!property)

1720

<+=?|> return [];

1721

<+=?|> var values = [];

1722

<+=?|> if (property in propertyMap && typeof propertyMap[property] === "object") {

1723

<+=?|> values = Object.keys(propertyMap[property]);

1724

<+=?|> }

1725

<+=?|> return values.map(function(value){

1726

<+=?|> return {

1727

<+=?|> caption: value,

1728

<+=?|> snippet: value,

1729

<+=?|> meta: "property value",

1730

<+=?|> score: Number.MAX_VALUE

<+=?|> };

<+=?|> });

<+=?|> };

<+=?|>}).call(CssCompletions.prototype);

1736

1737

<+=?|>exports.CssCompletions = CssCompletions;

1738

<+=?|>});

1739

1740

<+=?|>ace.define("ace/mode/behaviour/css",["require","exports","module","ace/lib/oop","ace/mode/behaviour","ace/mode/behaviour/cstyle","ace/token_iterator"], function(require, exports, module) {

1741

<+=?|>"use strict";

1742

1743

<+=?|>var oop = require("../../lib/oop");

1744

<+=?|>var Behaviour = require("../behaviour").Behaviour;

1745

<+=?|>var CstyleBehaviour = require("./cstyle").CstyleBehaviour;

1746

<+=?|>var TokenIterator = require("../../token_iterator").TokenIterator;

1747

1748

<+=?|>var CssBehaviour = function () {

1749

1750

<+=?|> this.inherit(CstyleBehaviour);

1751

1752

<+=?|> this.add("colon", "insertion", function (state, action, editor, session, text) {

1753

<+=?|> if (text === ':') {

1754

<+=?|> var cursor = editor.getCursorPosition();

1755

<+=?|> var iterator = new TokenIterator(session, cursor.row, cursor.column);

1756

<+=?|> var token = iterator.getCurrentToken();

1757

<+=?|> if (token && token.value.match(/\s+/)) {

1758

<+=?|> token = iterator.stepBackward();

1759

<+=?|> }

1760

<+=?|> if (token && token.type === 'support.type') {

1761

<+=?|> var line = session.doc.getLine(cursor.row);

1762

<+=?|> var rightChar = line.substring(cursor.column, cursor.column + 1);

1763

<+=?|> if (rightChar === ':') {

1764

<+=?|> return {

1765

<+=?|> text: '',

1766

<+=?|> selection: [1, 1]

1767

<+=?|> }

1768

<+=?|> }

1769

<+=?|> if (!line.substring(cursor.column).match(/^\s*;/)) {

1770

<+=?|> return {

1771

<+=?|> text: ':;',

1772

<+=?|> selection: [1, 1]

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> });

<+=?|> this.add("colon", "deletion", function (state, action, editor, session, range) {

1780

<+=?|> var selected = session.doc.getTextRange(range);

1781

<+=?|> if (!range.isMultiLine() && selected === ':') {

1782

<+=?|> var cursor = editor.getCursorPosition();

1783

<+=?|> var iterator = new TokenIterator(session, cursor.row, cursor.column);

1784

<+=?|> var token = iterator.getCurrentToken();

1785

<+=?|> if (token && token.value.match(/\s+/)) {

1786

<+=?|> token = iterator.stepBackward();

1787

<+=?|> }

1788

<+=?|> if (token && token.type === 'support.type') {

1789

<+=?|> var line = session.doc.getLine(range.start.row);

1790

<+=?|> var rightChar = line.substring(range.end.column, range.end.column + 1);

1791

<+=?|> if (rightChar === ';') {

1792

<+=?|> range.end.column ++;

1793

<+=?|> return range;

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> });

<+=?|> this.add("semicolon", "insertion", function (state, action, editor, session, text) {

1800

<+=?|> if (text === ';') {

1801

<+=?|> var cursor = editor.getCursorPosition();

1802

<+=?|> var line = session.doc.getLine(cursor.row);

1803

<+=?|> var rightChar = line.substring(cursor.column, cursor.column + 1);

1804

<+=?|> if (rightChar === ';') {

1805

<+=?|> return {

1806

<+=?|> text: '',

1807

<+=?|> selection: [1, 1]

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> });

<+=?|>}

<+=?|>oop.inherits(CssBehaviour, CstyleBehaviour);

1815

1816

<+=?|>exports.CssBehaviour = CssBehaviour;

1817

<+=?|>});

1818

1819

<+=?|>ace.define("ace/mode/css",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/css_highlight_rules","ace/mode/matching_brace_outdent","ace/worker/worker_client","ace/mode/css_completions","ace/mode/behaviour/css","ace/mode/folding/cstyle"], function(require, exports, module) {

1820

<+=?|>"use strict";

1821

1822

<+=?|>var oop = require("../lib/oop");

1823

<+=?|>var TextMode = require("./text").Mode;

1824

<+=?|>var CssHighlightRules = require("./css_highlight_rules").CssHighlightRules;

1825

<+=?|>var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;

1826

<+=?|>var WorkerClient = require("../worker/worker_client").WorkerClient;

1827

<+=?|>var CssCompletions = require("./css_completions").CssCompletions;

1828

<+=?|>var CssBehaviour = require("./behaviour/css").CssBehaviour;

1829

<+=?|>var CStyleFoldMode = require("./folding/cstyle").FoldMode;

1830

1831

<+=?|>var Mode = function() {

1832

<+=?|> this.HighlightRules = CssHighlightRules;

1833

<+=?|> this.$outdent = new MatchingBraceOutdent();

1834

<+=?|> this.$behaviour = new CssBehaviour();

1835

<+=?|> this.$completer = new CssCompletions();

1836

<+=?|> this.foldingRules = new CStyleFoldMode();

1837

<+=?|>};

1838

<+=?|>oop.inherits(Mode, TextMode);

1839

1840

<+=?|>(function() {

1841

1842

<+=?|> this.foldingRules = "cStyle";

1843

<+=?|> this.blockComment = {start: "/*", end: "*/"};

1844

1845

<+=?|> this.getNextLineIndent = function(state, line, tab) {

1846

<+=?|> var indent = this.$getIndent(line);

1847

<+=?|> var tokens = this.getTokenizer().getLineTokens(line, state).tokens;

1848

<+=?|> if (tokens.length && tokens[tokens.length-1].type == "comment") {

1849

<+=?|> return indent;

1850

<+=?|> }

1851

1852

<+=?|> var match = line.match(/^.*\{\s*$/);

1853

<+=?|> if (match) {

1854

<+=?|> indent += tab;

1855

<+=?|> }

1856

1857

<+=?|> return indent;

1858

<+=?|> };

1859

1860

<+=?|> this.checkOutdent = function(state, line, input) {

1861

<+=?|> return this.$outdent.checkOutdent(line, input);

1862

<+=?|> };

1863

1864

<+=?|> this.autoOutdent = function(state, doc, row) {

1865

<+=?|> this.$outdent.autoOutdent(doc, row);

1866

<+=?|> };

1867

1868

<+=?|> this.getCompletions = function(state, session, pos, prefix) {

1869

<+=?|> return this.$completer.getCompletions(state, session, pos, prefix);

1870

<+=?|> };

1871

1872

<+=?|> this.createWorker = function(session) {

1873

<+=?|> var worker = new WorkerClient(["ace"], "ace/mode/css_worker", "Worker");

1874

<+=?|> worker.attachToDocument(session.getDocument());

1875

1876

<+=?|> worker.on("annotate", function(e) {

1877

<+=?|> session.setAnnotations(e.data);

1878

<+=?|> });

1879

1880

<+=?|> worker.on("terminate", function() {

1881

<+=?|> session.clearAnnotations();

1882

<+=?|> });

1883

1884

<+=?|> return worker;

1885

<+=?|> };

1886

1887

<+=?|> this.$id = "ace/mode/css";

1888

<+=?|>}).call(Mode.prototype);

1889

1890

<+=?|>exports.Mode = Mode;

<+=?|>});

<+=?|>ace.define("ace/mode/behaviour/xml",["require","exports","module","ace/lib/oop","ace/mode/behaviour","ace/token_iterator","ace/lib/lang"], function(require, exports, module) {

1895

<+=?|>"use strict";

1896

1897

<+=?|>var oop = require("../../lib/oop");

1898

<+=?|>var Behaviour = require("../behaviour").Behaviour;

1899

<+=?|>var TokenIterator = require("../../token_iterator").TokenIterator;

1900

<+=?|>var lang = require("../../lib/lang");

1901

1902

<+=?|>function is(token, type) {

1903

<+=?|> return token.type.lastIndexOf(type + ".xml") > -1;

1904

<+=?|>}

1905

1906

<+=?|>var XmlBehaviour = function () {

1907

1908

<+=?|> this.add("string_dquotes", "insertion", function (state, action, editor, session, text) {

1909

<+=?|> if (text == '"' || text == "'") {

1910

<+=?|> var quote = text;

1911

<+=?|> var selected = session.doc.getTextRange(editor.getSelectionRange());

1912

<+=?|> if (selected !== "" && selected !== "'" && selected != '"' && editor.getWrapBehavioursEnabled()) {

1913

<+=?|> return {

1914

<+=?|> text: quote + selected + quote,

1915

<+=?|> selection: false

<+=?|> };

<+=?|> }

<+=?|> var cursor = editor.getCursorPosition();

1920

<+=?|> var line = session.doc.getLine(cursor.row);

1921

<+=?|> var rightChar = line.substring(cursor.column, cursor.column + 1);

1922

<+=?|> var iterator = new TokenIterator(session, cursor.row, cursor.column);

1923

<+=?|> var token = iterator.getCurrentToken();

1924

1925

<+=?|> if (rightChar == quote && (is(token, "attribute-value") || is(token, "string"))) {

1926

<+=?|> return {

1927

<+=?|> text: "",

1928

<+=?|> selection: [1, 1]

<+=?|> };

<+=?|> }

<+=?|> if (!token)

<+=?|> token = iterator.stepBackward();

<+=?|> if (!token)

<+=?|> return;

<+=?|> while (is(token, "tag-whitespace") || is(token, "whitespace")) {

1939

<+=?|> token = iterator.stepBackward();

1940

<+=?|> }

1941

<+=?|> var rightSpace = !rightChar || rightChar.match(/\s/);

1942

<+=?|>            if (is(token, "attribute-equals") && (rightSpace || rightChar == '>') || (is(token, "decl-attribute-equals") && (rightSpace || rightChar == '?'))) {

1943

<+=?|> return {

1944

<+=?|> text: quote + quote,

1945

<+=?|> selection: [1, 1]

<+=?|> };

<+=?|> }

<+=?|> }

<+=?|> });

<+=?|> this.add("string_dquotes", "deletion", function(state, action, editor, session, range) {

1952

<+=?|> var selected = session.doc.getTextRange(range);

1953

<+=?|> if (!range.isMultiLine() && (selected == '"' || selected == "'")) {

1954

<+=?|> var line = session.doc.getLine(range.start.row);

1955

<+=?|> var rightChar = line.substring(range.start.column + 1, range.start.column + 2);

1956

<+=?|> if (rightChar == selected) {

1957

<+=?|> range.end.column++;

1958

<+=?|> return range;

<+=?|> }

<+=?|> }

<+=?|> });

<+=?|> this.add("autoclosing", "insertion", function (state, action, editor, session, text) {

1964

<+=?|> if (text == '>') {

1965

<+=?|> var position = editor.getSelectionRange().start;

1966

<+=?|> var iterator = new TokenIterator(session, position.row, position.column);

1967

<+=?|> var token = iterator.getCurrentToken() || iterator.stepBackward();

1968

<+=?|>            if (!token || !(is(token, "tag-name") || is(token, "tag-whitespace") || is(token, "attribute-name") || is(token, "attribute-equals") || is(token, "attribute-value")))

1969

<+=?|> return;

1970

<+=?|> if (is(token, "reference.attribute-value"))

1971

<+=?|> return;

1972

<+=?|> if (is(token, "attribute-value")) {

1973

<+=?|> var firstChar = token.value.charAt(0);

1974

<+=?|> if (firstChar == '"' || firstChar == "'") {

1975

<+=?|> var lastChar = token.value.charAt(token.value.length - 1);

1976

<+=?|> var tokenEnd = iterator.getCurrentTokenColumn() + token.value.length;

1977

<+=?|> if (tokenEnd > position.column || tokenEnd == position.column && firstChar != lastChar)

<+=?|> return;

<+=?|> }

<+=?|> }

<+=?|> while (!is(token, "tag-name")) {

1982

<+=?|> token = iterator.stepBackward();

1983

<+=?|> if (token.value == "<") {

1984

<+=?|> token = iterator.stepForward();

<+=?|> break;

<+=?|> }

<+=?|> }

<+=?|> var tokenRow = iterator.getCurrentTokenRow();

1990

<+=?|> var tokenColumn = iterator.getCurrentTokenColumn();

1991

<+=?|> if (is(iterator.stepBackward(), "end-tag-open"))

1992

<+=?|> return;

1993

1994

<+=?|> var element = token.value;

1995

<+=?|> if (tokenRow == position.row)

1996

<+=?|> element = element.substring(0, position.column - tokenColumn);

1997

1998

<+=?|> if (this.voidElements.hasOwnProperty(element.toLowerCase()))

<+=?|> return;

<+=?|> return {

<+=?|> text: ">" + "</" + element + ">",

2003

<+=?|> selection: [1, 1]

<+=?|> };

<+=?|> }

<+=?|> });

<+=?|> this.add("autoindent", "insertion", function (state, action, editor, session, text) {

2009

<+=?|> if (text == "\n") {

2010

<+=?|> var cursor = editor.getCursorPosition();

2011

<+=?|> var line = session.getLine(cursor.row);

2012

<+=?|> var iterator = new TokenIterator(session, cursor.row, cursor.column);

2013

<+=?|> var token = iterator.getCurrentToken();

2014

2015

<+=?|> if (token && token.type.indexOf("tag-close") !== -1) {

2016

<+=?|> if (token.value == "/>")

2017

<+=?|> return;

2018

<+=?|> while (token && token.type.indexOf("tag-name") === -1) {

2019

<+=?|> token = iterator.stepBackward();

2020

<+=?|> }

2021

2022

<+=?|> if (!token) {

<+=?|> return;

<+=?|> }

<+=?|> var tag = token.value;

2027

<+=?|> var row = iterator.getCurrentTokenRow();

2028

<+=?|> token = iterator.stepBackward();

2029

<+=?|> if (!token || token.type.indexOf("end-tag") !== -1) {

<+=?|> return;

<+=?|> }

<+=?|> if (this.voidElements && !this.voidElements[tag]) {

2034

<+=?|> var nextToken = session.getTokenAt(cursor.row, cursor.column+1);

2035

<+=?|> var line = session.getLine(row);

2036

<+=?|> var nextIndent = this.$getIndent(line);

2037

<+=?|> var indent = nextIndent + session.getTabString();

2038

2039

<+=?|> if (nextToken && nextToken.value === "</") {

2040

<+=?|> return {

2041

<+=?|> text: "\n" + indent + "\n" + nextIndent,

2042

<+=?|> selection: [1, indent.length, 1, indent.length]

<+=?|> };

<+=?|> } else {

<+=?|> return {

<+=?|> text: "\n" + indent

<+=?|> };

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> });

<+=?|>};

<+=?|>oop.inherits(XmlBehaviour, Behaviour);

2057

2058

<+=?|>exports.XmlBehaviour = XmlBehaviour;

2059

<+=?|>});

2060

2061

<+=?|>ace.define("ace/mode/folding/mixed",["require","exports","module","ace/lib/oop","ace/mode/folding/fold_mode"], function(require, exports, module) {

2062

<+=?|>"use strict";

2063

2064

<+=?|>var oop = require("../../lib/oop");

2065

<+=?|>var BaseFoldMode = require("./fold_mode").FoldMode;

2066

2067

<+=?|>var FoldMode = exports.FoldMode = function(defaultMode, subModes) {

2068

<+=?|> this.defaultMode = defaultMode;

2069

<+=?|> this.subModes = subModes;

2070

<+=?|>};

2071

<+=?|>oop.inherits(FoldMode, BaseFoldMode);

2072

2073

<+=?|>(function() {

2074

2075

2076

<+=?|> this.$getMode = function(state) {

2077

<+=?|> if (typeof state != "string")

2078

<+=?|> state = state[0];

2079

<+=?|> for (var key in this.subModes) {

2080

<+=?|> if (state.indexOf(key) === 0)

2081

<+=?|> return this.subModes[key];

2082

<+=?|> }

2083

<+=?|> return null;

2084

<+=?|> };

2085

2086

<+=?|> this.$tryMode = function(state, session, foldStyle, row) {

2087

<+=?|> var mode = this.$getMode(state);

2088

<+=?|> return (mode ? mode.getFoldWidget(session, foldStyle, row) : "");

2089

<+=?|> };

2090

2091

<+=?|> this.getFoldWidget = function(session, foldStyle, row) {

2092

<+=?|> return (

2093

<+=?|> this.$tryMode(session.getState(row-1), session, foldStyle, row) ||

2094

<+=?|> this.$tryMode(session.getState(row), session, foldStyle, row) ||

2095

<+=?|> this.defaultMode.getFoldWidget(session, foldStyle, row)

<+=?|> );

<+=?|> };

<+=?|> this.getFoldWidgetRange = function(session, foldStyle, row) {

2100

<+=?|> var mode = this.$getMode(session.getState(row-1));

2101

2102

<+=?|> if (!mode || !mode.getFoldWidget(session, foldStyle, row))

2103

<+=?|> mode = this.$getMode(session.getState(row));

2104

2105

<+=?|> if (!mode || !mode.getFoldWidget(session, foldStyle, row))

2106

<+=?|> mode = this.defaultMode;

2107

2108

<+=?|> return mode.getFoldWidgetRange(session, foldStyle, row);

2109

<+=?|> };

2110

2111

<+=?|>}).call(FoldMode.prototype);

<+=?|>});

<+=?|>ace.define("ace/mode/folding/xml",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/range","ace/mode/folding/fold_mode","ace/token_iterator"], function(require, exports, module) {

2116

<+=?|>"use strict";

2117

2118

<+=?|>var oop = require("../../lib/oop");

2119

<+=?|>var lang = require("../../lib/lang");

2120

<+=?|>var Range = require("../../range").Range;

2121

<+=?|>var BaseFoldMode = require("./fold_mode").FoldMode;

2122

<+=?|>var TokenIterator = require("../../token_iterator").TokenIterator;

2123

2124

<+=?|>var FoldMode = exports.FoldMode = function(voidElements, optionalEndTags) {

2125

<+=?|> BaseFoldMode.call(this);

2126

<+=?|> this.voidElements = voidElements || {};

2127

<+=?|> this.optionalEndTags = oop.mixin({}, this.voidElements);

2128

<+=?|> if (optionalEndTags)

2129

<+=?|> oop.mixin(this.optionalEndTags, optionalEndTags);

2130

2131

<+=?|>};

2132

<+=?|>oop.inherits(FoldMode, BaseFoldMode);

2133

2134

<+=?|>var Tag = function() {

2135

<+=?|> this.tagName = "";

2136

<+=?|> this.closing = false;

2137

<+=?|> this.selfClosing = false;

2138

<+=?|> this.start = {row: 0, column: 0};

2139

<+=?|> this.end = {row: 0, column: 0};

2140

<+=?|>};

2141

2142

<+=?|>function is(token, type) {

2143

<+=?|> return token.type.lastIndexOf(type + ".xml") > -1;

2144

<+=?|>}

2145

2146

<+=?|>(function() {

2147

2148

<+=?|> this.getFoldWidget = function(session, foldStyle, row) {

2149

<+=?|> var tag = this._getFirstTagInLine(session, row);

<+=?|> if (!tag)

<+=?|> return "";

<+=?|> if (tag.closing || (!tag.tagName && tag.selfClosing))

2155

<+=?|> return foldStyle == "markbeginend" ? "end" : "";

2156

2157

<+=?|> if (!tag.tagName || tag.selfClosing || this.voidElements.hasOwnProperty(tag.tagName.toLowerCase()))

2158

<+=?|> return "";

2159

2160

<+=?|> if (this._findEndTagInLine(session, row, tag.tagName, tag.end.column))

2161

<+=?|> return "";

2162

2163

<+=?|> return "start";

2164

<+=?|> };

2165

<+=?|> this._getFirstTagInLine = function(session, row) {

2166

<+=?|> var tokens = session.getTokens(row);

2167

<+=?|> var tag = new Tag();

2168

2169

<+=?|> for (var i = 0; i < tokens.length; i++) {

2170

<+=?|> var token = tokens[i];

2171

<+=?|> if (is(token, "tag-open")) {

2172

<+=?|> tag.end.column = tag.start.column + token.value.length;

2173

<+=?|> tag.closing = is(token, "end-tag-open");

2174

<+=?|> token = tokens[++i];

2175

<+=?|> if (!token)

2176

<+=?|> return null;

2177

<+=?|> tag.tagName = token.value;

2178

<+=?|> tag.end.column += token.value.length;

2179

<+=?|> for (i++; i < tokens.length; i++) {

2180

<+=?|> token = tokens[i];

2181

<+=?|> tag.end.column += token.value.length;

2182

<+=?|> if (is(token, "tag-close")) {

2183

<+=?|> tag.selfClosing = token.value == '/>';

<+=?|> break;

<+=?|> }

<+=?|> }

<+=?|> return tag;

<+=?|> } else if (is(token, "tag-close")) {

2189

<+=?|> tag.selfClosing = token.value == '/>';

2190

<+=?|> return tag;

2191

<+=?|> }

2192

<+=?|> tag.start.column += token.value.length;

2193

<+=?|> }

2194

2195

<+=?|> return null;

2196

<+=?|> };

2197

2198

<+=?|> this._findEndTagInLine = function(session, row, tagName, startColumn) {

2199

<+=?|> var tokens = session.getTokens(row);

2200

<+=?|> var column = 0;

2201

<+=?|> for (var i = 0; i < tokens.length; i++) {

2202

<+=?|> var token = tokens[i];

2203

<+=?|> column += token.value.length;

2204

<+=?|> if (column < startColumn)

2205

<+=?|> continue;

2206

<+=?|> if (is(token, "end-tag-open")) {

2207

<+=?|> token = tokens[i + 1];

2208

<+=?|> if (token && token.value == tagName)

2209

<+=?|> return true;

2210

<+=?|> }

2211

<+=?|> }

2212

<+=?|> return false;

2213

<+=?|> };

2214

<+=?|> this._readTagForward = function(iterator) {

2215

<+=?|> var token = iterator.getCurrentToken();

2216

<+=?|> if (!token)

2217

<+=?|> return null;

2218

2219

<+=?|> var tag = new Tag();

2220

<+=?|> do {

2221

<+=?|> if (is(token, "tag-open")) {

2222

<+=?|> tag.closing = is(token, "end-tag-open");

2223

<+=?|> tag.start.row = iterator.getCurrentTokenRow();

2224

<+=?|> tag.start.column = iterator.getCurrentTokenColumn();

2225

<+=?|> } else if (is(token, "tag-name")) {

2226

<+=?|> tag.tagName = token.value;

2227

<+=?|> } else if (is(token, "tag-close")) {

2228

<+=?|> tag.selfClosing = token.value == "/>";

2229

<+=?|> tag.end.row = iterator.getCurrentTokenRow();

2230

<+=?|> tag.end.column = iterator.getCurrentTokenColumn() + token.value.length;

2231

<+=?|> iterator.stepForward();

2232

<+=?|> return tag;

2233

<+=?|> }

2234

<+=?|> } while(token = iterator.stepForward());

2235

2236

<+=?|> return null;

2237

<+=?|> };

2238

2239

<+=?|> this._readTagBackward = function(iterator) {

2240

<+=?|> var token = iterator.getCurrentToken();

2241

<+=?|> if (!token)

2242

<+=?|> return null;

2243

2244

<+=?|> var tag = new Tag();

2245

<+=?|> do {

2246

<+=?|> if (is(token, "tag-open")) {

2247

<+=?|> tag.closing = is(token, "end-tag-open");

2248

<+=?|> tag.start.row = iterator.getCurrentTokenRow();

2249

<+=?|> tag.start.column = iterator.getCurrentTokenColumn();

2250

<+=?|> iterator.stepBackward();

2251

<+=?|> return tag;

2252

<+=?|> } else if (is(token, "tag-name")) {

2253

<+=?|> tag.tagName = token.value;

2254

<+=?|> } else if (is(token, "tag-close")) {

2255

<+=?|> tag.selfClosing = token.value == "/>";

2256

<+=?|> tag.end.row = iterator.getCurrentTokenRow();

2257

<+=?|> tag.end.column = iterator.getCurrentTokenColumn() + token.value.length;

2258

<+=?|> }

2259

<+=?|> } while(token = iterator.stepBackward());

2260

2261

<+=?|> return null;

2262

<+=?|> };

2263

2264

<+=?|> this._pop = function(stack, tag) {

2265

<+=?|> while (stack.length) {

2266

2267

<+=?|> var top = stack[stack.length-1];

2268

<+=?|> if (!tag || top.tagName == tag.tagName) {

2269

<+=?|> return stack.pop();

2270

<+=?|> }

2271

<+=?|> else if (this.optionalEndTags.hasOwnProperty(top.tagName)) {

2272

<+=?|> stack.pop();

2273

<+=?|> continue;

2274

<+=?|> } else {

2275

<+=?|> return null;

<+=?|> }

<+=?|> }

<+=?|> };

<+=?|> this.getFoldWidgetRange = function(session, foldStyle, row) {

2281

<+=?|> var firstTag = this._getFirstTagInLine(session, row);

2282

2283

<+=?|> if (!firstTag)

2284

<+=?|> return null;

2285

2286

<+=?|> var isBackward = firstTag.closing || firstTag.selfClosing;

2287

<+=?|> var stack = [];

2288

<+=?|> var tag;

2289

2290

<+=?|> if (!isBackward) {

2291

<+=?|> var iterator = new TokenIterator(session, row, firstTag.start.column);

2292

<+=?|> var start = {

2293

<+=?|> row: row,

2294

<+=?|> column: firstTag.start.column + firstTag.tagName.length + 2

2295

<+=?|> };

2296

<+=?|> if (firstTag.start.row == firstTag.end.row)

2297

<+=?|> start.column = firstTag.end.column;

2298

<+=?|> while (tag = this._readTagForward(iterator)) {

2299

<+=?|> if (tag.selfClosing) {

2300

<+=?|> if (!stack.length) {

2301

<+=?|> tag.start.column += tag.tagName.length + 2;

2302

<+=?|> tag.end.column -= 2;

2303

<+=?|> return Range.fromPoints(tag.start, tag.end);

<+=?|> } else

<+=?|> continue;

<+=?|> }

<+=?|> if (tag.closing) {

2309

<+=?|> this._pop(stack, tag);

2310

<+=?|> if (stack.length == 0)

2311

<+=?|> return Range.fromPoints(start, tag.start);

2312

<+=?|> }

2313

<+=?|> else {

2314

<+=?|> stack.push(tag);

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> else {

<+=?|> var iterator = new TokenIterator(session, row, firstTag.end.column);

2320

<+=?|> var end = {

2321

<+=?|> row: row,

2322

<+=?|> column: firstTag.start.column

2323

<+=?|> };

2324

2325

<+=?|> while (tag = this._readTagBackward(iterator)) {

2326

<+=?|> if (tag.selfClosing) {

2327

<+=?|> if (!stack.length) {

2328

<+=?|> tag.start.column += tag.tagName.length + 2;

2329

<+=?|> tag.end.column -= 2;

2330

<+=?|> return Range.fromPoints(tag.start, tag.end);

<+=?|> } else

<+=?|> continue;

<+=?|> }

<+=?|> if (!tag.closing) {

2336

<+=?|> this._pop(stack, tag);

2337

<+=?|> if (stack.length == 0) {

2338

<+=?|> tag.start.column += tag.tagName.length + 2;

2339

<+=?|> if (tag.start.row == tag.end.row && tag.start.column < tag.end.column)

2340

<+=?|> tag.start.column = tag.end.column;

2341

<+=?|> return Range.fromPoints(tag.start, end);

<+=?|> }

<+=?|> }

<+=?|> else {

<+=?|> stack.push(tag);

<+=?|> }

<+=?|> }

<+=?|> }

<+=?|> };

<+=?|>}).call(FoldMode.prototype);

<+=?|>});

<+=?|>ace.define("ace/mode/folding/html",["require","exports","module","ace/lib/oop","ace/mode/folding/mixed","ace/mode/folding/xml","ace/mode/folding/cstyle"], function(require, exports, module) {

2357

<+=?|>"use strict";

2358

2359

<+=?|>var oop = require("../../lib/oop");

2360

<+=?|>var MixedFoldMode = require("./mixed").FoldMode;

2361

<+=?|>var XmlFoldMode = require("./xml").FoldMode;

2362

<+=?|>var CStyleFoldMode = require("./cstyle").FoldMode;

2363

2364

<+=?|>var FoldMode = exports.FoldMode = function(voidElements, optionalTags) {

2365

<+=?|> MixedFoldMode.call(this, new XmlFoldMode(voidElements, optionalTags), {

2366

<+=?|> "js-": new CStyleFoldMode(),

2367

<+=?|> "css-": new CStyleFoldMode()

<+=?|> });

<+=?|>};

<+=?|>oop.inherits(FoldMode, MixedFoldMode);

<+=?|>});

<+=?|>ace.define("ace/mode/html_completions",["require","exports","module","ace/token_iterator"], function(require, exports, module) {

2376

<+=?|>"use strict";

2377

2378

<+=?|>var TokenIterator = require("../token_iterator").TokenIterator;

2379

2380

<+=?|>var commonAttributes = [

2381

<+=?|> "accesskey",

2382

<+=?|> "class",

2383

<+=?|> "contenteditable",

2384

<+=?|> "contextmenu",

2385

<+=?|> "dir",

2386

<+=?|> "draggable",

<+=?|> "dropzone",

<+=?|> "hidden",

<+=?|> "id",

<+=?|> "inert",

<+=?|> "itemid",

<+=?|> "itemprop",

<+=?|> "itemref",

<+=?|> "itemscope",

2395

<+=?|> "itemtype",

2396

<+=?|> "lang",

2397

<+=?|> "spellcheck",

<+=?|> "style",

<+=?|> "tabindex",

<+=?|> "title",

<+=?|> "translate"

<+=?|>];

<+=?|>var eventAttributes = [

<+=?|> "onabort",

<+=?|> "onblur",

<+=?|> "oncancel",

<+=?|> "oncanplay",

2409

<+=?|> "oncanplaythrough",

<+=?|> "onchange",

<+=?|> "onclick",

<+=?|> "onclose",

<+=?|> "oncontextmenu",

2414

<+=?|> "oncuechange",

2415

<+=?|> "ondblclick",

2416

<+=?|> "ondrag",

2417

<+=?|> "ondragend",

2418

<+=?|> "ondragenter",

2419

<+=?|> "ondragleave",

2420

<+=?|> "ondragover",

2421

<+=?|> "ondragstart",

2422

<+=?|> "ondrop",

2423

<+=?|> "ondurationchange",

2424

<+=?|> "onemptied",

<+=?|> "onended",

<+=?|> "onerror",

<+=?|> "onfocus",

<+=?|> "oninput",

<+=?|> "oninvalid",

2430

<+=?|> "onkeydown",

2431

<+=?|> "onkeypress",

2432

<+=?|> "onkeyup",

2433

<+=?|> "onload",

2434

<+=?|> "onloadeddata",

2435

<+=?|> "onloadedmetadata",

2436

<+=?|> "onloadstart",

2437

<+=?|> "onmousedown",

2438

<+=?|> "onmousemove",

2439

<+=?|> "onmouseout",

2440

<+=?|> "onmouseover",

2441

<+=?|> "onmouseup",

2442

<+=?|> "onmousewheel",

2443

<+=?|> "onpause",

2444

<+=?|> "onplay",

2445

<+=?|> "onplaying",

2446

<+=?|> "onprogress",

2447

<+=?|> "onratechange",

<+=?|> "onreset",

<+=?|> "onscroll",

<+=?|> "onseeked",

<+=?|> "onseeking",

2452

<+=?|> "onselect",

2453

<+=?|> "onshow",

2454

<+=?|> "onstalled",

2455

<+=?|> "onsubmit",

2456

<+=?|> "onsuspend",

2457

<+=?|> "ontimeupdate",

2458

<+=?|> "onvolumechange",

<+=?|> "onwaiting"

<+=?|>];

<+=?|>var globalAttributes = commonAttributes.concat(eventAttributes);

2463

2464

<+=?|>var attributeMap = {

2465

<+=?|> "html": {"manifest": 1},

2466

<+=?|> "head": {},

2467

<+=?|> "title": {},

2468

<+=?|> "base": {"href": 1, "target": 1},

2469

<+=?|>    "link": {"href": 1, "hreflang": 1, "rel": {"stylesheet": 1, "icon": 1}, "media": {"all": 1, "screen": 1, "print": 1}, "type": {"text/css": 1, "image/png": 1, "image/jpeg": 1, "image/gif": 1}, "sizes": 1},

2470

<+=?|>    "meta": {"http-equiv": {"content-type": 1}, "name": {"description": 1, "keywords": 1}, "content": {"text/html; charset=UTF-8": 1}, "charset": 1},

2471

<+=?|> "style": {"type": 1, "media": {"all": 1, "screen": 1, "print": 1}, "scoped": 1},

2472

<+=?|> "script": {"charset": 1, "type": {"text/javascript": 1}, "src": 1, "defer": 1, "async": 1},

2473

<+=?|> "noscript": {"href": 1},

2474

<+=?|>    "body": {"onafterprint": 1, "onbeforeprint": 1, "onbeforeunload": 1, "onhashchange": 1, "onmessage": 1, "onoffline": 1, "onpopstate": 1, "onredo": 1, "onresize": 1, "onstorage": 1, "onundo": 1, "onunload": 1},

2475

<+=?|> "section": {},

2476

<+=?|> "nav": {},

2477

<+=?|> "article": {"pubdate": 1},

2478

<+=?|> "aside": {},

<+=?|> "h1": {},

<+=?|> "h2": {},

<+=?|> "h3": {},

<+=?|> "h4": {},

<+=?|> "h5": {},

<+=?|> "h6": {},

<+=?|> "header": {},

2486

<+=?|> "footer": {},

2487

<+=?|> "address": {},

<+=?|> "main": {},

<+=?|> "p": {},

<+=?|> "hr": {},

<+=?|> "pre": {},

<+=?|> "blockquote": {"cite": 1},

2493

<+=?|> "ol": {"start": 1, "reversed": 1},

2494

<+=?|> "ul": {},

2495

<+=?|> "li": {"value": 1},

<+=?|> "dl": {},

<+=?|> "dt": {},

<+=?|> "dd": {},

<+=?|> "figure": {},

2500

<+=?|> "figcaption": {},

2501

<+=?|> "div": {},

2502

<+=?|>    "a": {"href": 1, "target": {"_blank": 1, "top": 1}, "ping": 1, "rel": {"nofollow": 1, "alternate": 1, "author": 1, "bookmark": 1, "help": 1, "license": 1, "next": 1, "noreferrer": 1, "prefetch": 1, "prev": 1, "search": 1, "tag": 1}, "media": 1, "hreflang": 1, "type": 1},

2503

<+=?|> "em": {},

2504

<+=?|> "strong": {},

2505

<+=?|> "small": {},

2506

<+=?|> "s": {},

2507

<+=?|> "cite": {},

2508

<+=?|> "q": {"cite": 1},

<+=?|> "dfn": {},

<+=?|> "abbr": {},

<+=?|> "data": {},

<+=?|> "time": {"datetime": 1},

<+=?|> "code": {},

<+=?|> "var": {},

<+=?|> "samp": {},

<+=?|> "kbd": {},

<+=?|> "sub": {},

<+=?|> "sup": {},

<+=?|> "i": {},

<+=?|> "b": {},

<+=?|> "u": {},

<+=?|> "mark": {},

<+=?|> "ruby": {},

<+=?|> "rt": {},

<+=?|> "rp": {},

<+=?|> "bdi": {},

<+=?|> "bdo": {},

<+=?|> "span": {},

<+=?|> "br": {},

<+=?|> "wbr": {},

<+=?|> "ins": {"cite": 1, "datetime": 1},

2532

<+=?|> "del": {"cite": 1, "datetime": 1},

2533

<+=?|> "img": {"alt": 1, "src": 1, "height": 1, "width": 1, "usemap": 1, "ismap": 1},

2534

<+=?|>    "iframe": {"name": 1, "src": 1, "height": 1, "width": 1, "sandbox": {"allow-same-origin": 1, "allow-top-navigation": 1, "allow-forms": 1, "allow-scripts": 1}, "seamless": {"seamless": 1}},

2535

<+=?|> "embed": {"src": 1, "height": 1, "width": 1, "type": 1},

2536

<+=?|>    "object": {"param": 1, "data": 1, "type": 1, "height" : 1, "width": 1, "usemap": 1, "name": 1, "form": 1, "classid": 1},

2537

<+=?|> "param": {"name": 1, "value": 1},

2538

<+=?|>    "video": {"src": 1, "autobuffer": 1, "autoplay": {"autoplay": 1}, "loop": {"loop": 1}, "controls": {"controls": 1}, "width": 1, "height": 1, "poster": 1, "muted": {"muted": 1}, "preload": {"auto": 1, "metadata": 1, "none": 1}},

2539

<+=?|>    "audio": {"src": 1, "autobuffer": 1, "autoplay": {"autoplay": 1}, "loop": {"loop": 1}, "controls": {"controls": 1}, "muted": {"muted": 1}, "preload": {"auto": 1, "metadata": 1, "none": 1 }},

2540

<+=?|> "source": {"src": 1, "type": 1, "media": 1},

2541

<+=?|> "track": {"kind": 1, "src": 1, "srclang": 1, "label": 1, "default": 1},

2542

<+=?|> "canvas": {"width": 1, "height": 1},

2543

<+=?|> "map": {"name": 1},

2544

<+=?|>    "area": {"shape": 1, "coords": 1, "href": 1, "hreflang": 1, "alt": 1, "target": 1, "media": 1, "rel": 1, "ping": 1, "type": 1},

2545

<+=?|> "svg": {},

2546

<+=?|> "math": {},

2547

<+=?|> "table": {"summary": 1},

2548

<+=?|> "caption": {},

2549

<+=?|> "colgroup": {"span": 1},

2550

<+=?|> "col": {"span": 1},

2551

<+=?|> "tbody": {},

2552

<+=?|> "thead": {},

2553

<+=?|> "tfoot": {},

2554

<+=?|> "tr": {},

2555

<+=?|> "td": {"headers": 1, "rowspan": 1, "colspan": 1},

2556

<+=?|> "th": {"headers": 1, "rowspan": 1, "colspan": 1, "scope": 1},

2557

<+=?|>    "form": {"accept-charset": 1, "action": 1, "autocomplete": 1, "enctype": {"multipart/form-data": 1, "application/x-www-form-urlencoded": 1}, "method": {"get": 1, "post": 1}, "name": 1, "novalidate": 1, "target": {"_blank": 1, "top": 1}},

2558

<+=?|> "fieldset": {"disabled": 1, "form": 1, "name": 1},

2559

<+=?|> "legend": {},

2560

<+=?|> "label": {"form": 1, "for": 1},

2561

<+=?|> "input": {

2562

<+=?|>        "type": {"text": 1, "password": 1, "hidden": 1, "checkbox": 1, "submit": 1, "radio": 1, "file": 1, "button": 1, "reset": 1, "image": 31, "color": 1, "date": 1, "datetime": 1, "datetime-local": 1, "email": 1, "month": 1, "number": 1, "range": 1, "search": 1, "tel": 1, "time": 1, "url": 1, "week": 1},

2563

<+=?|>        "accept": 1, "alt": 1, "autocomplete": {"on": 1, "off": 1}, "autofocus": {"autofocus": 1}, "checked": {"checked": 1}, "disabled": {"disabled": 1}, "form": 1, "formaction": 1, "formenctype": {"application/x-www-form-urlencoded": 1, "multipart/form-data": 1, "text/plain": 1}, "formmethod": {"get": 1, "post": 1}, "formnovalidate": {"formnovalidate": 1}, "formtarget": {"_blank": 1, "_self": 1, "_parent": 1, "_top": 1}, "height": 1, "list": 1, "max": 1, "maxlength": 1, "min": 1, "multiple": {"multiple": 1}, "name": 1, "pattern": 1, "placeholder": 1, "readonly": {"readonly": 1}, "required": {"required": 1}, "size": 1, "src": 1, "step": 1, "width": 1, "files": 1, "value": 1},

2564

<+=?|>    "button": {"autofocus": 1, "disabled": {"disabled": 1}, "form": 1, "formaction": 1, "formenctype": 1, "formmethod": 1, "formnovalidate": 1, "formtarget": 1, "name": 1, "value": 1, "type": {"button": 1, "submit": 1}},

2565

<+=?|>    "select": {"autofocus": 1, "disabled": 1, "form": 1, "multiple": {"multiple": 1}, "name": 1, "size": 1, "readonly":{"readonly": 1}},

2566

<+=?|> "datalist": {},

2567

<+=?|> "optgroup": {"disabled": 1, "label": 1},

2568

<+=?|> "option": {"disabled": 1, "selected": 1, "label": 1, "value": 1},

2569

<+=?|>    "textarea": {"autofocus": {"autofocus": 1}, "disabled": {"disabled": 1}, "form": 1, "maxlength": 1, "name": 1, "placeholder": 1, "readonly": {"readonly": 1}, "required": {"required": 1}, "rows": 1, "cols": 1, "wrap": {"on": 1, "off": 1, "hard": 1, "soft": 1}},

2570

<+=?|>    "keygen": {"autofocus": 1, "challenge": {"challenge": 1}, "disabled": {"disabled": 1}, "form": 1, "keytype": {"rsa": 1, "dsa": 1, "ec": 1}, "name": 1},

2571

<+=?|> "output": {"for": 1, "form": 1, "name": 1},

2572

<+=?|> "progress": {"value": 1, "max": 1},

2573

<+=?|> "meter": {"value": 1, "min": 1, "max": 1, "low": 1, "high": 1, "optimum": 1},

2574

<+=?|> "details": {"open": 1},

2575

<+=?|> "summary": {},

2576

<+=?|> "command": {"type": 1, "label": 1, "icon": 1, "disabled": 1, "checked": 1, "radiogroup": 1, "command": 1},

2577

<+=?|> "menu": {"type": 1, "label": 1},

2578

<+=?|> "dialog": {"open": 1}

2579

<+=?|>};

2580

2581

<+=?|>var elements = Object.keys(attributeMap);

2582

2583

<+=?|>function is(token, type) {

2584

<+=?|> return token.type.lastIndexOf(type + ".xml") > -1;

2585

<+=?|>}

2586

2587

<+=?|>function findTagName(session, pos) {

2588

<+=?|> var iterator = new TokenIterator(session, pos.row, pos.column);

2589

<+=?|> var token = iterator.getCurrentToken();

2590

<+=?|> while (token && !is(token, "tag-name")){

2591

<+=?|> token = iterator.stepBackward();

2592

<+=?|> }

2593

<+=?|> if (token)

2594

<+=?|> return token.value;

2595

<+=?|>}

2596

2597

<+=?|>function findAttributeName(session, pos) {

2598

<+=?|> var iterator = new TokenIterator(session, pos.row, pos.column);

2599

<+=?|> var token = iterator.getCurrentToken();

2600

<+=?|> while (token && !is(token, "attribute-name")){

2601

<+=?|> token = iterator.stepBackward();

2602

<+=?|> }

2603

<+=?|> if (token)

2604

<+=?|> return token.value;

2605

<+=?|>}

2606

2607

<+=?|>var HtmlCompletions = function() {

<+=?|>};

<+=?|>(function() {

2612

2613

<+=?|> this.getCompletions = function(state, session, pos, prefix) {

2614

<+=?|> var token = session.getTokenAt(pos.row, pos.column);

<+=?|> if (!token)

<+=?|> return [];

<+=?|> if (is(token, "tag-name") || is(token, "tag-open") || is(token, "end-tag-open"))

2619

<+=?|> return this.getTagCompletions(state, session, pos, prefix);

2620

<+=?|> if (is(token, "tag-whitespace") || is(token, "attribute-name"))

2621

<+=?|> return this.getAttributeCompletions(state, session, pos, prefix);

2622

<+=?|> if (is(token, "attribute-value"))

2623

<+=?|> return this.getAttributeValueCompletions(state, session, pos, prefix);

2624

<+=?|> var line = session.getLine(pos.row).substr(0, pos.column);

2625

<+=?|> if (/&[a-z]*$/i.test(line))

2626

<+=?|> return this.getHTMLEntityCompletions(state, session, pos, prefix);

<+=?|> return [];

<+=?|> };

<+=?|> this.getTagCompletions = function(state, session, pos, prefix) {

2632

<+=?|> return elements.map(function(element){

2633

<+=?|> return {

2634

<+=?|> value: element,

2635

<+=?|> meta: "tag",

2636

<+=?|> score: Number.MAX_VALUE

<+=?|> };

<+=?|> });

<+=?|> };

<+=?|> this.getAttributeCompletions = function(state, session, pos, prefix) {

2642

<+=?|> var tagName = findTagName(session, pos);

2643

<+=?|> if (!tagName)

2644

<+=?|> return [];

2645

<+=?|> var attributes = globalAttributes;

2646

<+=?|> if (tagName in attributeMap) {

2647

<+=?|> attributes = attributes.concat(Object.keys(attributeMap[tagName]));

2648

<+=?|> }

2649

<+=?|> return attributes.map(function(attribute){

2650

<+=?|> return {

2651

<+=?|> caption: attribute,

2652

<+=?|> snippet: attribute + '="$0"',

2653

<+=?|> meta: "attribute",

2654

<+=?|> score: Number.MAX_VALUE

<+=?|> };

<+=?|> });

<+=?|> };

<+=?|> this.getAttributeValueCompletions = function(state, session, pos, prefix) {

2660

<+=?|> var tagName = findTagName(session, pos);

2661

<+=?|> var attributeName = findAttributeName(session, pos);

2662

2663

<+=?|> if (!tagName)

2664

<+=?|> return [];

2665

<+=?|> var values = [];

2666

<+=?|>        if (tagName in attributeMap && attributeName in attributeMap[tagName] && typeof attributeMap[tagName][attributeName] === "object") {

2667

<+=?|> values = Object.keys(attributeMap[tagName][attributeName]);

2668

<+=?|> }

2669

<+=?|> return values.map(function(value){

2670

<+=?|> return {

2671

<+=?|> caption: value,

2672

<+=?|> snippet: value,

2673

<+=?|> meta: "attribute value",

2674

<+=?|> score: Number.MAX_VALUE

<+=?|> };

<+=?|> });

<+=?|> };

<+=?|> this.getHTMLEntityCompletions = function(state, session, pos, prefix) {

2680

<+=?|>        var values = ['Aacute;', 'aacute;', 'Acirc;', 'acirc;', 'acute;', 'AElig;', 'aelig;', 'Agrave;', 'agrave;', 'alefsym;', 'Alpha;', 'alpha;', 'amp;', 'and;', 'ang;', 'Aring;', 'aring;', 'asymp;', 'Atilde;', 'atilde;', 'Auml;', 'auml;', 'bdquo;', 'Beta;', 'beta;', 'brvbar;', 'bull;', 'cap;', 'Ccedil;', 'ccedil;', 'cedil;', 'cent;', 'Chi;', 'chi;', 'circ;', 'clubs;', 'cong;', 'copy;', 'crarr;', 'cup;', 'curren;', 'Dagger;', 'dagger;', 'dArr;', 'darr;', 'deg;', 'Delta;', 'delta;', 'diams;', 'divide;', 'Eacute;', 'eacute;', 'Ecirc;', 'ecirc;', 'Egrave;', 'egrave;', 'empty;', 'emsp;', 'ensp;', 'Epsilon;', 'epsilon;', 'equiv;', 'Eta;', 'eta;', 'ETH;', 'eth;', 'Euml;', 'euml;', 'euro;', 'exist;', 'fnof;', 'forall;', 'frac12;', 'frac14;', 'frac34;', 'frasl;', 'Gamma;', 'gamma;', 'ge;', 'gt;', 'hArr;', 'harr;', 'hearts;', 'hellip;', 'Iacute;', 'iacute;', 'Icirc;', 'icirc;', 'iexcl;', 'Igrave;', 'igrave;', 'image;', 'infin;', 'int;', 'Iota;', 'iota;', 'iquest;', 'isin;', 'Iuml;', 'iuml;', 'Kappa;', 'kappa;', 'Lambda;', 'lambda;', 'lang;', 'laquo;', 'lArr;', 'larr;', 'lceil;', 'ldquo;', 'le;', 'lfloor;', 'lowast;', 'loz;', 'lrm;', 'lsaquo;', 'lsquo;', 'lt;', 'macr;', 'mdash;', 'micro;', 'middot;', 'minus;', 'Mu;', 'mu;', 'nabla;', 'nbsp;', 'ndash;', 'ne;', 'ni;', 'not;', 'notin;', 'nsub;', 'Ntilde;', 'ntilde;', 'Nu;', 'nu;', 'Oacute;', 'oacute;', 'Ocirc;', 'ocirc;', 'OElig;', 'oelig;', 'Ograve;', 'ograve;', 'oline;', 'Omega;', 'omega;', 'Omicron;', 'omicron;', 'oplus;', 'or;', 'ordf;', 'ordm;', 'Oslash;', 'oslash;', 'Otilde;', 'otilde;', 'otimes;', 'Ouml;', 'ouml;', 'para;', 'part;', 'permil;', 'perp;', 'Phi;', 'phi;', 'Pi;', 'pi;', 'piv;', 'plusmn;', 'pound;', 'Prime;', 'prime;', 'prod;', 'prop;', 'Psi;', 'psi;', 'quot;', 'radic;', 'rang;', 'raquo;', 'rArr;', 'rarr;', 'rceil;', 'rdquo;', 'real;', 'reg;', 'rfloor;', 'Rho;', 'rho;', 'rlm;', 'rsaquo;', 'rsquo;', 'sbquo;', 'Scaron;', 'scaron;', 'sdot;', 'sect;', 'shy;', 'Sigma;', 'sigma;', 'sigmaf;', 'sim;', 'spades;', 'sub;', 'sube;', 'sum;', 'sup;', 'sup1;', 'sup2;', 'sup3;', 'supe;', 'szlig;', 'Tau;', 'tau;', 'there4;', 'Theta;', 'theta;', 'thetasym;', 'thinsp;', 'THORN;', 'thorn;', 'tilde;', 'times;', 'trade;', 'Uacute;', 'uacute;', 'uArr;', 'uarr;', 'Ucirc;', 'ucirc;', 'Ugrave;', 'ugrave;', 'uml;', 'upsih;', 'Upsilon;', 'upsilon;', 'Uuml;', 'uuml;', 'weierp;', 'Xi;', 'xi;', 'Yacute;', 'yacute;', 'yen;', 'Yuml;', 'yuml;', 'Zeta;', 'zeta;', 'zwj;', 'zwnj;'];

2681

2682

<+=?|> return values.map(function(value){

2683

<+=?|> return {

2684

<+=?|> caption: value,

2685

<+=?|> snippet: value,

2686

<+=?|> meta: "html entity",

2687

<+=?|> score: Number.MAX_VALUE

<+=?|> };

<+=?|> });

<+=?|> };

<+=?|>}).call(HtmlCompletions.prototype);

2693

2694

<+=?|>exports.HtmlCompletions = HtmlCompletions;

2695

<+=?|>});

2696

2697

<+=?|>ace.define("ace/mode/html",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/mode/text","ace/mode/javascript","ace/mode/css","ace/mode/html_highlight_rules","ace/mode/behaviour/xml","ace/mode/folding/html","ace/mode/html_completions","ace/worker/worker_client"], function(require, exports, module) {

2698

<+=?|>"use strict";

2699

2700

<+=?|>var oop = require("../lib/oop");

2701

<+=?|>var lang = require("../lib/lang");

2702

<+=?|>var TextMode = require("./text").Mode;

2703

<+=?|>var JavaScriptMode = require("./javascript").Mode;

2704

<+=?|>var CssMode = require("./css").Mode;

2705

<+=?|>var HtmlHighlightRules = require("./html_highlight_rules").HtmlHighlightRules;

2706

<+=?|>var XmlBehaviour = require("./behaviour/xml").XmlBehaviour;

2707

<+=?|>var HtmlFoldMode = require("./folding/html").FoldMode;

2708

<+=?|>var HtmlCompletions = require("./html_completions").HtmlCompletions;

2709

<+=?|>var WorkerClient = require("../worker/worker_client").WorkerClient;

2710

<+=?|>var voidElements = ["area", "base", "br", "col", "embed", "hr", "img", "input", "keygen", "link", "meta", "menuitem", "param", "source", "track", "wbr"];

2711

<+=?|>var optionalEndTags = ["li", "dt", "dd", "p", "rt", "rp", "optgroup", "option", "colgroup", "td", "th"];

2712

2713

<+=?|>var Mode = function(options) {

2714

<+=?|> this.fragmentContext = options && options.fragmentContext;

2715

<+=?|> this.HighlightRules = HtmlHighlightRules;

2716

<+=?|> this.$behaviour = new XmlBehaviour();

2717

<+=?|> this.$completer = new HtmlCompletions();

2718

2719

<+=?|> this.createModeDelegates({

2720

<+=?|> "js-": JavaScriptMode,

2721

<+=?|> "css-": CssMode

2722

<+=?|> });

2723

2724

<+=?|> this.foldingRules = new HtmlFoldMode(this.voidElements, lang.arrayToMap(optionalEndTags));

2725

<+=?|>};

2726

<+=?|>oop.inherits(Mode, TextMode);

2727

2728

<+=?|>(function() {

2729

2730

<+=?|> this.blockComment = {start: ""};

2731

2732

<+=?|> this.voidElements = lang.arrayToMap(voidElements);

2733

2734

<+=?|> this.getNextLineIndent = function(state, line, tab) {

2735

<+=?|> return this.$getIndent(line);

2736

<+=?|> };

2737

2738

<+=?|> this.checkOutdent = function(state, line, input) {

2739

<+=?|> return false;

2740

<+=?|> };

2741

2742

<+=?|> this.getCompletions = function(state, session, pos, prefix) {

2743

<+=?|> return this.$completer.getCompletions(state, session, pos, prefix);

2744

<+=?|> };

2745

2746

<+=?|> this.createWorker = function(session) {

2747

<+=?|> if (this.constructor != Mode)

2748

<+=?|> return;

2749

<+=?|> var worker = new WorkerClient(["ace"], "ace/mode/html_worker", "Worker");

2750

<+=?|> worker.attachToDocument(session.getDocument());

2751

2752

<+=?|> if (this.fragmentContext)

2753

<+=?|> worker.call("setOptions", [{context: this.fragmentContext}]);

2754

2755

<+=?|> worker.on("error", function(e) {

2756

<+=?|> session.setAnnotations(e.data);

2757

<+=?|> });

2758

2759

<+=?|> worker.on("terminate", function() {

2760

<+=?|> session.clearAnnotations();

2761

<+=?|> });

2762

2763

<+=?|> return worker;

2764

<+=?|> };

2765

2766

<+=?|> this.$id = "ace/mode/html";

2767

<+=?|>}).call(Mode.prototype);

2768

2769

<+=?|>exports.Mode = Mode;

2770

<+=?|>});

2771

2772

<+=?|>ace.define("ace/mode/folding/coffee",["require","exports","module","ace/lib/oop","ace/mode/folding/fold_mode","ace/range"], function(require, exports, module) {

2773

<+=?|>"use strict";

2774

2775

<+=?|>var oop = require("../../lib/oop");

2776

<+=?|>var BaseFoldMode = require("./fold_mode").FoldMode;

2777

<+=?|>var Range = require("../../range").Range;

2778

2779

<+=?|>var FoldMode = exports.FoldMode = function() {};

2780

<+=?|>oop.inherits(FoldMode, BaseFoldMode);

2781

2782

<+=?|>(function() {

2783

2784

<+=?|> this.getFoldWidgetRange = function(session, foldStyle, row) {

2785

<+=?|> var range = this.indentationBlock(session, row);

2786

<+=?|> if (range)

2787

<+=?|> return range;

2788

2789

<+=?|> var re = /\S/;

2790

<+=?|> var line = session.getLine(row);

2791

<+=?|> var startLevel = line.search(re);

2792

<+=?|> if (startLevel == -1 || line[startLevel] != "#")

2793

<+=?|> return;

2794

2795

<+=?|> var startColumn = line.length;

2796

<+=?|> var maxRow = session.getLength();

2797

<+=?|> var startRow = row;

2798

<+=?|> var endRow = row;

2799

2800

<+=?|> while (++row < maxRow) {

2801

<+=?|> line = session.getLine(row);

2802

<+=?|> var level = line.search(re);

2803

2804

<+=?|> if (level == -1)

2805

<+=?|> continue;

2806

2807

<+=?|> if (line[level] != "#")

2808

<+=?|> break;

2809

2810

<+=?|> endRow = row;

2811

<+=?|> }

2812

2813

<+=?|> if (endRow > startRow) {

2814

<+=?|> var endColumn = session.getLine(endRow).length;

2815

<+=?|> return new Range(startRow, startColumn, endRow, endColumn);

2816

<+=?|> }

2817

<+=?|> };

2818

<+=?|> this.getFoldWidget = function(session, foldStyle, row) {

2819

<+=?|> var line = session.getLine(row);

2820

<+=?|> var indent = line.search(/\S/);

2821

<+=?|> var next = session.getLine(row + 1);

2822

<+=?|> var prev = session.getLine(row - 1);

2823

<+=?|> var prevIndent = prev.search(/\S/);

2824

<+=?|> var nextIndent = next.search(/\S/);

2825

2826

<+=?|> if (indent == -1) {

2827

<+=?|> session.foldWidgets[row - 1] = prevIndent!= -1 && prevIndent < nextIndent ? "start" : "";

2828

<+=?|> return "";

2829

<+=?|> }

2830

<+=?|> if (prevIndent == -1) {

2831

<+=?|> if (indent == nextIndent && line[indent] == "#" && next[indent] == "#") {

2832

<+=?|> session.foldWidgets[row - 1] = "";

2833

<+=?|> session.foldWidgets[row + 1] = "";

2834

<+=?|> return "start";

2835

<+=?|> }

2836

<+=?|> } else if (prevIndent == indent && line[indent] == "#" && prev[indent] == "#") {

2837

<+=?|> if (session.getLine(row - 2).search(/\S/) == -1) {

2838

<+=?|> session.foldWidgets[row - 1] = "start";

2839

<+=?|> session.foldWidgets[row + 1] = "";

<+=?|> return "";

<+=?|> }

<+=?|> }

<+=?|> if (prevIndent!= -1 && prevIndent < indent)

2845

<+=?|> session.foldWidgets[row - 1] = "start";

2846

<+=?|> else

2847

<+=?|> session.foldWidgets[row - 1] = "";

2848

2849

<+=?|> if (indent < nextIndent)

2850

<+=?|> return "start";

<+=?|> else

<+=?|> return "";

<+=?|> };

<+=?|>}).call(FoldMode.prototype);

<+=?|>});

<+=?|>ace.define("ace/mode/ruby",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/ruby_highlight_rules","ace/mode/matching_brace_outdent","ace/range","ace/mode/behaviour/cstyle","ace/mode/folding/coffee"], function(require, exports, module) {

2860

<+=?|>"use strict";

2861

2862

<+=?|>var oop = require("../lib/oop");

2863

<+=?|>var TextMode = require("./text").Mode;

2864

<+=?|>var RubyHighlightRules = require("./ruby_highlight_rules").RubyHighlightRules;

2865

<+=?|>var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;

2866

<+=?|>var Range = require("../range").Range;

2867

<+=?|>var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;

2868

<+=?|>var FoldMode = require("./folding/coffee").FoldMode;

2869

2870

<+=?|>var Mode = function() {

2871

<+=?|> this.HighlightRules = RubyHighlightRules;

2872

<+=?|> this.$outdent = new MatchingBraceOutdent();

2873

<+=?|> this.$behaviour = new CstyleBehaviour();

2874

<+=?|> this.foldingRules = new FoldMode();

2875

<+=?|>};

2876

<+=?|>oop.inherits(Mode, TextMode);

2877

2878

<+=?|>(function() {

2879

2880

2881

<+=?|> this.lineCommentStart = "#";

2882

2883

<+=?|> this.getNextLineIndent = function(state, line, tab) {

2884

<+=?|> var indent = this.$getIndent(line);

2885

2886

<+=?|> var tokenizedLine = this.getTokenizer().getLineTokens(line, state);

2887

<+=?|> var tokens = tokenizedLine.tokens;

2888

2889

<+=?|> if (tokens.length && tokens[tokens.length-1].type == "comment") {

2890

<+=?|> return indent;

2891

<+=?|> }

2892

2893

<+=?|> if (state == "start") {

2894

<+=?|> var match = line.match(/^.*[\{\(\[]\s*$/);

2895

<+=?|> var startingClassOrMethod = line.match(/^\s*(class|def|module)\s.*$/);

2896

<+=?|> var startingDoBlock = line.match(/.*do(\s*|\s+\|.*\|\s*)$/);

2897

<+=?|> var startingConditional = line.match(/^\s*(if|else|when)\s*/)

2898

<+=?|> if (match || startingClassOrMethod || startingDoBlock || startingConditional) {

2899

<+=?|> indent += tab;

<+=?|> }

<+=?|> }

<+=?|> return indent;

2904

<+=?|> };

2905

2906

<+=?|> this.checkOutdent = function(state, line, input) {

2907

<+=?|> return /^\s+(end|else)$/.test(line + input) || this.$outdent.checkOutdent(line, input);

2908

<+=?|> };

2909

2910

<+=?|> this.autoOutdent = function(state, session, row) {

2911

<+=?|> var line = session.getLine(row);

2912

<+=?|> if (/}/.test(line))

2913

<+=?|> return this.$outdent.autoOutdent(session, row);

2914

<+=?|> var indent = this.$getIndent(line);

2915

<+=?|> var prevLine = session.getLine(row - 1);

2916

<+=?|> var prevIndent = this.$getIndent(prevLine);

2917

<+=?|> var tab = session.getTabString();

2918

<+=?|> if (prevIndent.length <= indent.length) {

2919

<+=?|> if (indent.slice(-tab.length) == tab)

2920

<+=?|> session.remove(new Range(row, indent.length-tab.length, row, indent.length));

<+=?|> }

<+=?|> };

<+=?|> this.$id = "ace/mode/ruby";

2925

<+=?|>}).call(Mode.prototype);

2926

2927

<+=?|>exports.Mode = Mode;

2928

<+=?|>});

2929

2930

<+=?|>ace.define("ace/mode/html_ruby",["require","exports","module","ace/lib/oop","ace/mode/html_ruby_highlight_rules","ace/mode/html","ace/mode/javascript","ace/mode/css","ace/mode/ruby"], function(require, exports, module) {