hyde_admin 0.0.1 → 0.0.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (71) hide show
  1. checksums.yaml +4 -4
  2. data/.gitattributes +3 -0
  3. data/.idea/hyde_admin.iml +2 -0
  4. data/.idea/vcs.xml +6 -0
  5. data/CHANGELOG.md +35 -0
  6. data/README.md +23 -0
  7. data/TODO.md +3 -0
  8. data/bin/admin_views/admin_layout.html.erb +204 -108
  9. data/bin/admin_views/configuration.erb +13 -0
  10. data/bin/admin_views/dashboard.erb +1 -1
  11. data/bin/admin_views/editor_html.erb +24 -0
  12. data/bin/admin_views/editor_js.erb +120 -0
  13. data/bin/admin_views/files/edit.erb +30 -0
  14. data/bin/admin_views/files/listing.erb +111 -0
  15. data/bin/admin_views/partials/image_element.html.erb +4 -0
  16. data/bin/admin_views/partials/images_page.html.erb +8 -0
  17. data/bin/admin_views/posts/edit.erb +158 -0
  18. data/bin/admin_views/posts/listing.erb +37 -0
  19. data/bin/admin_views/upload_image_form.erb +45 -0
  20. data/bin/fslightbox/fslightbox.js +1 -0
  21. data/bin/hyde_admin +3 -0
  22. data/bin/hyde_admin.ru +306 -56
  23. data/bin/hyde_admin.yml +12 -5
  24. data/bin/hyde_assets/hyde_admin.css +37 -0
  25. data/bin/hyde_assets/hyde_admin.js +24 -0
  26. data/bin/i18n/en.yml +77 -1
  27. data/bin/i18n/fr.yml +77 -1
  28. data/bin/lib/codemirror.css +349 -0
  29. data/bin/lib/codemirror.js +9833 -0
  30. data/bin/mode/css/css.js +864 -0
  31. data/bin/mode/css/gss.html +104 -0
  32. data/bin/mode/css/gss_test.js +17 -0
  33. data/bin/mode/css/index.html +81 -0
  34. data/bin/mode/css/less.html +152 -0
  35. data/bin/mode/css/less_test.js +54 -0
  36. data/bin/mode/css/scss.html +158 -0
  37. data/bin/mode/css/scss_test.js +110 -0
  38. data/bin/mode/css/test.js +217 -0
  39. data/bin/mode/htmlembedded/htmlembedded.js +37 -0
  40. data/bin/mode/htmlembedded/index.html +60 -0
  41. data/bin/mode/htmlmixed/htmlmixed.js +153 -0
  42. data/bin/mode/htmlmixed/index.html +100 -0
  43. data/bin/mode/javascript/index.html +118 -0
  44. data/bin/mode/javascript/javascript.js +959 -0
  45. data/bin/mode/javascript/json-ld.html +72 -0
  46. data/bin/mode/javascript/test.js +521 -0
  47. data/bin/mode/javascript/typescript.html +62 -0
  48. data/bin/mode/markdown/index.html +418 -0
  49. data/bin/mode/markdown/markdown.js +886 -0
  50. data/bin/mode/markdown/test.js +1319 -0
  51. data/bin/mode/ruby/index.html +183 -0
  52. data/bin/mode/ruby/ruby.js +303 -0
  53. data/bin/mode/ruby/test.js +23 -0
  54. data/bin/mode/sass/index.html +68 -0
  55. data/bin/mode/sass/sass.js +459 -0
  56. data/bin/mode/sass/test.js +122 -0
  57. data/bin/mode/spreadsheet/index.html +42 -0
  58. data/bin/mode/spreadsheet/spreadsheet.js +112 -0
  59. data/bin/mode/xml/index.html +61 -0
  60. data/bin/mode/xml/test.js +51 -0
  61. data/bin/mode/xml/xml.js +417 -0
  62. data/bin/mode/yaml/index.html +80 -0
  63. data/bin/mode/yaml/yaml.js +120 -0
  64. data/bin/mode/yaml-frontmatter/index.html +121 -0
  65. data/bin/mode/yaml-frontmatter/yaml-frontmatter.js +72 -0
  66. data/hyde_admin.gemspec +7 -1
  67. data/lib/hyde_admin/version.rb +1 -1
  68. metadata +131 -7
  69. data/bin/admin_views/edit.erb +0 -57
  70. data/bin/admin_views/listing.erb +0 -32
  71. data/bin/hyde_admin.sh +0 -3
@@ -0,0 +1,959 @@
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: https://codemirror.net/LICENSE
3
+
4
+ (function(mod) {
5
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
6
+ mod(require("../../lib/codemirror"));
7
+ else if (typeof define == "function" && define.amd) // AMD
8
+ define(["../../lib/codemirror"], mod);
9
+ else // Plain browser env
10
+ mod(CodeMirror);
11
+ })(function(CodeMirror) {
12
+ "use strict";
13
+
14
+ CodeMirror.defineMode("javascript", function(config, parserConfig) {
15
+ var indentUnit = config.indentUnit;
16
+ var statementIndent = parserConfig.statementIndent;
17
+ var jsonldMode = parserConfig.jsonld;
18
+ var jsonMode = parserConfig.json || jsonldMode;
19
+ var trackScope = parserConfig.trackScope !== false
20
+ var isTS = parserConfig.typescript;
21
+ var wordRE = parserConfig.wordCharacters || /[\w$\xa1-\uffff]/;
22
+
23
+ // Tokenizer
24
+
25
+ var keywords = function(){
26
+ function kw(type) {return {type: type, style: "keyword"};}
27
+ var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c"), D = kw("keyword d");
28
+ var operator = kw("operator"), atom = {type: "atom", style: "atom"};
29
+
30
+ return {
31
+ "if": kw("if"), "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
32
+ "return": D, "break": D, "continue": D, "new": kw("new"), "delete": C, "void": C, "throw": C,
33
+ "debugger": kw("debugger"), "var": kw("var"), "const": kw("var"), "let": kw("var"),
34
+ "function": kw("function"), "catch": kw("catch"),
35
+ "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
36
+ "in": operator, "typeof": operator, "instanceof": operator,
37
+ "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom,
38
+ "this": kw("this"), "class": kw("class"), "super": kw("atom"),
39
+ "yield": C, "export": kw("export"), "import": kw("import"), "extends": C,
40
+ "await": C
41
+ };
42
+ }();
43
+
44
+ var isOperatorChar = /[+\-*&%=<>!?|~^@]/;
45
+ var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/;
46
+
47
+ function readRegexp(stream) {
48
+ var escaped = false, next, inSet = false;
49
+ while ((next = stream.next()) != null) {
50
+ if (!escaped) {
51
+ if (next == "/" && !inSet) return;
52
+ if (next == "[") inSet = true;
53
+ else if (inSet && next == "]") inSet = false;
54
+ }
55
+ escaped = !escaped && next == "\\";
56
+ }
57
+ }
58
+
59
+ // Used as scratch variables to communicate multiple values without
60
+ // consing up tons of objects.
61
+ var type, content;
62
+ function ret(tp, style, cont) {
63
+ type = tp; content = cont;
64
+ return style;
65
+ }
66
+ function tokenBase(stream, state) {
67
+ var ch = stream.next();
68
+ if (ch == '"' || ch == "'") {
69
+ state.tokenize = tokenString(ch);
70
+ return state.tokenize(stream, state);
71
+ } else if (ch == "." && stream.match(/^\d[\d_]*(?:[eE][+\-]?[\d_]+)?/)) {
72
+ return ret("number", "number");
73
+ } else if (ch == "." && stream.match("..")) {
74
+ return ret("spread", "meta");
75
+ } else if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
76
+ return ret(ch);
77
+ } else if (ch == "=" && stream.eat(">")) {
78
+ return ret("=>", "operator");
79
+ } else if (ch == "0" && stream.match(/^(?:x[\dA-Fa-f_]+|o[0-7_]+|b[01_]+)n?/)) {
80
+ return ret("number", "number");
81
+ } else if (/\d/.test(ch)) {
82
+ stream.match(/^[\d_]*(?:n|(?:\.[\d_]*)?(?:[eE][+\-]?[\d_]+)?)?/);
83
+ return ret("number", "number");
84
+ } else if (ch == "/") {
85
+ if (stream.eat("*")) {
86
+ state.tokenize = tokenComment;
87
+ return tokenComment(stream, state);
88
+ } else if (stream.eat("/")) {
89
+ stream.skipToEnd();
90
+ return ret("comment", "comment");
91
+ } else if (expressionAllowed(stream, state, 1)) {
92
+ readRegexp(stream);
93
+ stream.match(/^\b(([gimyus])(?![gimyus]*\2))+\b/);
94
+ return ret("regexp", "string-2");
95
+ } else {
96
+ stream.eat("=");
97
+ return ret("operator", "operator", stream.current());
98
+ }
99
+ } else if (ch == "`") {
100
+ state.tokenize = tokenQuasi;
101
+ return tokenQuasi(stream, state);
102
+ } else if (ch == "#" && stream.peek() == "!") {
103
+ stream.skipToEnd();
104
+ return ret("meta", "meta");
105
+ } else if (ch == "#" && stream.eatWhile(wordRE)) {
106
+ return ret("variable", "property")
107
+ } else if (ch == "<" && stream.match("!--") ||
108
+ (ch == "-" && stream.match("->") && !/\S/.test(stream.string.slice(0, stream.start)))) {
109
+ stream.skipToEnd()
110
+ return ret("comment", "comment")
111
+ } else if (isOperatorChar.test(ch)) {
112
+ if (ch != ">" || !state.lexical || state.lexical.type != ">") {
113
+ if (stream.eat("=")) {
114
+ if (ch == "!" || ch == "=") stream.eat("=")
115
+ } else if (/[<>*+\-|&?]/.test(ch)) {
116
+ stream.eat(ch)
117
+ if (ch == ">") stream.eat(ch)
118
+ }
119
+ }
120
+ if (ch == "?" && stream.eat(".")) return ret(".")
121
+ return ret("operator", "operator", stream.current());
122
+ } else if (wordRE.test(ch)) {
123
+ stream.eatWhile(wordRE);
124
+ var word = stream.current()
125
+ if (state.lastType != ".") {
126
+ if (keywords.propertyIsEnumerable(word)) {
127
+ var kw = keywords[word]
128
+ return ret(kw.type, kw.style, word)
129
+ }
130
+ if (word == "async" && stream.match(/^(\s|\/\*([^*]|\*(?!\/))*?\*\/)*[\[\(\w]/, false))
131
+ return ret("async", "keyword", word)
132
+ }
133
+ return ret("variable", "variable", word)
134
+ }
135
+ }
136
+
137
+ function tokenString(quote) {
138
+ return function(stream, state) {
139
+ var escaped = false, next;
140
+ if (jsonldMode && stream.peek() == "@" && stream.match(isJsonldKeyword)){
141
+ state.tokenize = tokenBase;
142
+ return ret("jsonld-keyword", "meta");
143
+ }
144
+ while ((next = stream.next()) != null) {
145
+ if (next == quote && !escaped) break;
146
+ escaped = !escaped && next == "\\";
147
+ }
148
+ if (!escaped) state.tokenize = tokenBase;
149
+ return ret("string", "string");
150
+ };
151
+ }
152
+
153
+ function tokenComment(stream, state) {
154
+ var maybeEnd = false, ch;
155
+ while (ch = stream.next()) {
156
+ if (ch == "/" && maybeEnd) {
157
+ state.tokenize = tokenBase;
158
+ break;
159
+ }
160
+ maybeEnd = (ch == "*");
161
+ }
162
+ return ret("comment", "comment");
163
+ }
164
+
165
+ function tokenQuasi(stream, state) {
166
+ var escaped = false, next;
167
+ while ((next = stream.next()) != null) {
168
+ if (!escaped && (next == "`" || next == "$" && stream.eat("{"))) {
169
+ state.tokenize = tokenBase;
170
+ break;
171
+ }
172
+ escaped = !escaped && next == "\\";
173
+ }
174
+ return ret("quasi", "string-2", stream.current());
175
+ }
176
+
177
+ var brackets = "([{}])";
178
+ // This is a crude lookahead trick to try and notice that we're
179
+ // parsing the argument patterns for a fat-arrow function before we
180
+ // actually hit the arrow token. It only works if the arrow is on
181
+ // the same line as the arguments and there's no strange noise
182
+ // (comments) in between. Fallback is to only notice when we hit the
183
+ // arrow, and not declare the arguments as locals for the arrow
184
+ // body.
185
+ function findFatArrow(stream, state) {
186
+ if (state.fatArrowAt) state.fatArrowAt = null;
187
+ var arrow = stream.string.indexOf("=>", stream.start);
188
+ if (arrow < 0) return;
189
+
190
+ if (isTS) { // Try to skip TypeScript return type declarations after the arguments
191
+ var m = /:\s*(?:\w+(?:<[^>]*>|\[\])?|\{[^}]*\})\s*$/.exec(stream.string.slice(stream.start, arrow))
192
+ if (m) arrow = m.index
193
+ }
194
+
195
+ var depth = 0, sawSomething = false;
196
+ for (var pos = arrow - 1; pos >= 0; --pos) {
197
+ var ch = stream.string.charAt(pos);
198
+ var bracket = brackets.indexOf(ch);
199
+ if (bracket >= 0 && bracket < 3) {
200
+ if (!depth) { ++pos; break; }
201
+ if (--depth == 0) { if (ch == "(") sawSomething = true; break; }
202
+ } else if (bracket >= 3 && bracket < 6) {
203
+ ++depth;
204
+ } else if (wordRE.test(ch)) {
205
+ sawSomething = true;
206
+ } else if (/["'\/`]/.test(ch)) {
207
+ for (;; --pos) {
208
+ if (pos == 0) return
209
+ var next = stream.string.charAt(pos - 1)
210
+ if (next == ch && stream.string.charAt(pos - 2) != "\\") { pos--; break }
211
+ }
212
+ } else if (sawSomething && !depth) {
213
+ ++pos;
214
+ break;
215
+ }
216
+ }
217
+ if (sawSomething && !depth) state.fatArrowAt = pos;
218
+ }
219
+
220
+ // Parser
221
+
222
+ var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true,
223
+ "regexp": true, "this": true, "import": true, "jsonld-keyword": true};
224
+
225
+ function JSLexical(indented, column, type, align, prev, info) {
226
+ this.indented = indented;
227
+ this.column = column;
228
+ this.type = type;
229
+ this.prev = prev;
230
+ this.info = info;
231
+ if (align != null) this.align = align;
232
+ }
233
+
234
+ function inScope(state, varname) {
235
+ if (!trackScope) return false
236
+ for (var v = state.localVars; v; v = v.next)
237
+ if (v.name == varname) return true;
238
+ for (var cx = state.context; cx; cx = cx.prev) {
239
+ for (var v = cx.vars; v; v = v.next)
240
+ if (v.name == varname) return true;
241
+ }
242
+ }
243
+
244
+ function parseJS(state, style, type, content, stream) {
245
+ var cc = state.cc;
246
+ // Communicate our context to the combinators.
247
+ // (Less wasteful than consing up a hundred closures on every call.)
248
+ cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;
249
+
250
+ if (!state.lexical.hasOwnProperty("align"))
251
+ state.lexical.align = true;
252
+
253
+ while(true) {
254
+ var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
255
+ if (combinator(type, content)) {
256
+ while(cc.length && cc[cc.length - 1].lex)
257
+ cc.pop()();
258
+ if (cx.marked) return cx.marked;
259
+ if (type == "variable" && inScope(state, content)) return "variable-2";
260
+ return style;
261
+ }
262
+ }
263
+ }
264
+
265
+ // Combinator utils
266
+
267
+ var cx = {state: null, column: null, marked: null, cc: null};
268
+ function pass() {
269
+ for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
270
+ }
271
+ function cont() {
272
+ pass.apply(null, arguments);
273
+ return true;
274
+ }
275
+ function inList(name, list) {
276
+ for (var v = list; v; v = v.next) if (v.name == name) return true
277
+ return false;
278
+ }
279
+ function register(varname) {
280
+ var state = cx.state;
281
+ cx.marked = "def";
282
+ if (!trackScope) return
283
+ if (state.context) {
284
+ if (state.lexical.info == "var" && state.context && state.context.block) {
285
+ // FIXME function decls are also not block scoped
286
+ var newContext = registerVarScoped(varname, state.context)
287
+ if (newContext != null) {
288
+ state.context = newContext
289
+ return
290
+ }
291
+ } else if (!inList(varname, state.localVars)) {
292
+ state.localVars = new Var(varname, state.localVars)
293
+ return
294
+ }
295
+ }
296
+ // Fall through means this is global
297
+ if (parserConfig.globalVars && !inList(varname, state.globalVars))
298
+ state.globalVars = new Var(varname, state.globalVars)
299
+ }
300
+ function registerVarScoped(varname, context) {
301
+ if (!context) {
302
+ return null
303
+ } else if (context.block) {
304
+ var inner = registerVarScoped(varname, context.prev)
305
+ if (!inner) return null
306
+ if (inner == context.prev) return context
307
+ return new Context(inner, context.vars, true)
308
+ } else if (inList(varname, context.vars)) {
309
+ return context
310
+ } else {
311
+ return new Context(context.prev, new Var(varname, context.vars), false)
312
+ }
313
+ }
314
+
315
+ function isModifier(name) {
316
+ return name == "public" || name == "private" || name == "protected" || name == "abstract" || name == "readonly"
317
+ }
318
+
319
+ // Combinators
320
+
321
+ function Context(prev, vars, block) { this.prev = prev; this.vars = vars; this.block = block }
322
+ function Var(name, next) { this.name = name; this.next = next }
323
+
324
+ var defaultVars = new Var("this", new Var("arguments", null))
325
+ function pushcontext() {
326
+ cx.state.context = new Context(cx.state.context, cx.state.localVars, false)
327
+ cx.state.localVars = defaultVars
328
+ }
329
+ function pushblockcontext() {
330
+ cx.state.context = new Context(cx.state.context, cx.state.localVars, true)
331
+ cx.state.localVars = null
332
+ }
333
+ function popcontext() {
334
+ cx.state.localVars = cx.state.context.vars
335
+ cx.state.context = cx.state.context.prev
336
+ }
337
+ popcontext.lex = true
338
+ function pushlex(type, info) {
339
+ var result = function() {
340
+ var state = cx.state, indent = state.indented;
341
+ if (state.lexical.type == "stat") indent = state.lexical.indented;
342
+ else for (var outer = state.lexical; outer && outer.type == ")" && outer.align; outer = outer.prev)
343
+ indent = outer.indented;
344
+ state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);
345
+ };
346
+ result.lex = true;
347
+ return result;
348
+ }
349
+ function poplex() {
350
+ var state = cx.state;
351
+ if (state.lexical.prev) {
352
+ if (state.lexical.type == ")")
353
+ state.indented = state.lexical.indented;
354
+ state.lexical = state.lexical.prev;
355
+ }
356
+ }
357
+ poplex.lex = true;
358
+
359
+ function expect(wanted) {
360
+ function exp(type) {
361
+ if (type == wanted) return cont();
362
+ else if (wanted == ";" || type == "}" || type == ")" || type == "]") return pass();
363
+ else return cont(exp);
364
+ };
365
+ return exp;
366
+ }
367
+
368
+ function statement(type, value) {
369
+ if (type == "var") return cont(pushlex("vardef", value), vardef, expect(";"), poplex);
370
+ if (type == "keyword a") return cont(pushlex("form"), parenExpr, statement, poplex);
371
+ if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
372
+ if (type == "keyword d") return cx.stream.match(/^\s*$/, false) ? cont() : cont(pushlex("stat"), maybeexpression, expect(";"), poplex);
373
+ if (type == "debugger") return cont(expect(";"));
374
+ if (type == "{") return cont(pushlex("}"), pushblockcontext, block, poplex, popcontext);
375
+ if (type == ";") return cont();
376
+ if (type == "if") {
377
+ if (cx.state.lexical.info == "else" && cx.state.cc[cx.state.cc.length - 1] == poplex)
378
+ cx.state.cc.pop()();
379
+ return cont(pushlex("form"), parenExpr, statement, poplex, maybeelse);
380
+ }
381
+ if (type == "function") return cont(functiondef);
382
+ if (type == "for") return cont(pushlex("form"), pushblockcontext, forspec, statement, popcontext, poplex);
383
+ if (type == "class" || (isTS && value == "interface")) {
384
+ cx.marked = "keyword"
385
+ return cont(pushlex("form", type == "class" ? type : value), className, poplex)
386
+ }
387
+ if (type == "variable") {
388
+ if (isTS && value == "declare") {
389
+ cx.marked = "keyword"
390
+ return cont(statement)
391
+ } else if (isTS && (value == "module" || value == "enum" || value == "type") && cx.stream.match(/^\s*\w/, false)) {
392
+ cx.marked = "keyword"
393
+ if (value == "enum") return cont(enumdef);
394
+ else if (value == "type") return cont(typename, expect("operator"), typeexpr, expect(";"));
395
+ else return cont(pushlex("form"), pattern, expect("{"), pushlex("}"), block, poplex, poplex)
396
+ } else if (isTS && value == "namespace") {
397
+ cx.marked = "keyword"
398
+ return cont(pushlex("form"), expression, statement, poplex)
399
+ } else if (isTS && value == "abstract") {
400
+ cx.marked = "keyword"
401
+ return cont(statement)
402
+ } else {
403
+ return cont(pushlex("stat"), maybelabel);
404
+ }
405
+ }
406
+ if (type == "switch") return cont(pushlex("form"), parenExpr, expect("{"), pushlex("}", "switch"), pushblockcontext,
407
+ block, poplex, poplex, popcontext);
408
+ if (type == "case") return cont(expression, expect(":"));
409
+ if (type == "default") return cont(expect(":"));
410
+ if (type == "catch") return cont(pushlex("form"), pushcontext, maybeCatchBinding, statement, poplex, popcontext);
411
+ if (type == "export") return cont(pushlex("stat"), afterExport, poplex);
412
+ if (type == "import") return cont(pushlex("stat"), afterImport, poplex);
413
+ if (type == "async") return cont(statement)
414
+ if (value == "@") return cont(expression, statement)
415
+ return pass(pushlex("stat"), expression, expect(";"), poplex);
416
+ }
417
+ function maybeCatchBinding(type) {
418
+ if (type == "(") return cont(funarg, expect(")"))
419
+ }
420
+ function expression(type, value) {
421
+ return expressionInner(type, value, false);
422
+ }
423
+ function expressionNoComma(type, value) {
424
+ return expressionInner(type, value, true);
425
+ }
426
+ function parenExpr(type) {
427
+ if (type != "(") return pass()
428
+ return cont(pushlex(")"), maybeexpression, expect(")"), poplex)
429
+ }
430
+ function expressionInner(type, value, noComma) {
431
+ if (cx.state.fatArrowAt == cx.stream.start) {
432
+ var body = noComma ? arrowBodyNoComma : arrowBody;
433
+ if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, expect("=>"), body, popcontext);
434
+ else if (type == "variable") return pass(pushcontext, pattern, expect("=>"), body, popcontext);
435
+ }
436
+
437
+ var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;
438
+ if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);
439
+ if (type == "function") return cont(functiondef, maybeop);
440
+ if (type == "class" || (isTS && value == "interface")) { cx.marked = "keyword"; return cont(pushlex("form"), classExpression, poplex); }
441
+ if (type == "keyword c" || type == "async") return cont(noComma ? expressionNoComma : expression);
442
+ if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeop);
443
+ if (type == "operator" || type == "spread") return cont(noComma ? expressionNoComma : expression);
444
+ if (type == "[") return cont(pushlex("]"), arrayLiteral, poplex, maybeop);
445
+ if (type == "{") return contCommasep(objprop, "}", null, maybeop);
446
+ if (type == "quasi") return pass(quasi, maybeop);
447
+ if (type == "new") return cont(maybeTarget(noComma));
448
+ return cont();
449
+ }
450
+ function maybeexpression(type) {
451
+ if (type.match(/[;\}\)\],]/)) return pass();
452
+ return pass(expression);
453
+ }
454
+
455
+ function maybeoperatorComma(type, value) {
456
+ if (type == ",") return cont(maybeexpression);
457
+ return maybeoperatorNoComma(type, value, false);
458
+ }
459
+ function maybeoperatorNoComma(type, value, noComma) {
460
+ var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;
461
+ var expr = noComma == false ? expression : expressionNoComma;
462
+ if (type == "=>") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);
463
+ if (type == "operator") {
464
+ if (/\+\+|--/.test(value) || isTS && value == "!") return cont(me);
465
+ if (isTS && value == "<" && cx.stream.match(/^([^<>]|<[^<>]*>)*>\s*\(/, false))
466
+ return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, me);
467
+ if (value == "?") return cont(expression, expect(":"), expr);
468
+ return cont(expr);
469
+ }
470
+ if (type == "quasi") { return pass(quasi, me); }
471
+ if (type == ";") return;
472
+ if (type == "(") return contCommasep(expressionNoComma, ")", "call", me);
473
+ if (type == ".") return cont(property, me);
474
+ if (type == "[") return cont(pushlex("]"), maybeexpression, expect("]"), poplex, me);
475
+ if (isTS && value == "as") { cx.marked = "keyword"; return cont(typeexpr, me) }
476
+ if (type == "regexp") {
477
+ cx.state.lastType = cx.marked = "operator"
478
+ cx.stream.backUp(cx.stream.pos - cx.stream.start - 1)
479
+ return cont(expr)
480
+ }
481
+ }
482
+ function quasi(type, value) {
483
+ if (type != "quasi") return pass();
484
+ if (value.slice(value.length - 2) != "${") return cont(quasi);
485
+ return cont(maybeexpression, continueQuasi);
486
+ }
487
+ function continueQuasi(type) {
488
+ if (type == "}") {
489
+ cx.marked = "string-2";
490
+ cx.state.tokenize = tokenQuasi;
491
+ return cont(quasi);
492
+ }
493
+ }
494
+ function arrowBody(type) {
495
+ findFatArrow(cx.stream, cx.state);
496
+ return pass(type == "{" ? statement : expression);
497
+ }
498
+ function arrowBodyNoComma(type) {
499
+ findFatArrow(cx.stream, cx.state);
500
+ return pass(type == "{" ? statement : expressionNoComma);
501
+ }
502
+ function maybeTarget(noComma) {
503
+ return function(type) {
504
+ if (type == ".") return cont(noComma ? targetNoComma : target);
505
+ else if (type == "variable" && isTS) return cont(maybeTypeArgs, noComma ? maybeoperatorNoComma : maybeoperatorComma)
506
+ else return pass(noComma ? expressionNoComma : expression);
507
+ };
508
+ }
509
+ function target(_, value) {
510
+ if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorComma); }
511
+ }
512
+ function targetNoComma(_, value) {
513
+ if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorNoComma); }
514
+ }
515
+ function maybelabel(type) {
516
+ if (type == ":") return cont(poplex, statement);
517
+ return pass(maybeoperatorComma, expect(";"), poplex);
518
+ }
519
+ function property(type) {
520
+ if (type == "variable") {cx.marked = "property"; return cont();}
521
+ }
522
+ function objprop(type, value) {
523
+ if (type == "async") {
524
+ cx.marked = "property";
525
+ return cont(objprop);
526
+ } else if (type == "variable" || cx.style == "keyword") {
527
+ cx.marked = "property";
528
+ if (value == "get" || value == "set") return cont(getterSetter);
529
+ var m // Work around fat-arrow-detection complication for detecting typescript typed arrow params
530
+ if (isTS && cx.state.fatArrowAt == cx.stream.start && (m = cx.stream.match(/^\s*:\s*/, false)))
531
+ cx.state.fatArrowAt = cx.stream.pos + m[0].length
532
+ return cont(afterprop);
533
+ } else if (type == "number" || type == "string") {
534
+ cx.marked = jsonldMode ? "property" : (cx.style + " property");
535
+ return cont(afterprop);
536
+ } else if (type == "jsonld-keyword") {
537
+ return cont(afterprop);
538
+ } else if (isTS && isModifier(value)) {
539
+ cx.marked = "keyword"
540
+ return cont(objprop)
541
+ } else if (type == "[") {
542
+ return cont(expression, maybetype, expect("]"), afterprop);
543
+ } else if (type == "spread") {
544
+ return cont(expressionNoComma, afterprop);
545
+ } else if (value == "*") {
546
+ cx.marked = "keyword";
547
+ return cont(objprop);
548
+ } else if (type == ":") {
549
+ return pass(afterprop)
550
+ }
551
+ }
552
+ function getterSetter(type) {
553
+ if (type != "variable") return pass(afterprop);
554
+ cx.marked = "property";
555
+ return cont(functiondef);
556
+ }
557
+ function afterprop(type) {
558
+ if (type == ":") return cont(expressionNoComma);
559
+ if (type == "(") return pass(functiondef);
560
+ }
561
+ function commasep(what, end, sep) {
562
+ function proceed(type, value) {
563
+ if (sep ? sep.indexOf(type) > -1 : type == ",") {
564
+ var lex = cx.state.lexical;
565
+ if (lex.info == "call") lex.pos = (lex.pos || 0) + 1;
566
+ return cont(function(type, value) {
567
+ if (type == end || value == end) return pass()
568
+ return pass(what)
569
+ }, proceed);
570
+ }
571
+ if (type == end || value == end) return cont();
572
+ if (sep && sep.indexOf(";") > -1) return pass(what)
573
+ return cont(expect(end));
574
+ }
575
+ return function(type, value) {
576
+ if (type == end || value == end) return cont();
577
+ return pass(what, proceed);
578
+ };
579
+ }
580
+ function contCommasep(what, end, info) {
581
+ for (var i = 3; i < arguments.length; i++)
582
+ cx.cc.push(arguments[i]);
583
+ return cont(pushlex(end, info), commasep(what, end), poplex);
584
+ }
585
+ function block(type) {
586
+ if (type == "}") return cont();
587
+ return pass(statement, block);
588
+ }
589
+ function maybetype(type, value) {
590
+ if (isTS) {
591
+ if (type == ":") return cont(typeexpr);
592
+ if (value == "?") return cont(maybetype);
593
+ }
594
+ }
595
+ function maybetypeOrIn(type, value) {
596
+ if (isTS && (type == ":" || value == "in")) return cont(typeexpr)
597
+ }
598
+ function mayberettype(type) {
599
+ if (isTS && type == ":") {
600
+ if (cx.stream.match(/^\s*\w+\s+is\b/, false)) return cont(expression, isKW, typeexpr)
601
+ else return cont(typeexpr)
602
+ }
603
+ }
604
+ function isKW(_, value) {
605
+ if (value == "is") {
606
+ cx.marked = "keyword"
607
+ return cont()
608
+ }
609
+ }
610
+ function typeexpr(type, value) {
611
+ if (value == "keyof" || value == "typeof" || value == "infer" || value == "readonly") {
612
+ cx.marked = "keyword"
613
+ return cont(value == "typeof" ? expressionNoComma : typeexpr)
614
+ }
615
+ if (type == "variable" || value == "void") {
616
+ cx.marked = "type"
617
+ return cont(afterType)
618
+ }
619
+ if (value == "|" || value == "&") return cont(typeexpr)
620
+ if (type == "string" || type == "number" || type == "atom") return cont(afterType);
621
+ if (type == "[") return cont(pushlex("]"), commasep(typeexpr, "]", ","), poplex, afterType)
622
+ if (type == "{") return cont(pushlex("}"), typeprops, poplex, afterType)
623
+ if (type == "(") return cont(commasep(typearg, ")"), maybeReturnType, afterType)
624
+ if (type == "<") return cont(commasep(typeexpr, ">"), typeexpr)
625
+ if (type == "quasi") { return pass(quasiType, afterType); }
626
+ }
627
+ function maybeReturnType(type) {
628
+ if (type == "=>") return cont(typeexpr)
629
+ }
630
+ function typeprops(type) {
631
+ if (type.match(/[\}\)\]]/)) return cont()
632
+ if (type == "," || type == ";") return cont(typeprops)
633
+ return pass(typeprop, typeprops)
634
+ }
635
+ function typeprop(type, value) {
636
+ if (type == "variable" || cx.style == "keyword") {
637
+ cx.marked = "property"
638
+ return cont(typeprop)
639
+ } else if (value == "?" || type == "number" || type == "string") {
640
+ return cont(typeprop)
641
+ } else if (type == ":") {
642
+ return cont(typeexpr)
643
+ } else if (type == "[") {
644
+ return cont(expect("variable"), maybetypeOrIn, expect("]"), typeprop)
645
+ } else if (type == "(") {
646
+ return pass(functiondecl, typeprop)
647
+ } else if (!type.match(/[;\}\)\],]/)) {
648
+ return cont()
649
+ }
650
+ }
651
+ function quasiType(type, value) {
652
+ if (type != "quasi") return pass();
653
+ if (value.slice(value.length - 2) != "${") return cont(quasiType);
654
+ return cont(typeexpr, continueQuasiType);
655
+ }
656
+ function continueQuasiType(type) {
657
+ if (type == "}") {
658
+ cx.marked = "string-2";
659
+ cx.state.tokenize = tokenQuasi;
660
+ return cont(quasiType);
661
+ }
662
+ }
663
+ function typearg(type, value) {
664
+ if (type == "variable" && cx.stream.match(/^\s*[?:]/, false) || value == "?") return cont(typearg)
665
+ if (type == ":") return cont(typeexpr)
666
+ if (type == "spread") return cont(typearg)
667
+ return pass(typeexpr)
668
+ }
669
+ function afterType(type, value) {
670
+ if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
671
+ if (value == "|" || type == "." || value == "&") return cont(typeexpr)
672
+ if (type == "[") return cont(typeexpr, expect("]"), afterType)
673
+ if (value == "extends" || value == "implements") { cx.marked = "keyword"; return cont(typeexpr) }
674
+ if (value == "?") return cont(typeexpr, expect(":"), typeexpr)
675
+ }
676
+ function maybeTypeArgs(_, value) {
677
+ if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
678
+ }
679
+ function typeparam() {
680
+ return pass(typeexpr, maybeTypeDefault)
681
+ }
682
+ function maybeTypeDefault(_, value) {
683
+ if (value == "=") return cont(typeexpr)
684
+ }
685
+ function vardef(_, value) {
686
+ if (value == "enum") {cx.marked = "keyword"; return cont(enumdef)}
687
+ return pass(pattern, maybetype, maybeAssign, vardefCont);
688
+ }
689
+ function pattern(type, value) {
690
+ if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(pattern) }
691
+ if (type == "variable") { register(value); return cont(); }
692
+ if (type == "spread") return cont(pattern);
693
+ if (type == "[") return contCommasep(eltpattern, "]");
694
+ if (type == "{") return contCommasep(proppattern, "}");
695
+ }
696
+ function proppattern(type, value) {
697
+ if (type == "variable" && !cx.stream.match(/^\s*:/, false)) {
698
+ register(value);
699
+ return cont(maybeAssign);
700
+ }
701
+ if (type == "variable") cx.marked = "property";
702
+ if (type == "spread") return cont(pattern);
703
+ if (type == "}") return pass();
704
+ if (type == "[") return cont(expression, expect(']'), expect(':'), proppattern);
705
+ return cont(expect(":"), pattern, maybeAssign);
706
+ }
707
+ function eltpattern() {
708
+ return pass(pattern, maybeAssign)
709
+ }
710
+ function maybeAssign(_type, value) {
711
+ if (value == "=") return cont(expressionNoComma);
712
+ }
713
+ function vardefCont(type) {
714
+ if (type == ",") return cont(vardef);
715
+ }
716
+ function maybeelse(type, value) {
717
+ if (type == "keyword b" && value == "else") return cont(pushlex("form", "else"), statement, poplex);
718
+ }
719
+ function forspec(type, value) {
720
+ if (value == "await") return cont(forspec);
721
+ if (type == "(") return cont(pushlex(")"), forspec1, poplex);
722
+ }
723
+ function forspec1(type) {
724
+ if (type == "var") return cont(vardef, forspec2);
725
+ if (type == "variable") return cont(forspec2);
726
+ return pass(forspec2)
727
+ }
728
+ function forspec2(type, value) {
729
+ if (type == ")") return cont()
730
+ if (type == ";") return cont(forspec2)
731
+ if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression, forspec2) }
732
+ return pass(expression, forspec2)
733
+ }
734
+ function functiondef(type, value) {
735
+ if (value == "*") {cx.marked = "keyword"; return cont(functiondef);}
736
+ if (type == "variable") {register(value); return cont(functiondef);}
737
+ if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, statement, popcontext);
738
+ if (isTS && value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, functiondef)
739
+ }
740
+ function functiondecl(type, value) {
741
+ if (value == "*") {cx.marked = "keyword"; return cont(functiondecl);}
742
+ if (type == "variable") {register(value); return cont(functiondecl);}
743
+ if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, popcontext);
744
+ if (isTS && value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, functiondecl)
745
+ }
746
+ function typename(type, value) {
747
+ if (type == "keyword" || type == "variable") {
748
+ cx.marked = "type"
749
+ return cont(typename)
750
+ } else if (value == "<") {
751
+ return cont(pushlex(">"), commasep(typeparam, ">"), poplex)
752
+ }
753
+ }
754
+ function funarg(type, value) {
755
+ if (value == "@") cont(expression, funarg)
756
+ if (type == "spread") return cont(funarg);
757
+ if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(funarg); }
758
+ if (isTS && type == "this") return cont(maybetype, maybeAssign)
759
+ return pass(pattern, maybetype, maybeAssign);
760
+ }
761
+ function classExpression(type, value) {
762
+ // Class expressions may have an optional name.
763
+ if (type == "variable") return className(type, value);
764
+ return classNameAfter(type, value);
765
+ }
766
+ function className(type, value) {
767
+ if (type == "variable") {register(value); return cont(classNameAfter);}
768
+ }
769
+ function classNameAfter(type, value) {
770
+ if (value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, classNameAfter)
771
+ if (value == "extends" || value == "implements" || (isTS && type == ",")) {
772
+ if (value == "implements") cx.marked = "keyword";
773
+ return cont(isTS ? typeexpr : expression, classNameAfter);
774
+ }
775
+ if (type == "{") return cont(pushlex("}"), classBody, poplex);
776
+ }
777
+ function classBody(type, value) {
778
+ if (type == "async" ||
779
+ (type == "variable" &&
780
+ (value == "static" || value == "get" || value == "set" || (isTS && isModifier(value))) &&
781
+ cx.stream.match(/^\s+[\w$\xa1-\uffff]/, false))) {
782
+ cx.marked = "keyword";
783
+ return cont(classBody);
784
+ }
785
+ if (type == "variable" || cx.style == "keyword") {
786
+ cx.marked = "property";
787
+ return cont(classfield, classBody);
788
+ }
789
+ if (type == "number" || type == "string") return cont(classfield, classBody);
790
+ if (type == "[")
791
+ return cont(expression, maybetype, expect("]"), classfield, classBody)
792
+ if (value == "*") {
793
+ cx.marked = "keyword";
794
+ return cont(classBody);
795
+ }
796
+ if (isTS && type == "(") return pass(functiondecl, classBody)
797
+ if (type == ";" || type == ",") return cont(classBody);
798
+ if (type == "}") return cont();
799
+ if (value == "@") return cont(expression, classBody)
800
+ }
801
+ function classfield(type, value) {
802
+ if (value == "!") return cont(classfield)
803
+ if (value == "?") return cont(classfield)
804
+ if (type == ":") return cont(typeexpr, maybeAssign)
805
+ if (value == "=") return cont(expressionNoComma)
806
+ var context = cx.state.lexical.prev, isInterface = context && context.info == "interface"
807
+ return pass(isInterface ? functiondecl : functiondef)
808
+ }
809
+ function afterExport(type, value) {
810
+ if (value == "*") { cx.marked = "keyword"; return cont(maybeFrom, expect(";")); }
811
+ if (value == "default") { cx.marked = "keyword"; return cont(expression, expect(";")); }
812
+ if (type == "{") return cont(commasep(exportField, "}"), maybeFrom, expect(";"));
813
+ return pass(statement);
814
+ }
815
+ function exportField(type, value) {
816
+ if (value == "as") { cx.marked = "keyword"; return cont(expect("variable")); }
817
+ if (type == "variable") return pass(expressionNoComma, exportField);
818
+ }
819
+ function afterImport(type) {
820
+ if (type == "string") return cont();
821
+ if (type == "(") return pass(expression);
822
+ if (type == ".") return pass(maybeoperatorComma);
823
+ return pass(importSpec, maybeMoreImports, maybeFrom);
824
+ }
825
+ function importSpec(type, value) {
826
+ if (type == "{") return contCommasep(importSpec, "}");
827
+ if (type == "variable") register(value);
828
+ if (value == "*") cx.marked = "keyword";
829
+ return cont(maybeAs);
830
+ }
831
+ function maybeMoreImports(type) {
832
+ if (type == ",") return cont(importSpec, maybeMoreImports)
833
+ }
834
+ function maybeAs(_type, value) {
835
+ if (value == "as") { cx.marked = "keyword"; return cont(importSpec); }
836
+ }
837
+ function maybeFrom(_type, value) {
838
+ if (value == "from") { cx.marked = "keyword"; return cont(expression); }
839
+ }
840
+ function arrayLiteral(type) {
841
+ if (type == "]") return cont();
842
+ return pass(commasep(expressionNoComma, "]"));
843
+ }
844
+ function enumdef() {
845
+ return pass(pushlex("form"), pattern, expect("{"), pushlex("}"), commasep(enummember, "}"), poplex, poplex)
846
+ }
847
+ function enummember() {
848
+ return pass(pattern, maybeAssign);
849
+ }
850
+
851
+ function isContinuedStatement(state, textAfter) {
852
+ return state.lastType == "operator" || state.lastType == "," ||
853
+ isOperatorChar.test(textAfter.charAt(0)) ||
854
+ /[,.]/.test(textAfter.charAt(0));
855
+ }
856
+
857
+ function expressionAllowed(stream, state, backUp) {
858
+ return state.tokenize == tokenBase &&
859
+ /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
860
+ (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
861
+ }
862
+
863
+ // Interface
864
+
865
+ return {
866
+ startState: function(basecolumn) {
867
+ var state = {
868
+ tokenize: tokenBase,
869
+ lastType: "sof",
870
+ cc: [],
871
+ lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
872
+ localVars: parserConfig.localVars,
873
+ context: parserConfig.localVars && new Context(null, null, false),
874
+ indented: basecolumn || 0
875
+ };
876
+ if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
877
+ state.globalVars = parserConfig.globalVars;
878
+ return state;
879
+ },
880
+
881
+ token: function(stream, state) {
882
+ if (stream.sol()) {
883
+ if (!state.lexical.hasOwnProperty("align"))
884
+ state.lexical.align = false;
885
+ state.indented = stream.indentation();
886
+ findFatArrow(stream, state);
887
+ }
888
+ if (state.tokenize != tokenComment && stream.eatSpace()) return null;
889
+ var style = state.tokenize(stream, state);
890
+ if (type == "comment") return style;
891
+ state.lastType = type == "operator" && (content == "++" || content == "--") ? "incdec" : type;
892
+ return parseJS(state, style, type, content, stream);
893
+ },
894
+
895
+ indent: function(state, textAfter) {
896
+ if (state.tokenize == tokenComment || state.tokenize == tokenQuasi) return CodeMirror.Pass;
897
+ if (state.tokenize != tokenBase) return 0;
898
+ var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top
899
+ // Kludge to prevent 'maybelse' from blocking lexical scope pops
900
+ if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {
901
+ var c = state.cc[i];
902
+ if (c == poplex) lexical = lexical.prev;
903
+ else if (c != maybeelse && c != popcontext) break;
904
+ }
905
+ while ((lexical.type == "stat" || lexical.type == "form") &&
906
+ (firstChar == "}" || ((top = state.cc[state.cc.length - 1]) &&
907
+ (top == maybeoperatorComma || top == maybeoperatorNoComma) &&
908
+ !/^[,\.=+\-*:?[\(]/.test(textAfter))))
909
+ lexical = lexical.prev;
910
+ if (statementIndent && lexical.type == ")" && lexical.prev.type == "stat")
911
+ lexical = lexical.prev;
912
+ var type = lexical.type, closing = firstChar == type;
913
+
914
+ if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info.length + 1 : 0);
915
+ else if (type == "form" && firstChar == "{") return lexical.indented;
916
+ else if (type == "form") return lexical.indented + indentUnit;
917
+ else if (type == "stat")
918
+ return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);
919
+ else if (lexical.info == "switch" && !closing && parserConfig.doubleIndentSwitch != false)
920
+ return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
921
+ else if (lexical.align) return lexical.column + (closing ? 0 : 1);
922
+ else return lexical.indented + (closing ? 0 : indentUnit);
923
+ },
924
+
925
+ electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
926
+ blockCommentStart: jsonMode ? null : "/*",
927
+ blockCommentEnd: jsonMode ? null : "*/",
928
+ blockCommentContinue: jsonMode ? null : " * ",
929
+ lineComment: jsonMode ? null : "//",
930
+ fold: "brace",
931
+ closeBrackets: "()[]{}''\"\"``",
932
+
933
+ helperType: jsonMode ? "json" : "javascript",
934
+ jsonldMode: jsonldMode,
935
+ jsonMode: jsonMode,
936
+
937
+ expressionAllowed: expressionAllowed,
938
+
939
+ skipExpression: function(state) {
940
+ parseJS(state, "atom", "atom", "true", new CodeMirror.StringStream("", 2, null))
941
+ }
942
+ };
943
+ });
944
+
945
+ CodeMirror.registerHelper("wordChars", "javascript", /[\w$]/);
946
+
947
+ CodeMirror.defineMIME("text/javascript", "javascript");
948
+ CodeMirror.defineMIME("text/ecmascript", "javascript");
949
+ CodeMirror.defineMIME("application/javascript", "javascript");
950
+ CodeMirror.defineMIME("application/x-javascript", "javascript");
951
+ CodeMirror.defineMIME("application/ecmascript", "javascript");
952
+ CodeMirror.defineMIME("application/json", { name: "javascript", json: true });
953
+ CodeMirror.defineMIME("application/x-json", { name: "javascript", json: true });
954
+ CodeMirror.defineMIME("application/manifest+json", { name: "javascript", json: true })
955
+ CodeMirror.defineMIME("application/ld+json", { name: "javascript", jsonld: true });
956
+ CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true });
957
+ CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true });
958
+
959
+ });