Head and Footer Scripts Inserter - Version 4.21

Version Description

  • CodeMirror library updated to the latest version v5.38.0. The directory structure is changed (files are better organized). Added a test files for the CodeMirror modes.
  • Updated the method of loading the modes and addons of the CodeMirror library.
Download this release

Release Info

Developer Arthur Gareginyan
Plugin Icon 128x128 Head and Footer Scripts Inserter
Version 4.21
Comparing to
See all releases

Code changes from version 4.20 to 4.21

Files changed (34) hide show
  1. header-and-footer-scripts-inserter.php +1 -1
  2. inc/lib/codemirror/AUTHORS +748 -0
  3. inc/lib/codemirror/CHANGELOG.md +1412 -0
  4. inc/lib/codemirror/CONTRIBUTING.md +92 -0
  5. inc/lib/codemirror/LICENSE +3 -1
  6. inc/lib/codemirror/README.md +22 -1
  7. inc/lib/codemirror/{addons → addon/selection}/active-line.js +11 -13
  8. inc/lib/codemirror/codemirror.js +0 -8935
  9. inc/lib/codemirror/{codemirror.css → lib/codemirror.css} +19 -20
  10. inc/lib/codemirror/lib/codemirror.js +9685 -0
  11. inc/lib/codemirror/mode/{css.js → css/css.js} +36 -29
  12. inc/lib/codemirror/mode/css/gss.html +103 -0
  13. inc/lib/codemirror/mode/css/gss_test.js +17 -0
  14. inc/lib/codemirror/mode/css/index.html +75 -0
  15. inc/lib/codemirror/mode/css/less.html +152 -0
  16. inc/lib/codemirror/mode/css/less_test.js +54 -0
  17. inc/lib/codemirror/mode/css/scss.html +157 -0
  18. inc/lib/codemirror/mode/css/scss_test.js +110 -0
  19. inc/lib/codemirror/mode/css/test.js +209 -0
  20. inc/lib/codemirror/mode/{htmlmixed.js → htmlmixed/htmlmixed.js} +4 -4
  21. inc/lib/codemirror/mode/htmlmixed/index.html +100 -0
  22. inc/lib/codemirror/mode/index.html +165 -0
  23. inc/lib/codemirror/mode/javascript/index.html +114 -0
  24. inc/lib/codemirror/mode/{javascript.js → javascript/javascript.js} +289 -136
  25. inc/lib/codemirror/mode/javascript/json-ld.html +72 -0
  26. inc/lib/codemirror/mode/javascript/test.js +482 -0
  27. inc/lib/codemirror/mode/javascript/typescript.html +61 -0
  28. inc/lib/codemirror/mode/meta.js +217 -0
  29. inc/lib/codemirror/mode/xml/index.html +61 -0
  30. inc/lib/codemirror/mode/xml/test.js +51 -0
  31. inc/lib/codemirror/mode/{xml.js → xml/xml.js} +7 -0
  32. inc/lib/codemirror/package.json +49 -0
  33. inc/php/enqueue.php +10 -7
  34. readme.txt +6 -2
header-and-footer-scripts-inserter.php CHANGED
@@ -5,7 +5,7 @@
5
  * Description: Easily add your scripts to the WordPress website's head and footer sections. This is a must have tool for authors and website's owners.
6
  * Author: Space X-Chimp
7
  * Author URI: https://www.spacexchimp.com
8
- * Version: 4.20
9
  * License: GPL3
10
  * Text Domain: header-and-footer-scripts-inserter
11
  * Domain Path: /languages/
5
  * Description: Easily add your scripts to the WordPress website's head and footer sections. This is a must have tool for authors and website's owners.
6
  * Author: Space X-Chimp
7
  * Author URI: https://www.spacexchimp.com
8
+ * Version: 4.21
9
  * License: GPL3
10
  * Text Domain: header-and-footer-scripts-inserter
11
  * Domain Path: /languages/
inc/lib/codemirror/AUTHORS ADDED
@@ -0,0 +1,748 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ List of CodeMirror contributors. Updated before every release.
2
+
3
+ 4oo4
4
+ 4r2r
5
+ Aaron Brooks
6
+ Abdelouahab
7
+ Abe Fettig
8
+ Adam Ahmed
9
+ Adam King
10
+ Adam Particka
11
+ adanlobato
12
+ Adán Lobato
13
+ Adrian Aichner
14
+ Adrian Heine
15
+ Adrien Bertrand
16
+ aeroson
17
+ Ahmad Amireh
18
+ Ahmad M. Zawawi
19
+ ahoward
20
+ Akeksandr Motsjonov
21
+ Alasdair Smith
22
+ Alberto González Palomo
23
+ Alberto Pose
24
+ Albert Xing
25
+ Alexander Pavlov
26
+ Alexander Schepanovski
27
+ Alexander Shvets
28
+ Alexander Solovyov
29
+ Alexandre Bique
30
+ alexey-k
31
+ Alex Piggott
32
+ Aliaksei Chapyzhenka
33
+ Allen Sarkisyan
34
+ Ami Fischman
35
+ Amin Shali
36
+ Amin Ullah Khan
37
+ amshali@google.com
38
+ Amsul
39
+ amuntean
40
+ Amy
41
+ Ananya Sen
42
+ anaran
43
+ AndersMad
44
+ Anders Nawroth
45
+ Anderson Mesquita
46
+ Anders Wåglund
47
+ Andrea G
48
+ Andreas Reischuck
49
+ Andres Taylor
50
+ Andre von Houck
51
+ Andrew Cheng
52
+ Andrew Dassonville
53
+ Andrey Fedorov
54
+ Andrey Klyuchnikov
55
+ Andrey Lushnikov
56
+ Andrey Shchekin
57
+ Andy Joslin
58
+ Andy Kimball
59
+ Andy Li
60
+ Angelo
61
+ angelozerr
62
+ angelo.zerr@gmail.com
63
+ Ankit
64
+ Ankit Ahuja
65
+ Ansel Santosa
66
+ Anthony Dugois
67
+ anthonygego
68
+ Anthony Gégo
69
+ Anthony Grimes
70
+ Anton Kovalyov
71
+ Apollo Zhu
72
+ AQNOUCH Mohammed
73
+ Aram Shatakhtsyan
74
+ areos
75
+ Arnab Bose
76
+ Arsène von Wyss
77
+ Arthur Müller
78
+ Arun Narasani
79
+ as3boyan
80
+ asolove
81
+ atelierbram
82
+ AtomicPages LLC
83
+ Atul Bhouraskar
84
+ Aurelian Oancea
85
+ Axel Lewenhaupt
86
+ Barret Rennie
87
+ Basarat Ali Syed
88
+ Bastian Müller
89
+ belhaj
90
+ Bem Jones-Bey
91
+ benbro
92
+ Beni Cherniavsky-Paskin
93
+ Benjamin DeCoste
94
+ Benjamin Young
95
+ Ben Keen
96
+ Ben Miller
97
+ Ben Mosher
98
+ Bernhard Sirlinger
99
+ Bert Chang
100
+ Bharad
101
+ BigBlueHat
102
+ Billy Moon
103
+ binny
104
+ B Krishna Chaitanya
105
+ Blaine G
106
+ blukat29
107
+ Bo
108
+ boomyjee
109
+ Bo Peng
110
+ borawjm
111
+ Brad Metcalf
112
+ Brandon Frohs
113
+ Brandon Wamboldt
114
+ Bret Little
115
+ Brett Zamir
116
+ Brian Grinstead
117
+ Brian Sletten
118
+ brrd
119
+ Bruce Mitchener
120
+ Bryan Massoth
121
+ Caitlin Potter
122
+ Calin Barbat
123
+ callodacity
124
+ Camilo Roca
125
+ Casey Klebba
126
+ César González Íñiguez
127
+ Chad Jolly
128
+ Chandra Sekhar Pydi
129
+ Charles Skelton
130
+ Cheah Chu Yeow
131
+ Chris Coyier
132
+ Chris Ford
133
+ Chris Granger
134
+ Chris Houseknecht
135
+ Chris Lohfink
136
+ Chris Morgan
137
+ Chris Reeves
138
+ Chris Smith
139
+ Christian Gruen
140
+ Christian Oyarzun
141
+ Christian Petrov
142
+ christopherblaser
143
+ Christopher Brown
144
+ Christopher Kramer
145
+ Christopher Mitchell
146
+ Christopher Pfohl
147
+ Chunliang Lyu
148
+ ciaranj
149
+ CodeAnimal
150
+ CodeBitt
151
+ coderaiser
152
+ Cole R Lawrence
153
+ ComFreek
154
+ Cristian Prieto
155
+ Curtis Gagliardi
156
+ dagsta
157
+ daines
158
+ Dale Jung
159
+ Dan Bentley
160
+ Dan Heberden
161
+ Daniel, Dao Quang Minh
162
+ Daniele Di Sarli
163
+ Daniel Faust
164
+ Daniel Huigens
165
+ Daniel Kesler
166
+ Daniel KJ
167
+ Daniel Neel
168
+ Daniel Parnell
169
+ Daniel Thwaites
170
+ Danila Malyutin
171
+ Danny Yoo
172
+ darealshinji
173
+ Darius Roberts
174
+ Dave Brondsema
175
+ Dave Myers
176
+ David Barnett
177
+ David H. Bronke
178
+ David Mignot
179
+ David Pathakjee
180
+ David Vázquez
181
+ David Whittington
182
+ deebugger
183
+ Deep Thought
184
+ Devin Abbott
185
+ Devon Carew
186
+ Dick Choi
187
+ dignifiedquire
188
+ Dimage Sapelkin
189
+ Dmitry Kiselyov
190
+ domagoj412
191
+ Dominator008
192
+ Domizio Demichelis
193
+ Doug Wikle
194
+ Drew Bratcher
195
+ Drew Hintz
196
+ Drew Khoury
197
+ Drini Cami
198
+ Dror BG
199
+ duralog
200
+ dwelle
201
+ eborden
202
+ edsharp
203
+ ekhaled
204
+ Elisée
205
+ Emmanuel Schanzer
206
+ Enam Mijbah Noor
207
+ Eric Allam
208
+ Eric Bogard
209
+ Erik Welander
210
+ eustas
211
+ Fabien Dubosson
212
+ Fabien O'Carroll
213
+ Fabio Zendhi Nagao
214
+ Faiza Alsaied
215
+ Fauntleroy
216
+ fbuchinger
217
+ feizhang365
218
+ Felipe Lalanne
219
+ Felix Raab
220
+ ficristo
221
+ Filip Noetzel
222
+ Filip Stollár
223
+ Filype Pereira
224
+ flack
225
+ Florian Felten
226
+ ForbesLindesay
227
+ Forbes Lindesay
228
+ Ford_Lawnmower
229
+ Forrest Oliphant
230
+ Franco Catena
231
+ Frank Wiegand
232
+ Fredrik Borg
233
+ Gabriel Gheorghian
234
+ Gabriel Horner
235
+ Gabriel Nahmias
236
+ galambalazs
237
+ Gary Sheng
238
+ Gautam Mehta
239
+ Gavin Douglas
240
+ gekkoe
241
+ Geordie Hall
242
+ George Stephanis
243
+ geowarin
244
+ Gerard Braad
245
+ Gergely Hegykozi
246
+ Giovanni Calò
247
+ Glebov Boris
248
+ Glenn Jorde
249
+ Glenn Ruehle
250
+ goldsmcb
251
+ Golevka
252
+ Google Inc.
253
+ Gordon Smith
254
+ Grant Skinner
255
+ greengiant
256
+ Gregory Koberger
257
+ Grzegorz Mazur
258
+ Guan Gui
259
+ Guillaume Massé
260
+ Guillaume Massé
261
+ guraga
262
+ Gustavo Rodrigues
263
+ Hakan Tunc
264
+ Hans Engel
265
+ Hardest
266
+ Harshvardhan Gupta
267
+ Hasan Karahan
268
+ Heanes
269
+ Hector Oswaldo Caballero
270
+ Hélio
271
+ Hendrik Wallbaum
272
+ Henrik Haugbølle
273
+ Herculano Campos
274
+ hidaiy
275
+ Hiroyuki Makino
276
+ hitsthings
277
+ Hocdoc
278
+ Hugues Malphettes
279
+ Ian Beck
280
+ Ian Davies
281
+ Ian Dickinson
282
+ Ian Rose
283
+ Ian Wehrman
284
+ Ian Wetherbee
285
+ Ice White
286
+ ICHIKAWA, Yuji
287
+ idleberg
288
+ ilvalle
289
+ Ingo Richter
290
+ Irakli Gozalishvili
291
+ Ivan Kurnosov
292
+ Ivoah
293
+ Jacob Lee
294
+ Jaimin
295
+ Jake Peyser
296
+ Jakob Miland
297
+ Jakub Vrana
298
+ Jakub Vrána
299
+ James Campos
300
+ James Howard
301
+ James Thorne
302
+ Jamie Hill
303
+ Jamie Morris
304
+ Jan Jongboom
305
+ jankeromnes
306
+ Jan Keromnes
307
+ Jan Odvarko
308
+ Jan Schär
309
+ Jan T. Sott
310
+ Jared Dean
311
+ Jared Forsyth
312
+ Jared Jacobs
313
+ Jason
314
+ Jason Barnabe
315
+ Jason Grout
316
+ Jason Johnston
317
+ Jason San Jose
318
+ Jason Siefken
319
+ Jayaprabhakar
320
+ Jaydeep Solanki
321
+ Jean Boussier
322
+ Jeff Blaisdell
323
+ Jeff Hanke
324
+ Jeff Jenkins
325
+ jeffkenton
326
+ Jeff Pickhardt
327
+ jem (graphite)
328
+ Jeremy Parmenter
329
+ Jim
330
+ Jim Avery
331
+ jkaplon
332
+ JobJob
333
+ jochenberger
334
+ Jochen Berger
335
+ Joel Einbinder
336
+ joelpinheiro
337
+ Johan Ask
338
+ John Connor
339
+ John-David Dalton
340
+ John Engler
341
+ John Lees-Miller
342
+ John Snelson
343
+ John Van Der Loo
344
+ Jon Ander Peñalba
345
+ Jonas Döbertin
346
+ Jonas Helfer
347
+ Jonathan Hart
348
+ Jonathan Malmaud
349
+ Jon Gacnik
350
+ jongalloway
351
+ Jon Malmaud
352
+ Jon Sangster
353
+ Joost-Wim Boekesteijn
354
+ Joseph Pecoraro
355
+ Josh Barnes
356
+ Josh Cohen
357
+ Josh Soref
358
+ Joshua Newman
359
+ Josh Watzman
360
+ jots
361
+ jsoojeon
362
+ ju1ius
363
+ Juan Benavides Romero
364
+ Jucovschi Constantin
365
+ Juho Vuori
366
+ Julien CROUZET
367
+ Julien Rebetez
368
+ Justin Andresen
369
+ Justin Hileman
370
+ jwallers@gmail.com
371
+ kaniga
372
+ karevn
373
+ Karol
374
+ Kayur Patel
375
+ Kazuhito Hokamura
376
+ Ken Newman
377
+ ken restivo
378
+ Ken Rockot
379
+ Kevin Earls
380
+ Kevin Kwok
381
+ Kevin Muret
382
+ Kevin Sawicki
383
+ Kevin Ushey
384
+ Klaus Silveira
385
+ Koh Zi Han, Cliff
386
+ komakino
387
+ Konstantin Lopuhin
388
+ koops
389
+ Kris Ciccarello
390
+ ks-ifware
391
+ kubelsmieci
392
+ KwanEsq
393
+ Kyle Kelley
394
+ KyleMcNutt
395
+ Lanfei
396
+ Lanny
397
+ Laszlo Vidacs
398
+ leaf corcoran
399
+ Lemmon
400
+ Leonid Khachaturov
401
+ Leon Sorokin
402
+ Leonya Khachaturov
403
+ Liam Newman
404
+ Libo Cannici
405
+ Lior Goldberg
406
+ Lior Shub
407
+ LloydMilligan
408
+ LM
409
+ lochel
410
+ Lorenzo Stoakes
411
+ Louis Mauchet
412
+ Luca Fabbri
413
+ Luciano Longo
414
+ Lu Fangjian
415
+ Luke Browning
416
+ Luke Granger-Brown
417
+ Luke Stagner
418
+ lynschinzer
419
+ M1cha
420
+ Madhura Jayaratne
421
+ Maksim Lin
422
+ Maksym Taran
423
+ Malay Majithia
424
+ Manideep
425
+ Manuel Rego Casasnovas
426
+ Marat Dreizin
427
+ Marcel Gerber
428
+ Marcelo Camargo
429
+ Marco Aurélio
430
+ Marco Munizaga
431
+ Marcus Bointon
432
+ Marek Rudnicki
433
+ Marijn Haverbeke
434
+ Mário Gonçalves
435
+ Mario Pietsch
436
+ Mark Anderson
437
+ Mark Lentczner
438
+ Marko Bonaci
439
+ Mark Peace
440
+ Markus Bordihn
441
+ Markus Olsson
442
+ Martin Balek
443
+ Martín Gaitán
444
+ Martin Hasoň
445
+ Martin Hunt
446
+ Martin Laine
447
+ Martin Zagora
448
+ Mason Malone
449
+ Mateusz Paprocki
450
+ Mathias Bynens
451
+ mats cronqvist
452
+ Matt Gaide
453
+ Matthew Bauer
454
+ Matthew Beale
455
+ matthewhayes
456
+ Matthew Rathbone
457
+ Matthias Bussonnier
458
+ Matthias BUSSONNIER
459
+ Matt MacPherson
460
+ Matt McDonald
461
+ Matt Pass
462
+ Matt Sacks
463
+ mauricio
464
+ Maximilian Hils
465
+ Maxim Kraev
466
+ Max Kirsch
467
+ Max Schaefer
468
+ Max Xiantu
469
+ mbarkhau
470
+ McBrainy
471
+ mce2
472
+ melpon
473
+ meshuamam
474
+ Metatheos
475
+ Micah Dubinko
476
+ Michael
477
+ Michael Goderbauer
478
+ Michael Grey
479
+ Michael Kaminsky
480
+ Michael Lehenbauer
481
+ Michael Walker
482
+ Michael Zhou
483
+ Michal Čihař
484
+ Michal Dorner
485
+ Michal Kapiczynski
486
+ Mighty Guava
487
+ Miguel Castillo
488
+ mihailik
489
+ Mike
490
+ Mike Brevoort
491
+ Mike Diaz
492
+ Mike Ivanov
493
+ Mike Kadin
494
+ Mike Kobit
495
+ Milan Szekely
496
+ MinRK
497
+ Miraculix87
498
+ misfo
499
+ mkaminsky11
500
+ mloginov
501
+ Moritz Schubotz (physikerwelt)
502
+ Moritz Schwörer
503
+ Moshe Wajnberg
504
+ mps
505
+ ms
506
+ mtaran-google
507
+ Mu-An Chiou
508
+ Mu-An ✌️ Chiou
509
+ mzabuawala
510
+ Narciso Jaramillo
511
+ Nathan Williams
512
+ ndr
513
+ Neil Anderson
514
+ neon-dev
515
+ nerbert
516
+ NetworkNode
517
+ nextrevision
518
+ ngn
519
+ nguillaumin
520
+ Ng Zhi An
521
+ Nicholas Bollweg
522
+ Nicholas Bollweg (Nick)
523
+ NickKolok
524
+ Nick Kreeger
525
+ Nick Small
526
+ Nicolas Kick
527
+ Nicolò Ribaudo
528
+ Niels van Groningen
529
+ nightwing
530
+ Nikita Beloglazov
531
+ Nikita Vasilyev
532
+ Nikolay Kostov
533
+ nilp0inter
534
+ Nisarg Jhaveri
535
+ nlwillia
536
+ noragrossman
537
+ Norman Rzepka
538
+ opl-
539
+ Oreoluwa Onatemowo
540
+ Oskar Segersvärd
541
+ overdodactyl
542
+ pablo
543
+ pabloferz
544
+ Pablo Zubieta
545
+ paddya
546
+ Page
547
+ paladox
548
+ Panupong Pasupat
549
+ paris
550
+ Paris
551
+ Paris Kasidiaris
552
+ Patil Arpith
553
+ Patrick Stoica
554
+ Patrick Strawderman
555
+ Paul Garvin
556
+ Paul Ivanov
557
+ Paul Masson
558
+ Pavel
559
+ Pavel Feldman
560
+ Pavel Petržela
561
+ Pavel Strashkin
562
+ Paweł Bartkiewicz
563
+ peteguhl
564
+ peter
565
+ Peter Flynn
566
+ peterkroon
567
+ Peter Kroon
568
+ Philipp A
569
+ Philip Stadermann
570
+ Pi Delport
571
+ Pierre Gerold
572
+ Pieter Ouwerkerk
573
+ Pontus Melke
574
+ prasanthj
575
+ Prasanth J
576
+ Prayag Verma
577
+ Prendota
578
+ Qiang Li
579
+ Radek Piórkowski
580
+ Rahul
581
+ Rahul Anand
582
+ ramwin1
583
+ Randall Mason
584
+ Randy Burden
585
+ Randy Edmunds
586
+ Randy Luecke
587
+ Raphael Amorim
588
+ Rasmus Erik Voel Jensen
589
+ Rasmus Schultz
590
+ Raymond Hill
591
+ ray ratchup
592
+ Ray Ratchup
593
+ Remi Nyborg
594
+ Renaud Durlin
595
+ Richard Denton
596
+ Richard van der Meer
597
+ Richard Z.H. Wang
598
+ Rishi Goomar
599
+ Robert Brignull
600
+ Robert Crossfield
601
+ Roberto Abdelkader Martínez Pérez
602
+ robertop23
603
+ Robert Plummer
604
+ Rrandom
605
+ Rrrandom
606
+ Ruslan Osmanov
607
+ Ryan Petrello
608
+ Ryan Prior
609
+ ryu-sato
610
+ sabaca
611
+ Sam Lee
612
+ Sam Rawlins
613
+ Samuel Ainsworth
614
+ Sam Wilson
615
+ sandeepshetty
616
+ Sander AKA Redsandro
617
+ Sander Verweij
618
+ santec
619
+ Sarah McAlear and Wenlin Zhang
620
+ Sascha Peilicke
621
+ satamas
622
+ satchmorun
623
+ sathyamoorthi
624
+ Saul Costa
625
+ S. Chris Colbert
626
+ SCLINIC\jdecker
627
+ Scott Aikin
628
+ Scott Goodhew
629
+ Sebastian Wilzbach
630
+ Sebastian Zaha
631
+ Sergey Goder
632
+ Sergey Tselovalnikov
633
+ Se-Won Kim
634
+ Shane Liesegang
635
+ shaund
636
+ shaun gilchrist
637
+ Shawn A
638
+ Shea Bunge
639
+ sheopory
640
+ Shil S
641
+ Shiv Deepak
642
+ Shmuel Englard
643
+ Shubham Jain
644
+ Siamak Mokhtari
645
+ silverwind
646
+ Simon Edwards
647
+ sinkuu
648
+ snasa
649
+ soliton4
650
+ sonson
651
+ Sorab Bisht
652
+ spastorelli
653
+ srajanpaliwal
654
+ Stanislav Oaserele
655
+ stan-z
656
+ Stas Kobzar
657
+ Stefan Borsje
658
+ Steffen Beyer
659
+ Steffen Bruchmann
660
+ Steffen Kowalski
661
+ Stephane Moore
662
+ Stephen Lavelle
663
+ Steve Champagne
664
+ Steve Hoover
665
+ Steve O'Hara
666
+ stoskov
667
+ Stu Kennedy
668
+ Sungho Kim
669
+ sverweij
670
+ Taha Jahangir
671
+ takamori
672
+ Tako Schotanus
673
+ Takuji Shimokawa
674
+ Takuya Matsuyama
675
+ Tarmil
676
+ TDaglis
677
+ tel
678
+ Tentone
679
+ tfjgeorge
680
+ Thaddee Tyl
681
+ thanasis
682
+ TheHowl
683
+ themrmax
684
+ think
685
+ Thomas Brouard
686
+ Thomas Dvornik
687
+ Thomas Kluyver
688
+ Thomas Schmid
689
+ Tim Alby
690
+ Tim Baumann
691
+ Timothy Farrell
692
+ Timothy Gu
693
+ Timothy Hatcher
694
+ Tobias Bertelsen
695
+ TobiasBg
696
+ Todd Berman
697
+ Todd Kennedy
698
+ Tomas-A
699
+ Tomas Varaneckas
700
+ Tom Erik Støwer
701
+ Tom Klancer
702
+ Tom MacWright
703
+ Tom McLaughlin
704
+ Tony Jian
705
+ tophf
706
+ totalamd
707
+ Travis Heppe
708
+ Triangle717
709
+ Tristan Tarrant
710
+ TSUYUSATO Kitsune
711
+ Tugrul Elmas
712
+ twifkak
713
+ Tyler Long
714
+ Vadzim Ramanenka
715
+ Vaibhav Sagar
716
+ VapidWorx
717
+ Vestimir Markov
718
+ vf
719
+ Victor Bocharsky
720
+ Vincent Woo
721
+ Volker Mische
722
+ vtripolitakis
723
+ Weiyan Shao
724
+ wenli
725
+ Wes Cossick
726
+ Wesley Wiser
727
+ Weston Ruter
728
+ Will Binns-Smith
729
+ Will Dean
730
+ William Jamieson
731
+ William Stein
732
+ Willy
733
+ Wojtek Ptak
734
+ wonderboyjon
735
+ Wu Cheng-Han
736
+ Xavier Mendez
737
+ Yassin N. Hassan
738
+ YNH Webdev
739
+ Yunchi Luo
740
+ Yuvi Panda
741
+ Yvonnick Esnault
742
+ Zac Anger
743
+ Zachary Dremann
744
+ Zeno Rocha
745
+ Zhang Hao
746
+ Ziv
747
+ zziuni
748
+ 魏鹏刚
inc/lib/codemirror/CHANGELOG.md ADDED
@@ -0,0 +1,1412 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ## 5.38.0 (2018-05-21)
2
+
3
+ ### Bug fixes
4
+
5
+ Improve reliability of noticing a missing mouseup event during dragging.
6
+
7
+ Make sure `getSelection` is always called on the correct document.
8
+
9
+ Fix interpretation of line breaks and non-breaking spaces inserted by renderer in contentEditable mode.
10
+
11
+ Work around some browsers inexplicably making the fake scrollbars focusable.
12
+
13
+ Make sure `coordsChar` doesn't return positions inside collapsed ranges.
14
+
15
+ [javascript mode](http://codemirror.net/mode/javascript/): Support block scopes, bindingless catch, bignum suffix, `s` regexp flag.
16
+
17
+ [markdown mode](http://codemirror.net/mode/markdown/): Adjust a wasteful regexp.
18
+
19
+ [show-hint addon](http://codemirror.net/doc/manual.html#addon_show-hint): Allow opening the control without any item selected.
20
+
21
+ ### New features
22
+
23
+ New theme: [darcula](http://codemirror.net/demo/theme.html#darcula).
24
+
25
+ [dialog addon](http://codemirror.net/doc/manual.html#addon_dialog): Add a CSS class (`dialog-opened`) to the editor when a dialog is open.
26
+
27
+ ## 5.37.0 (2018-04-20)
28
+
29
+ ### Bug fixes
30
+
31
+ Suppress keypress events during composition, for platforms that don't properly do this themselves.
32
+
33
+ [xml-fold addon](http://codemirror.net/demo/folding.html): Improve handling of line-wrapped opening tags.
34
+
35
+ [javascript mode](http://codemirror.net/mode/javascript/): Improve TypeScript support.
36
+
37
+ [python mode](http://codemirror.net/mode/python/): Highlight expressions inside format strings.
38
+
39
+ ### New features
40
+
41
+ [vim bindings](http://codemirror.net/demo/vim.html): Add support for '(' and ')' movement.
42
+
43
+ New themes: [idea](http://codemirror.net/demo/theme.html#idea), [ssms](http://codemirror.net/demo/theme.html#ssms), [gruvbox-dark](http://codemirror.net/demo/theme.html#gruvbox-dark).
44
+
45
+ ## 5.36.0 (2018-03-20)
46
+
47
+ ### Bug fixes
48
+
49
+ Make sure all document-level event handlers are registered on the document that the editor is part of.
50
+
51
+ Fix issue that prevented edits whose origin starts with `+` from being combined in history events for an editor-less document.
52
+
53
+ [multiplex addon](http://codemirror.net/demo/multiplex.html): Improve handling of indentation.
54
+
55
+ [merge addon](http://codemirror.net/doc/manual.html#addon_merge): Use CSS `:after` element to style the scroll-lock icon.
56
+
57
+ [javascript-hint addon](http://codemirror.net/doc/manual.html#addon_javascript-hint): Don't provide completions in JSON mode.
58
+
59
+ [continuelist addon](http://codemirror.net/doc/manual.html#addon_continuelist): Fix numbering error.
60
+
61
+ [show-hint addon](http://codemirror.net/doc/manual.html#addon_show-hint): Make `fromList` completion strategy act on the current token up to the cursor, rather than the entire token.
62
+
63
+ [markdown mode](http://codemirror.net/mode/markdown/): Fix a regexp with potentially exponental complexity.
64
+
65
+ ### New features
66
+
67
+ New theme: [lucario](http://codemirror.net/demo/theme.html#lucario).
68
+
69
+ ## 5.35.0 (2018-02-20)
70
+
71
+ ### Bug fixes
72
+
73
+ Fix problem where selection undo might change read-only documents.
74
+
75
+ Fix crash when calling `addLineWidget` on a document that has no attached editor.
76
+
77
+ [searchcursor addon](http://codemirror.net/doc/manual.html#addon_searchcursor): Fix behavior of `^` in multiline regexp mode.
78
+
79
+ [match-highlighter addon](http://codemirror.net/doc/manual.html#addon_match-highlighter): Fix problem with matching words that have regexp special syntax in them.
80
+
81
+ [sublime bindings](http://codemirror.net/demo/sublime.html): Fix `addCursorToSelection` for short lines.
82
+
83
+ [javascript mode](http://codemirror.net/mode/javascript/): Support TypeScript intersection types, dynamic `import`.
84
+
85
+ [stex mode](http://codemirror.net/mode/stex/): Fix parsing of `\(` `\)` delimiters, recognize more atom arguments.
86
+
87
+ [haskell mode](http://codemirror.net/mode/haskell/): Highlight more builtins, support `<*` and `*>`.
88
+
89
+ [sql mode](http://codemirror.net/mode/sql/): Make it possible to disable backslash escapes in strings for dialects that don't have them, do this for MS SQL.
90
+
91
+ [dockerfile mode](http://codemirror.net/mode/dockerfile/): Highlight strings and ports, recognize more instructions.
92
+
93
+ ### New features
94
+
95
+ [vim bindings](http://codemirror.net/demo/vim.html): Support alternative delimiters in replace command.
96
+
97
+ ## 5.34.0 (2018-01-29)
98
+
99
+ ### Bug fixes
100
+
101
+ [markdown mode](http://codemirror.net/mode/markdown/): Fix a problem where inline styles would persist across list items.
102
+
103
+ [sublime bindings](http://codemirror.net/demo/sublime.html): Fix the `toggleBookmark` command.
104
+
105
+ [closebrackets addon](http://codemirror.net/doc/manual.html#addon_closebrackets): Improve behavior when closing triple quotes.
106
+
107
+ [xml-fold addon](http://codemirror.net/demo/folding.html): Fix folding of line-broken XML tags.
108
+
109
+ [shell mode](http://codemirror.net/mode/shell/): Better handling of nested quoting.
110
+
111
+ [javascript-lint addon](http://codemirror.net/demo/lint.html): Clean up and simplify.
112
+
113
+ [matchbrackets addon](http://codemirror.net/doc/manual.html#addon_matchbrackets): Fix support for multiple editors at the same time.
114
+
115
+ ### New features
116
+
117
+ New themes: [oceanic-next](http://codemirror.net/demo/theme.html#oceanic-next) and [shadowfox](http://codemirror.net/demo/theme.html#shadowfox).
118
+
119
+ ## 5.33.0 (2017-12-21)
120
+
121
+ ### Bug fixes
122
+
123
+ [lint addon](http://codemirror.net/doc/manual.html#addon_lint): Make updates more efficient.
124
+
125
+ [css mode](http://codemirror.net/mode/css/): The mode is now properly case-insensitive.
126
+
127
+ [continuelist addon](http://codemirror.net/doc/manual.html#addon_continuelist): Fix broken handling of unordered lists introduced in previous release.
128
+
129
+ [swift](http://codemirror.net/mode/swift) and [scala](http://codemirror.net/mode/clike/) modes: Support nested block comments.
130
+
131
+ [mllike mode](http://codemirror.net/mode/mllike/index.html): Improve OCaml support.
132
+
133
+ [sublime bindings](http://codemirror.net/demo/sublime.html): Use the proper key bindings for `addCursorToNextLine` and `addCursorToPrevLine`.
134
+
135
+ ### New features
136
+
137
+ [jsx mode](http://codemirror.net/mode/jsx/index.html): Support JSX fragments.
138
+
139
+ [closetag addon](http://codemirror.net/demo/closetag.html): Add an option to disable auto-indenting.
140
+
141
+ ## 5.32.0 (2017-11-22)
142
+
143
+ ### Bug fixes
144
+
145
+ Increase contrast on default bracket-matching colors.
146
+
147
+ [javascript mode](http://codemirror.net/mode/javascript/): Recognize TypeScript type parameters for calls, type guards, and type parameter defaults. Improve handling of `enum` and `module` keywords.
148
+
149
+ [comment addon](http://codemirror.net/doc/manual.html#addon_comment): Fix bug when uncommenting a comment that spans all but the last selected line.
150
+
151
+ [searchcursor addon](http://codemirror.net/doc/manual.html#addon_searchcursor): Fix bug in case folding.
152
+
153
+ [emacs bindings](http://codemirror.net/demo/emacs.html): Prevent single-character deletions from resetting the kill ring.
154
+
155
+ [closebrackets addon](http://codemirror.net/doc/manual.html#addon_closebrackets): Tweak quote matching behavior.
156
+
157
+ ### New features
158
+
159
+ [continuelist addon](http://codemirror.net/doc/manual.html#addon_continuelist): Increment ordered list numbers when adding one.
160
+
161
+ ## 5.31.0 (2017-10-20)
162
+
163
+ ### Bug fixes
164
+
165
+ Further improve selection drawing and cursor motion in right-to-left documents.
166
+
167
+ [vim bindings](http://codemirror.net/demo/vim.html): Fix ctrl-w behavior, support quote-dot and backtick-dot marks, make the wide cursor visible in contentEditable [input mode](http://codemirror.net/doc/manual.html#option_contentEditable).
168
+
169
+ [continuecomment addon](http://codemirror.net/doc/manual.html#addon_continuecomment): Fix bug when pressing enter after a single-line block comment.
170
+
171
+ [markdown mode](http://codemirror.net/mode/markdown/): Fix issue with leaving indented fenced code blocks.
172
+
173
+ [javascript mode](http://codemirror.net/mode/javascript/): Fix bad parsing of operators without spaces between them. Fix some corner cases around semicolon insertion and regexps.
174
+
175
+ ### New features
176
+
177
+ Modes added with [`addOverlay`](http://codemirror.net/doc/manual.html#addOverlay) now have access to a [`baseToken`](http://codemirror.net/doc/manual.html#baseToken) method on their input stream, giving access to the tokens of the underlying mode.
178
+
179
+ ## 5.30.0 (2017-09-20)
180
+
181
+ ### Bug fixes
182
+
183
+ Fixed a number of issues with drawing right-to-left selections and mouse selection in bidirectional text.
184
+
185
+ [search addon](http://codemirror.net/demo/search/): Fix crash when restarting search after doing empty search.
186
+
187
+ [mark-selection addon](http://cm/doc/manual.html#addon_mark-selection): Fix off-by-one bug.
188
+
189
+ [tern addon](http://codemirror.net/demo/tern.html): Fix bad request made when editing at the bottom of a large document.
190
+
191
+ [javascript mode](http://codemirror.net/mode/javascript/): Improve parsing in a number of corner cases.
192
+
193
+ [markdown mode](http://codemirror.net/mode/markdown/): Fix crash when a sub-mode doesn't support indentation, allow uppercase X in task lists.
194
+
195
+ [gfm mode](http://codemirror.net/mode/gfm/): Don't highlight SHA1 'hashes' without numbers to avoid false positives.
196
+
197
+ [soy mode](http://codemirror.net/mode/soy/): Support injected data and `@param` in comments.
198
+
199
+ ### New features
200
+
201
+ [simple mode addon](http://codemirror.net/demo/simplemode.html): Allow groups in regexps when `token` isn't an array.
202
+
203
+ ## 5.29.0 (2017-08-24)
204
+
205
+ ### Bug fixes
206
+
207
+ Fix crash in contentEditable input style when editing near a bookmark.
208
+
209
+ Make sure change origins are preserved when splitting changes on [read-only marks](http://codemirror.net/doc/manual.html#mark_readOnly).
210
+
211
+ [javascript mode](http://codemirror.net/mode/javascript/): More support for TypeScript syntax.
212
+
213
+ [d mode](http://codemirror.net/mode/d/): Support nested comments.
214
+
215
+ [python mode](http://codemirror.net/mode/python/): Improve tokenizing of operators.
216
+
217
+ [markdown mode](http://codemirror.net/mode/markdown/): Further improve CommonMark conformance.
218
+
219
+ [css mode](http://codemirror.net/mode/css/): Don't run comment tokens through the mode's state machine.
220
+
221
+ [shell mode](http://codemirror.net/mode/shell/): Allow strings to span lines.
222
+
223
+ [search addon](http://codemirror.net/demo/search/): Fix crash in persistent search when `extraKeys` is null.
224
+
225
+ ## 5.28.0 (2017-07-21)
226
+
227
+ ### Bug fixes
228
+
229
+ Fix copying of, or replacing editor content with, a single dash character when copying a big selection in some corner cases.
230
+
231
+ Make [`"goLineLeft"`](http://codemirror.net/doc/manual.html#command_goLineLeft)/`"goLineRight"` behave better on wrapped lines.
232
+
233
+ [sql mode](http://codemirror.net/mode/sql/): Fix tokenizing of multi-dot operator and allow digits in subfield names.
234
+
235
+ [searchcursor addon](http://codemirror.net/doc/manual.html#addon_searchcursor): Fix infinite loop on some composed character inputs.
236
+
237
+ [markdown mode](http://codemirror.net/mode/markdown/): Make list parsing more CommonMark-compliant.
238
+
239
+ [gfm mode](http://codemirror.net/mode/gfm/): Highlight colon syntax for emoji.
240
+
241
+ ### New features
242
+
243
+ Expose [`startOperation`](http://codemirror.net/doc/manual.html#startOperation) and `endOperation` for explicit operation management.
244
+
245
+ [sublime bindings](http://codemirror.net/demo/sublime.html): Add extend-selection (Ctrl-Alt- or Cmd-Shift-Up/Down).
246
+
247
+ ## 5.27.4 (2017-06-29)
248
+
249
+ ### Bug fixes
250
+
251
+ Fix crash when using mode lookahead.
252
+
253
+ [markdown mode](http://codemirror.net/mode/markdown/): Don't block inner mode's indentation support.
254
+
255
+ ## 5.27.2 (2017-06-22)
256
+
257
+ ### Bug fixes
258
+
259
+ Fix crash in the [simple mode](http://codemirror.net/demo/simplemode.html)< addon.
260
+
261
+ ## 5.27.0 (2017-06-22)
262
+
263
+ ### Bug fixes
264
+
265
+ Fix infinite loop in forced display update.
266
+
267
+ Properly disable the hidden textarea when `readOnly` is `"nocursor"`.
268
+
269
+ Calling the `Doc` constructor without `new` works again.
270
+
271
+ [sql mode](http://codemirror.net/mode/sql/): Handle nested comments.
272
+
273
+ [javascript mode](http://codemirror.net/mode/javascript/): Improve support for TypeScript syntax.
274
+
275
+ [markdown mode](http://codemirror.net/mode/markdown/): Fix bug where markup was ignored on indented paragraph lines.
276
+
277
+ [vim bindings](http://codemirror.net/demo/vim.html): Referencing invalid registers no longer causes an uncaught exception.
278
+
279
+ [rust mode](http://codemirror.net/mode/rust/): Add the correct MIME type.
280
+
281
+ [matchbrackets addon](http://codemirror.net/doc/manual.html#addon_matchbrackets): Document options.
282
+
283
+ ### New features
284
+
285
+ Mouse button clicks can now be bound in keymaps by using names like `"LeftClick"` or `"Ctrl-Alt-MiddleTripleClick"`. When bound to a function, that function will be passed the position of the click as second argument.
286
+
287
+ The behavior of mouse selection and dragging can now be customized with the [`configureMouse`](http://codemirror.net/doc/manual.html#option_configureMouse) option.
288
+
289
+ Modes can now look ahead across line boundaries with the [`StringStream`](http://codemirror.net/doc/manual.html#StringStream)`.lookahead` method.
290
+
291
+ Introduces a `"type"` token type, makes modes that recognize types output it, and add styling for it to the themes.
292
+
293
+ New [`pasteLinesPerSelection`](http://codemirror.net/doc/manual.html#option_pasteLinesPerSelection) option to control the behavior of pasting multiple lines into multiple selections.
294
+
295
+ [searchcursor addon](http://codemirror.net/doc/manual.html#addon_searchcursor): Support multi-line regular expression matches, and normalize strings when matching.
296
+
297
+ ## 5.26.0 (2017-05-22)
298
+
299
+ ### Bug fixes
300
+
301
+ In textarea-mode, don't reset the input field during composition.
302
+
303
+ More careful restoration of selections in widgets, during editor redraw.
304
+
305
+ [javascript mode](http://codemirror.net/mode/javascript/): More TypeScript parsing fixes.
306
+
307
+ [julia mode](http://codemirror.net/mode/julia/): Fix issue where the mode gets stuck.
308
+
309
+ [markdown mode](http://codemirror.net/mode/markdown/): Understand cross-line links, parse all bracketed things as links.
310
+
311
+ [soy mode](http://codemirror.net/mode/soy/): Support single-quoted strings.
312
+
313
+ [go mode](http://codemirror.net/mode/go/): Don't try to indent inside strings or comments.
314
+
315
+ ### New features
316
+
317
+ [vim bindings](http://codemirror.net/demo/vim.html): Parse line offsets in line or range specs.
318
+
319
+ ## 5.25.2 (2017-04-20)
320
+
321
+ ### Bug fixes
322
+
323
+ Better handling of selections that cover the whole viewport in contentEditable-mode.
324
+
325
+ No longer accidentally scroll the editor into view when calling `setValue`.
326
+
327
+ Work around Chrome Android bug when converting screen coordinates to editor positions.
328
+
329
+ Make sure long-clicking a selection sets a cursor and doesn't show the editor losing focus.
330
+
331
+ Fix issue where pointer events were incorrectly disabled on Chrome's overlay scrollbars.
332
+
333
+ [javascript mode](http://codemirror.net/mode/javascript/): Recognize annotations and TypeScript-style type parameters.
334
+
335
+ [shell mode](http://codemirror.net/mode/shell/): Handle nested braces.
336
+
337
+ [markdown mode](http://codemirror.net/mode/markdown/): Make parsing of strong/em delimiters CommonMark-compliant.
338
+
339
+ ## 5.25.0 (2017-03-20)
340
+
341
+ ### Bug fixes
342
+
343
+ In contentEditable-mode, properly locate changes that repeat a character when inserted with IME.
344
+
345
+ Fix handling of selections bigger than the viewport in contentEditable mode.
346
+
347
+ Improve handling of changes that insert or delete lines in contentEditable mode.
348
+
349
+ Count Unicode control characters 0x80 to 0x9F as special (non-printing) chars.
350
+
351
+ Fix handling of shadow DOM roots when finding the active element.
352
+
353
+ Add `role=presentation` to more DOM elements to improve screen reader support.
354
+
355
+ [merge addon](http://codemirror.net/doc/manual.html#addon_merge): Make aligning of unchanged chunks more robust.
356
+
357
+ [comment addon](http://codemirror.net/doc/manual.html#addon_comment): Fix comment-toggling on a block of text that starts and ends in a (differnet) block comment.
358
+
359
+ [javascript mode](http://codemirror.net/mode/javascript/): Improve support for TypeScript syntax.
360
+
361
+ [r mode](http://codemirror.net/mode/r/): Fix indentation after semicolon-less statements.
362
+
363
+ [shell mode](http://codemirror.net/mode/shell/): Properly handle escaped parentheses in parenthesized expressions.
364
+
365
+ [markdown mode](http://codemirror.net/mode/markdown/): Fix a few bugs around leaving fenced code blocks.
366
+
367
+ [soy mode](http://codemirror.net/mode/soy/): Improve indentation.
368
+
369
+ ### New features
370
+
371
+ [lint addon](http://codemirror.net/doc/manual.html#addon_lint): Support asynchronous linters that return promises.
372
+
373
+ [continuelist addon](http://codemirror.net/doc/manual.html#addon_continuelist): Support continuing task lists.
374
+
375
+ [vim bindings](http://codemirror.net/demo/vim.html): Make Y behave like yy.
376
+
377
+ [sql mode](http://codemirror.net/mode/sql/): Support sqlite dialect.
378
+
379
+ ## 5.24.2 (2017-02-22)
380
+
381
+ ### Bug fixes
382
+
383
+ [javascript mode](http://codemirror.net/mode/javascript/): Support computed class method names.
384
+
385
+ [merge addon](http://codemirror.net/doc/manual.html#addon_merge): Improve aligning of unchanged code in the presence of marks and line widgets.
386
+
387
+ ## 5.24.0 (2017-02-20)
388
+
389
+ ### Bug fixes
390
+
391
+ A cursor directly before a line-wrapping break is now drawn before or after the line break depending on which direction you arrived from.
392
+
393
+ Visual cursor motion in line-wrapped right-to-left text should be much more correct.
394
+
395
+ Fix bug in handling of read-only marked text.
396
+
397
+ [shell mode](http://codemirror.net/mode/shell/): Properly tokenize nested parentheses.
398
+
399
+ [python mode](http://codemirror.net/mode/python/): Support underscores in number literals.
400
+
401
+ [sass mode](http://codemirror.net/mode/sass/): Uses the full list of CSS properties and keywords from the CSS mode, rather than defining its own incomplete subset.
402
+
403
+ [css mode](http://codemirror.net/mode/css/): Expose `lineComment` property for LESS and SCSS dialects. Recognize vendor prefixes on pseudo-elements.
404
+
405
+ [julia mode](http://codemirror.net/mode/julia/): Properly indent `elseif` lines.
406
+
407
+ [markdown mode](http://codemirror.net/mode/markdown/): Properly recognize the end of fenced code blocks when inside other markup.
408
+
409
+ [scala mode](http://codemirror.net/mode/clike/): Improve handling of operators containing <code>#</code>, <code>@</code>, and <code>:</code> chars.
410
+
411
+ [xml mode](http://codemirror.net/mode/xml/): Allow dashes in HTML tag names.
412
+
413
+ [javascript mode](http://codemirror.net/mode/javascript/): Improve parsing of async methods, TypeScript-style comma-separated superclass lists.
414
+
415
+ [indent-fold addon](http://codemirror.net/demo/folding.html): Ignore comment lines.
416
+
417
+ ### New features
418
+
419
+ Positions now support a `sticky` property which determines whether they should be associated with the character before (value `"before"`) or after (value `"after"`) them.
420
+
421
+ [vim bindings](http://codemirror.net/demo/vim.html): Make it possible to remove built-in bindings through the API.
422
+
423
+ [comment addon](http://codemirror.net/doc/manual.html#addon_comment): Support a per-mode <code>useInnerComments</code> option to optionally suppress descending to the inner modes to get comment strings.
424
+
425
+ ### Breaking changes
426
+
427
+ The [sass mode](http://codemirror.net/mode/sass/) now depends on the [css mode](http://codemirror.net/mode/css/).
428
+
429
+ ## 5.23.0 (2017-01-19)
430
+
431
+ ### Bug fixes
432
+
433
+ Presentation-related elements DOM elements are now marked as such to help screen readers.
434
+
435
+ [markdown mode](http://codemirror.net/mode/markdown/): Be more picky about what HTML tags look like to avoid false positives.
436
+
437
+ ### New features
438
+
439
+ `findModeByMIME` now understands `+json` and `+xml` MIME suffixes.
440
+
441
+ [closebrackets addon](http://codemirror.net/doc/manual.html#addon_closebrackets): Add support for an `override` option to ignore language-specific defaults.
442
+
443
+ [panel addon](http://codemirror.net/doc/manual.html#addon_panel): Add a `stable` option that auto-scrolls the content to keep it in the same place when inserting/removing a panel.
444
+
445
+ ## 5.22.2 (2017-01-12)
446
+
447
+ ### Bug fixes
448
+
449
+ Include rollup.config.js in NPM package, so that it can be used to build from source.
450
+
451
+ ## 5.22.0 (2016-12-20)
452
+
453
+ ### Bug fixes
454
+
455
+ [sublime bindings](http://codemirror.net/demo/sublime.html): Make `selectBetweenBrackets` work with multiple cursors.
456
+
457
+ [javascript mode](http://codemirror.net/mode/javascript/): Fix issues with parsing complex TypeScript types, imports, and exports.
458
+
459
+ A contentEditable editor instance with autofocus enabled no longer crashes during initializing.
460
+
461
+ ### New features
462
+
463
+ [emacs bindings](http://codemirror.net/demo/emacs.html): Export `CodeMirror.emacs` to allow other addons to hook into Emacs-style functionality.
464
+
465
+ [active-line addon](http://codemirror.net/doc/manual.html#addon_active-line): Add `nonEmpty` option.
466
+
467
+ New event: [`optionChange`](http://codemirror.net/doc/manual.html#event_optionChange).
468
+
469
+ ## 5.21.0 (2016-11-21)
470
+
471
+ ### Bug fixes
472
+
473
+ Tapping/clicking the editor in [contentEditable mode](http://codemirror.net/doc/manual.html#option_inputStyle) on Chrome now puts the cursor at the tapped position.
474
+
475
+ Fix various crashes and misbehaviors when reading composition events in [contentEditable mode](http://codemirror.net/doc/manual.html#option_inputStyle).
476
+
477
+ Catches and ignores an IE 'Unspecified Error' when creating an editor in an iframe before there is a `<body>`.
478
+
479
+ [merge addon](http://codemirror.net/doc/manual.html#addon_merge): Fix several issues in the chunk-aligning feature.
480
+
481
+ [verilog mode](http://codemirror.net/mode/verilog): Rewritten to address various issues.
482
+
483
+ [julia mode](http://codemirror.net/mode/julia): Recognize Julia 0.5 syntax.
484
+
485
+ [swift mode](http://codemirror.net/mode/swift): Various fixes and adjustments to current syntax.
486
+
487
+ [markdown mode](http://codemirror.net/mode/markdown): Allow lists without a blank line above them.
488
+
489
+ ### New features
490
+
491
+ The [`setGutterMarker`](http://codemirror.net/doc/manual.html#setGutterMarker), [`clearGutter`](http://codemirror.net/doc/manual.html#clearGutter), and [`lineInfo`](http://codemirror.net/doc/manual.html#lineInfo) methods are now available on `Doc` objects.
492
+
493
+ The [`heightAtLine`](http://codemirror.net/doc/manual.html#heightAtLine) method now takes an extra argument to allow finding the height at the top of the line's line widgets.
494
+
495
+ [ruby mode](http://codemirror.net/mode/ruby): `else` and `elsif` are now immediately indented.
496
+
497
+ [vim bindings](http://codemirror.net/demo/vim.html): Bind Ctrl-T and Ctrl-D to in- and dedent in insert mode.
498
+
499
+ ## 5.20.2 (2016-10-21)
500
+
501
+ ### Bug fixes
502
+
503
+ Fix `CodeMirror.version` returning the wrong version number.
504
+
505
+ ## 5.20.0 (2016-10-20)
506
+
507
+ ### Bug fixes
508
+
509
+ Make `newlineAndIndent` command work with multiple cursors on the same line.
510
+
511
+ Make sure keypress events for backspace are ignored.
512
+
513
+ Tokens styled with overlays no longer get a nonsense `cm-cm-overlay` class.
514
+
515
+ Line endings for pasted content are now normalized to the editor's [preferred ending](http://codemirror.net/doc/manual.html#option_lineSeparator).
516
+
517
+ [javascript mode](http://codemirror.net/mode/javascript): Improve support for class expressions. Support TypeScript optional class properties, the `abstract` keyword, and return type declarations for arrow functions.
518
+
519
+ [css mode](http://codemirror.net/mode/css): Fix highlighting of mixed-case keywords.
520
+
521
+ [closebrackets addon](http://codemirror.net/doc/manual.html#addon_closebrackets): Improve behavior when typing a quote before a string.
522
+
523
+ ### New features
524
+
525
+ The core is now maintained as a number of small files, using ES6 syntax and modules, under the `src/` directory. A git checkout no longer contains a working `codemirror.js` until you `npm build` (but when installing from NPM, it is included).
526
+
527
+ The [`refresh`](http://codemirror.net/doc/manual.html#event_refresh) event is now documented and stable.
528
+
529
+ ## 5.19.0 (2016-09-20)
530
+
531
+ ### Bugfixes
532
+
533
+ [erlang mode](http://codemirror.net/mode/erlang): Fix mode crash when trying to read an empty context.
534
+
535
+ [comment addon](http://codemirror.net/doc/manual.html#addon_comment): Fix broken behavior when toggling comments inside a comment.
536
+
537
+ xml-fold addon: Fix a null-dereference bug.
538
+
539
+ Page up and page down now do something even in single-line documents.
540
+
541
+ Fix an issue where the cursor position could be off in really long (~8000 character) tokens.
542
+
543
+ ### New features
544
+
545
+ [javascript mode](http://codemirror.net/mode/javascript): Better indentation when semicolons are missing. Better support for TypeScript classes, optional parameters, and the `type` keyword.
546
+
547
+ The [`blur`](http://codemirror.net/doc/manual.html#event_blur) and [`focus`](http://codemirror.net/doc/manual.html#event_focus) events now pass the DOM event to their handlers.
548
+
549
+ ## 5.18.2 (2016-08-23)
550
+
551
+ ### Bugfixes
552
+
553
+ [vue mode](http://codemirror.net/mode/vue): Fix outdated references to renamed Pug mode dependency.
554
+
555
+ ## 5.18.0 (2016-08-22)
556
+
557
+ ### Bugfixes
558
+
559
+ Make sure [gutter backgrounds](http://codemirror.net/doc/manual.html#addLineClass) stick to the rest of the gutter during horizontal scrolling.
560
+
561
+ The contenteditable [`inputStyle`](http://codemirror.net/doc/manual.html#option_inputStyle) now properly supports pasting on pre-Edge IE versions.
562
+
563
+ [javascript mode](http://codemirror.net/mode/javascript): Fix some small parsing bugs and improve TypeScript support.
564
+
565
+ [matchbrackets addon](http://codemirror.net/doc/manual.html#addon_matchbrackets): Fix bug where active highlighting was left in editor when the addon was disabled.
566
+
567
+ [match-highlighter addon](http://codemirror.net/doc/manual.html#addon_match-highlighter): Only start highlighting things when the editor gains focus.
568
+
569
+ [javascript-hint addon](http://codemirror.net/doc/manual.html#addon_javascript-hint): Also complete non-enumerable properties.
570
+
571
+ ### New features
572
+
573
+ The [`addOverlay`](http://codemirror.net/doc/manual.html#addOverlay) method now supports a `priority` option to control the order in which overlays are applied.
574
+
575
+ MIME types that end in `+json` now default to the JSON mode when the MIME itself is not defined.
576
+
577
+ ### Breaking changes
578
+
579
+ The mode formerly known as Jade was renamed to [Pug](http://codemirror.net/mode/pug).
580
+
581
+ The [Python mode](http://codemirror.net/mode/python) now defaults to Python 3 (rather than 2) syntax.
582
+
583
+ ## 5.17.0 (2016-07-19)
584
+
585
+ ### Bugfixes
586
+
587
+ Fix problem with wrapped trailing whitespace displaying incorrectly.
588
+
589
+ Prevent IME dialog from overlapping typed content in Chrome.
590
+
591
+ Improve measuring of characters near a line wrap.
592
+
593
+ [javascript mode](http://codemirror.net/mode/javascript): Improve support for `async`, allow trailing commas in `import` lists.
594
+
595
+ [vim bindings](http://codemirror.net/demo/vim.html): Fix backspace in replace mode.
596
+
597
+ [sublime bindings](http://codemirror.net/demo/sublime.html): Fix some key bindings on OS X to match Sublime Text.
598
+
599
+ ### New features
600
+
601
+ [markdown mode](http://codemirror.net/mode/markdown): Add more classes to image links in highlight-formatting mode.
602
+
603
+ ## 5.16.0 (2016-06-20)
604
+
605
+ ### Bugfixes
606
+
607
+ Fix glitches when dragging content caused by the drop indicator receiving mouse events.
608
+
609
+ Make Control-drag work on Firefox.
610
+
611
+ Make clicking or selection-dragging at the end of a wrapped line select the right position.
612
+
613
+ [show-hint addon](http://codemirror.net/doc/manual.html#addon_show-hint): Prevent widget scrollbar from hiding part of the hint text.
614
+
615
+ [rulers addon](http://codemirror.net/doc/manual.html#addon_rulers): Prevent rulers from forcing a horizontal editor scrollbar.
616
+
617
+ ### New features
618
+
619
+ [search addon](http://codemirror.net/doc/manual.html#addon_search): Automatically bind search-related keys in persistent dialog.
620
+
621
+ [sublime keymap](http://codemirror.net/demo/sublime.html): Add a multi-cursor aware smart backspace binding.
622
+
623
+ ## 5.15.2 (2016-05-20)
624
+
625
+ ### Bugfixes
626
+
627
+ Fix a critical document corruption bug that occurs when a document is gradually grown.
628
+
629
+ ## 5.15.0 (2016-05-20)
630
+
631
+ ### Bugfixes
632
+
633
+ Fix bug that caused the selection to reset when focusing the editor in contentEditable input mode.
634
+
635
+ Fix issue where not all ASCII control characters were being replaced by placeholders.
636
+
637
+ Remove the assumption that all modes have a `startState` method from several wrapping modes.
638
+
639
+ Fix issue where the editor would complain about overlapping collapsed ranges when there weren't any.
640
+
641
+ Optimize document tree building when loading or pasting huge chunks of content.
642
+
643
+ [markdown mode](http://codemirror.net/mode/markdown/): Fix several issues in matching link targets.
644
+
645
+ [clike mode](http://codemirror.net/mode/clike/): Improve indentation of C++ template declarations.
646
+
647
+ ### New features
648
+
649
+ Explicitly bind Ctrl-O on OS X to make that binding (“open line”) act as expected.
650
+
651
+ Pasting [linewise-copied](http://codemirror.net/doc/manual.html#option_lineWiseCopyCut) content when there is no selection now inserts the lines above the current line.
652
+
653
+ [javascript mode](http://codemirror.net/mode/javascript/): Support `async`/`await` and improve support for TypeScript type syntax.
654
+
655
+ ## 5.14.2 (2016-04-20)
656
+
657
+ ### Bugfixes
658
+
659
+ Push a new package to NPM due to an [NPM bug](https://github.com/npm/npm/issues/5082) omitting the LICENSE file in 5.14.0.
660
+
661
+ Set `dataTransfer.effectAllowed` in `dragstart` handler to help browsers use the right drag icon.
662
+
663
+ Add the [mbox mode](http://codemirror.net/mode/mbox/index.html) to `mode/meta.js`.
664
+
665
+ ## 5.14.0 (2016-04-20)
666
+
667
+ ### Bugfixes
668
+
669
+ [`posFromIndex`](http://codemirror.net/doc/manual.html#posFromIndex) and [`indexFromPos`](http://codemirror.net/doc/manual.html#indexFromPos) now take [`lineSeparator`](http://codemirror.net/doc/manual.html#option_lineSeparator) into account.
670
+
671
+ [vim bindings](http://codemirror.net/demo/vim.html): Only call `.save()` when it is actually available.
672
+
673
+ [comment addon](http://codemirror.net/doc/manual.html#addon_comment): Be careful not to mangle multi-line strings.
674
+
675
+ [Python mode](http://codemirror.net/mode/python/index.html): Improve distinguishing of decorators from `@` operators.
676
+
677
+ [`findMarks`](http://codemirror.net/doc/manual.html#findMarks): No longer return marks that touch but don't overlap given range.
678
+
679
+ ### New features
680
+
681
+ [vim bindings](http://codemirror.net/demo/vim.html): Add yank command.
682
+
683
+ [match-highlighter addon](http://codemirror.net/doc/manual.html#addon_match-highlighter): Add `trim` option to disable ignoring of whitespace.
684
+
685
+ [PowerShell mode](http://codemirror.net/mode/powershell/index.html): Added.
686
+
687
+ [Yacas mode](http://codemirror.net/mode/yacas/index.html): Added.
688
+
689
+ [Web IDL mode](http://codemirror.net/mode/webidl/index.html): Added.
690
+
691
+ [SAS mode](http://codemirror.net/mode/sas/index.html): Added.
692
+
693
+ [mbox mode](http://codemirror.net/mode/mbox/index.html): Added.
694
+
695
+ ## 5.13.2 (2016-03-23)
696
+
697
+ ### Bugfixes
698
+
699
+ Solves a problem where the gutter would sometimes not extend all the way to the end of the document.
700
+
701
+ ## 5.13.0 (2016-03-21)
702
+
703
+ ### New features
704
+
705
+ New DOM event forwarded: [`"dragleave"`](http://codemirror.net/doc/manual.html#event_dom).
706
+
707
+ [protobuf mode](http://codemirror.net/mode/protobuf/index.html): Newly added.
708
+
709
+ ### Bugfixes
710
+
711
+ Fix problem where [`findMarks`](http://codemirror.net/doc/manual.html#findMarks) sometimes failed to find multi-line marks.
712
+
713
+ Fix crash that showed up when atomic ranges and bidi text were combined.
714
+
715
+ [show-hint addon](http://codemirror.net/demo/complete.html): Completion widgets no longer close when the line indented or dedented.
716
+
717
+ [merge addon](http://codemirror.net/demo/merge.html): Fix bug when merging chunks at the end of the file.
718
+
719
+ [placeholder addon](http://codemirror.net/doc/manual.html#addon_placeholder): No longer gets confused by [`swapDoc`](http://codemirror.net/doc/manual.html#swapDoc).
720
+
721
+ [simplescrollbars addon](http://codemirror.net/doc/manual.html#addon_simplescrollbars): Fix invalid state when deleting at end of document.
722
+
723
+ [clike mode](http://codemirror.net/mode/clike/index.html): No longer gets confused when a comment starts after an operator.
724
+
725
+ [markdown mode](http://codemirror.net/mode/markdown/index.html): Now supports CommonMark-style flexible list indentation.
726
+
727
+ [dylan mode](http://codemirror.net/mode/dylan/index.html): Several improvements and fixes.
728
+
729
+ ## 5.12.0 (2016-02-19)
730
+
731
+ ### New features
732
+
733
+ [Vim bindings](http://codemirror.net/demo/vim.html): Ctrl-Q is now an alias for Ctrl-V.
734
+
735
+ [Vim bindings](http://codemirror.net/demo/vim.html): The Vim API now exposes an `unmap` method to unmap bindings.
736
+
737
+ [active-line addon](http://codemirror.net/demo/activeline.html): This addon can now style the active line's gutter.
738
+
739
+ [FCL mode](http://codemirror.net/mode/fcl/): Newly added.
740
+
741
+ [SQL mode](http://codemirror.net/mode/sql/): Now has a Postgresql dialect.
742
+
743
+ ### Bugfixes
744
+
745
+ Fix [issue](https://github.com/codemirror/CodeMirror/issues/3781) where trying to scroll to a horizontal position outside of the document's width could cause the gutter to be positioned incorrectly.
746
+
747
+ Use absolute, rather than fixed positioning in the context-menu intercept hack, to work around a [problem](https://github.com/codemirror/CodeMirror/issues/3238) when the editor is inside a transformed parent container.
748
+
749
+ Solve a [problem](https://github.com/codemirror/CodeMirror/issues/3821) where the horizontal scrollbar could hide text in Firefox.
750
+
751
+ Fix a [bug](https://github.com/codemirror/CodeMirror/issues/3834) that caused phantom scroll space under the text in some situations.
752
+
753
+ [Sublime Text bindings](http://codemirror.net/demo/sublime.html): Bind delete-line to Shift-Ctrl-K on OS X.
754
+
755
+ [Markdown mode](http://codemirror.net/mode/markdown/): Fix [issue](https://github.com/codemirror/CodeMirror/issues/3787) where the mode would keep state related to fenced code blocks in an unsafe way, leading to occasional corrupted parses.
756
+
757
+ [Markdown mode](http://codemirror.net/mode/markdown/): Ignore backslashes in code fragments.
758
+
759
+ [Markdown mode](http://codemirror.net/mode/markdown/): Use whichever mode is registered as `text/html` to parse HTML.
760
+
761
+ [Clike mode](http://codemirror.net/mode/clike/): Improve indentation of Scala `=>` functions.
762
+
763
+ [Python mode](http://codemirror.net/mode/python/): Improve indentation of bracketed code.
764
+
765
+ [HTMLMixed mode](http://codemirror.net/mode/htmlmixed/): Support multi-line opening tags for sub-languages (`<script>`, `<style>`, etc).
766
+
767
+ [Spreadsheet mode](http://codemirror.net/mode/spreadsheet/): Fix bug where the mode did not advance the stream when finding a backslash.
768
+
769
+ [XML mode](http://codemirror.net/mode/xml/): The mode now takes a `matchClosing` option to configure whether mismatched closing tags should be highlighted as errors.
770
+
771
+ ## 5.11.0 (2016-01-20)
772
+
773
+ * New modes: [JSX](http://codemirror.net/mode/jsx/index.html), [literate Haskell](http://codemirror.net/mode/haskell-literate/index.html)
774
+ * The editor now forwards more [DOM events](http://codemirror.net/doc/manual.html#event_dom): `cut`, `copy`, `paste`, and `touchstart`. It will also forward `mousedown` for drag events
775
+ * Fixes a bug where bookmarks next to collapsed spans were not rendered
776
+ * The [Swift](http://codemirror.net/mode/swift/index.html) mode now supports auto-indentation
777
+ * Frontmatters in the [YAML frontmatter](http://codemirror.net/mode/yaml-frontmatter/index.html) mode are now optional as intended
778
+
779
+ ## 5.10.0 (2015-12-21)
780
+
781
+ * Modify the way [atomic ranges](http://codemirror.net/doc/manual.html#mark_atomic) are skipped by selection to try and make it less surprising.
782
+ * The [Swift mode](http://codemirror.net/mode/swift/index.html) was rewritten.
783
+ * New addon: [jump-to-line](http://codemirror.net/doc/manual.html#addon_jump-to-line).
784
+ * New method: [`isReadOnly`](http://codemirror.net/doc/manual.html#isReadOnly).
785
+ * The [show-hint addon](http://codemirror.net/doc/manual.html#addon_show-hint) now defaults to picking completions on single click.
786
+ * The object passed to [`"beforeSelectionChange"`](http://codemirror.net/doc/manual.html#event_beforeSelectionChange) events now has an `origin` property.
787
+ * New mode: [Crystal](http://codemirror.net/mode/crystal/index.html).
788
+
789
+ ## 5.9.0 (2015-11-23)
790
+
791
+ * Improve the way overlay (OS X-style) scrollbars are handled
792
+ * Make [annotatescrollbar](http://codemirror.net/doc/manual.html#addon_annotatescrollbar) and scrollpastend addons work properly together
793
+ * Make [show-hint](http://codemirror.net/doc/manual.html#addon_show-hint) addon select options on single click by default, move selection to hovered item
794
+ * Properly fold comments that include block-comment-start markers
795
+ * Many small language mode fixes
796
+
797
+ ## 5.8.0 (2015-10-20)
798
+
799
+ * Fixes an infinite loop in the [hardwrap addon](http://codemirror.net/doc/manual.html#addon_hardwrap)
800
+ * New modes: [NSIS](http://codemirror.net/mode/nsis/index.html), [Ceylon](http://codemirror.net/mode/clike/index.html)
801
+ * The Kotlin mode is now a [clike](http://codemirror.net/mode/clike/index.html) dialect, rather than a stand-alone mode
802
+ * New option: [`allowDropFileTypes`](http://codemirror.net/doc/manual.html#option_allowDropFileTypes). Binary files can no longer be dropped into CodeMirror
803
+ * New themes: [bespin](http://codemirror.net/demo/theme.html#bespin), [hopscotch](http://codemirror.net/demo/theme.html#hopscotch), [isotope](http://codemirror.net/demo/theme.html#isotope), [railscasts](http://codemirror.net/demo/theme.html#railscasts)
804
+
805
+ ## 5.7.0 (2015-09-21)
806
+
807
+ * New modes: [Vue](http://codemirror.net/mode/vue/index.html), [Oz](http://codemirror.net/mode/oz/index.html), [MscGen](http://codemirror.net/mode/mscgen/index.html) (and dialects), [Closure Stylesheets](http://codemirror.net/mode/css/gss.html)
808
+ * Implement [CommonMark](http://commonmark.org)-style flexible list indent and cross-line code spans in [Markdown](http://codemirror.net/mode/markdown/index.html) mode
809
+ * Add a replace-all button to the [search addon](http://codemirror.net/doc/manual.html#addon_search), and make the persistent search dialog transparent when it obscures the match
810
+ * Handle `acync`/`await` and ocal and binary numbers in [JavaScript mode](http://codemirror.net/mode/javascript/index.html)
811
+ * Fix various issues with the [Haxe mode](http://codemirror.net/mode/haxe/index.html)
812
+ * Make the [closebrackets addon](http://codemirror.net/doc/manual.html#addon_closebrackets) select only the wrapped text when wrapping selection in brackets
813
+ * Tokenize properties as properties in the [CoffeeScript mode](http://codemirror.net/mode/coffeescript/index.html)
814
+ * The [placeholder addon](http://codemirror.net/doc/manual.html#addon_placeholder) now accepts a DOM node as well as a string placeholder
815
+
816
+ ## 5.6.0 (2015-08-20)
817
+
818
+ * Fix bug where you could paste into a `readOnly` editor
819
+ * Show a cursor at the drop location when dragging over the editor
820
+ * The [Rust mode](http://codemirror.net/mode/rust/index.html) was rewritten to handle modern Rust
821
+ * The editor and theme CSS was cleaned up. Some selectors are now less specific than before
822
+ * New theme: [abcdef](http://codemirror.net/demo/theme.html#abcdef)
823
+ * Lines longer than [`maxHighlightLength`](http://codemirror.net/doc/manual.html#option_maxHighlightLength) are now less likely to mess up indentation
824
+ * New addons: [`autorefresh`](http://codemirror.net/doc/manual.html#addon_autorefresh) for refreshing an editor the first time it becomes visible, and `html-lint` for using [HTMLHint](http://htmlhint.com/)
825
+ * The [`search`](http://codemirror.net/doc/manual.html#addon_search) addon now recognizes `\r` and `\n` in pattern and replacement input
826
+
827
+ ## 5.5.0 (2015-07-20)
828
+
829
+ * New option: [`lineSeparator`](http://codemirror.net/doc/manual.html#option_lineSeparator) (with corresponding [method](http://codemirror.net/doc/manual.html#lineSeparator))
830
+ * New themes: [dracula](http://codemirror.net/demo/theme.html#dracula), [seti](http://codemirror.net/demo/theme.html#seti), [yeti](http://codemirror.net/demo/theme.html#yeti), [material](http://codemirror.net/demo/theme.html#material), and [icecoder](http://codemirror.net/demo/theme.html#icecoder)
831
+ * New modes: [Brainfuck](http://codemirror.net/mode/brainfuck/index.html), [VHDL](http://codemirror.net/mode/vhdl/index.html), Squirrel ([clike](http://codemirror.net/mode/clike/index.html) dialect)
832
+ * Define a `findPersistent` command in the [search](http://codemirror.net/demo/search.html) addon, for a dialog that stays open as you cycle through matches
833
+ * From this release on, the NPM module doesn't include documentation and demos
834
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/5.4.0...5.5.0)
835
+
836
+ ## 5.4.0 (2015-06-25)
837
+
838
+ * New modes: [Twig](http://codemirror.net/mode/twig/index.html), [Elm](http://codemirror.net/mode/elm/index.html), [Factor](http://codemirror.net/mode/factor/index.html), [Swift](http://codemirror.net/mode/swift/index.html)
839
+ * Prefer clipboard API (if available) when pasting
840
+ * Refined definition highlighting in [clike](http://codemirror.net/mode/clike/index.html) mode
841
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/5.3.0...5.4.0)
842
+
843
+ ## 5.3.0 (2015-05-20)
844
+
845
+ * Fix several regressions in the [`show-hint`](http://codemirror.net/doc/manual.html#addon_show-hint) addon (`completeSingle` option, `"shown"` and `"close"` events)
846
+ * The [vim mode](http://codemirror.net/demo/vim.html) API was [documented](http://codemirror.net/doc/manual.html#vimapi)
847
+ * New modes: [ASN.1](http://codemirror.net/mode/asn.1/index.html), [TTCN](http://codemirror.net/mode/ttcn/index.html), and [TTCN-CFG](http://codemirror.net/mode/ttcn-cfg/index.html)
848
+ * The [clike](http://codemirror.net/mode/clike/index.html) mode can now deep-indent `switch` statements, and roughly recognizes types and defined identifiers
849
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/5.2.0...5.3.0)
850
+
851
+ ## 5.2.0 (2015-04-20)
852
+
853
+ * Fix several race conditions in [`show-hint`](http://codemirror.net/doc/manual.html#addon_show-hint)'s asynchronous mode
854
+ * Fix backspace binding in [Sublime bindings](http://codemirror.net/demo/sublime.html)
855
+ * Change the way IME is handled in the `"textarea"` [input style](http://codemirror.net/doc/manual.html#option_inputStyle)
856
+ * New modes: [MUMPS](http://codemirror.net/mode/mumps/index.html), [Handlebars](http://codemirror.net/mode/handlebars/index.html)
857
+ * Rewritten modes: [Django](http://codemirror.net/mode/django/index.html), [Z80](http://codemirror.net/mode/z80/index.html)
858
+ * New theme: [Liquibyte](http://codemirror.net/demo/theme.html#liquibyte)
859
+ * New option: [`lineWiseCopyCut`](http://codemirror.net/doc/manual.html#option_lineWiseCopyCut)
860
+ * The [Vim mode](http://codemirror.net/demo/vim.html) now supports buffer-local options and the `filetype` setting
861
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/5.1.0...5.2.0)
862
+
863
+ ## 5.1.0 (2015-03-23)
864
+
865
+ * New modes: [ASCII armor](http://codemirror.net/mode/asciiarmor/index.html) (PGP data), [Troff](http://codemirror.net/mode/troff/index.html), and [CMake](http://codemirror.net/mode/cmake/index.html).
866
+ * Remove SmartyMixed mode, rewrite [Smarty](http://codemirror.net/mode/smarty/index.html) mode to supersede it.
867
+ * New commands in the [merge addon](http://codemirror.net/doc/manual.html#addon_merge): `goNextDiff` and `goPrevDiff`.
868
+ * The [closebrackets addon](http://codemirror.net/doc/manual.html#addon_closebrackets) can now be configured per mode.
869
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/5.0.0...5.1.0).
870
+
871
+ ## 5.0.0 (2015-02-20)
872
+
873
+ * Experimental mobile support (tested on iOS, Android Chrome, stock Android browser)
874
+ * New option [`inputStyle`](http://codemirror.net/doc/manual.html#option_inputStyle) to switch between hidden textarea and contenteditable input.
875
+ * The [`getInputField`](http://codemirror.net/doc/manual.html#getInputField) method is no longer guaranteed to return a textarea.
876
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.13.0...5.0.0).
877
+
878
+ ## 4.13.0 (2015-02-20)
879
+
880
+ * Fix the way the [`closetag`](http://codemirror.net/demo/closetag.html) demo handles the slash character.
881
+ * New modes: [Forth](http://codemirror.net/mode/forth/index.html), [Stylus](http://codemirror.net/mode/stylus/index.html).
882
+ * Make the [CSS mode](http://codemirror.net/mode/css/index.html) understand some modern CSS extensions.
883
+ * Have the [Scala mode](http://codemirror.net/mode/clike/index.html) handle symbols and triple-quoted strings.
884
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.12.0...4.13.0).
885
+
886
+ ## 4.12.0 (2015-01-22)
887
+
888
+ * The [`closetag`](http://codemirror.net/doc/manual.html#addon_closetag) addon now defines a `"closeTag"` command.
889
+ * Adds a `findModeByFileName` to the [mode metadata](http://codemirror.net/doc/manual.html#addon_meta) addon.
890
+ * [Simple mode](http://codemirror.net/demo/simplemode.html) rules can now contain a `sol` property to only match at the start of a line.
891
+ * New addon: [`selection-pointer`](http://codemirror.net/doc/manual.html#addon_selection-pointer) to style the mouse cursor over the selection.
892
+ * Improvements to the [Sass mode](http://codemirror.net/mode/sass/index.html)'s indentation.
893
+ * The [Vim keymap](http://codemirror.net/demo/vim.html)'s search functionality now supports [scrollbar annotation](http://codemirror.net/doc/manual.html#addon_matchesonscrollbar).
894
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.11.0...4.12.0).
895
+
896
+ ## 4.11.0 (2015-01-09)
897
+
898
+ Unfortunately, 4.10 did not take care of the Firefox scrolling issue entirely. This release adds two more patches to address that.
899
+
900
+ ## 4.10.0 (2014-12-29)
901
+
902
+ Emergency single-patch update to 4.9\. Fixes Firefox-specific problem where the cursor could end up behind the horizontal scrollbar.
903
+
904
+ ## 4.9.0 (2014-12-23)
905
+
906
+ * Overhauled scroll bar handling. Add pluggable [scrollbar implementations](http://codemirror.net/demo/simplescrollbars.html).
907
+ * Tweaked behavior for the [completion addons](http://codemirror.net/doc/manual.html#addon_show-hint) to not take text after cursor into account.
908
+ * Two new optional features in the [merge addon](http://codemirror.net/doc/manual.html#addon_merge): aligning editors, and folding unchanged text.
909
+ * New modes: [Dart](http://codemirror.net/mode/dart/index.html), [EBNF](http://codemirror.net/mode/ebnf/index.html), [spreadsheet](http://codemirror.net/mode/spreadsheet/index.html), and [Soy](http://codemirror.net/mode/soy/index.html).
910
+ * New [addon](http://codemirror.net/demo/panel.html) to show persistent panels below/above an editor.
911
+ * New themes: [zenburn](http://codemirror.net/demo/theme.html#zenburn) and [tomorrow night bright](http://codemirror.net/demo/theme.html#tomorrow-night-bright).
912
+ * Allow ctrl-click to clear existing cursors.
913
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.8.0...4.9.0).
914
+
915
+ ## 4.8.0 (2014-11-22)
916
+
917
+ * Built-in support for [multi-stroke key bindings](http://codemirror.net/doc/manual.html#normalizeKeyMap).
918
+ * New method: [`getLineTokens`](http://codemirror.net/doc/manual.html#getLineTokens).
919
+ * New modes: [dockerfile](http://codemirror.net/mode/dockerfile/index.html), [IDL](http://codemirror.net/mode/idl/index.html), [Objective C](http://codemirror.net/mode/clike/index.html) (crude).
920
+ * Support styling of gutter backgrounds, allow `"gutter"` styles in [`addLineClass`](http://codemirror.net/doc/manual.html#addLineClass).
921
+ * Many improvements to the [Vim mode](http://codemirror.net/demo/vim.html), rewritten visual mode.
922
+ * Improvements to modes: [gfm](http://codemirror.net/mode/gfm/index.html) (strikethrough), [SPARQL](http://codemirror.net/mode/sparql/index.html) (version 1.1 support), and [sTeX](http://codemirror.net/mode/stex/index.html) (no more runaway math mode).
923
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.7.0...4.8.0).
924
+
925
+ ## 4.7.0 (2014-10-20)
926
+
927
+ * **Incompatible**: The [lint addon](http://codemirror.net/demo/lint.html) now passes the editor's value as first argument to asynchronous lint functions, for consistency. The editor is still passed, as fourth argument.
928
+ * Improved handling of unicode identifiers in modes for languages that support them.
929
+ * More mode improvements: [CoffeeScript](http://codemirror.net/mode/coffeescript/index.html) (indentation), [Verilog](http://codemirror.net/mode/verilog/index.html) (indentation), [Scala](http://codemirror.net/mode/clike/index.html) (indentation, triple-quoted strings), and [PHP](http://codemirror.net/mode/php/index.html) (interpolated variables in heredoc strings).
930
+ * New modes: [Textile](http://codemirror.net/mode/textile/index.html) and [Tornado templates](http://codemirror.net/mode/tornado/index.html).
931
+ * Experimental new [way to define modes](http://codemirror.net/demo/simplemode.html).
932
+ * Improvements to the [Vim bindings](http://codemirror.net/demo/vim.html): Arbitrary insert mode key mappings are now possible, and text objects are supported in visual mode.
933
+ * The mode [meta-information file](http://codemirror.net/mode/meta.js) now includes information about file extensions, and [helper functions](http://codemirror.net/doc/manual.html#addon_meta) `findModeByMIME` and `findModeByExtension`.
934
+ * New logo!
935
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.6.0...4.7.0).
936
+
937
+ ## 4.6.0 (2014-09-19)
938
+
939
+ * New mode: [Modelica](http://codemirror.net/mode/modelica/index.html)
940
+ * New method: [`findWordAt`](http://codemirror.net/doc/manual.html#findWordAt)
941
+ * Make it easier to [use text background styling](http://codemirror.net/demo/markselection.html)
942
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.5.0...4.6.0).
943
+
944
+ ## 4.5.0 (2014-08-21)
945
+
946
+ * Fix several serious bugs with horizontal scrolling
947
+ * New mode: [Slim](http://codemirror.net/mode/slim/index.html)
948
+ * New command: [`goLineLeftSmart`](http://codemirror.net/doc/manual.html#command_goLineLeftSmart)
949
+ * More fixes and extensions for the [Vim](http://codemirror.net/demo/vim.html) visual block mode
950
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.4.0...4.5.0).
951
+
952
+ ## 4.4.0 (2014-07-21)
953
+
954
+ * **Note:** Some events might now fire in slightly different order (`"change"` is still guaranteed to fire before `"cursorActivity"`)
955
+ * Nested operations in multiple editors are now synced (complete at same time, reducing DOM reflows)
956
+ * Visual block mode for [vim](http://codemirror.net/demo/vim.html) (<C-v>) is nearly complete
957
+ * New mode: [Kotlin](http://codemirror.net/mode/kotlin/index.html)
958
+ * Better multi-selection paste for text copied from multiple CodeMirror selections
959
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.3.0...4.4.0).
960
+
961
+ ## 4.3.0 (2014-06-23)
962
+
963
+ * Several [vim bindings](http://codemirror.net/demo/vim.html) improvements: search and exCommand history, global flag for `:substitute`, `:global` command.
964
+ * Allow hiding the cursor by setting [`cursorBlinkRate`](http://codemirror.net/doc/manual.html#option_cursorBlinkRate) to a negative value.
965
+ * Make gutter markers themeable, use this in foldgutter.
966
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.2.0...4.3.0).
967
+
968
+ ## 4.2.0 (2014-05-19)
969
+
970
+ * Fix problem where some modes were broken by the fact that empty tokens were forbidden.
971
+ * Several fixes to context menu handling.
972
+ * On undo, scroll _change_, not cursor, into view.
973
+ * Rewritten [Jade](http://codemirror.net/mode/jade/index.html) mode.
974
+ * Various improvements to [Shell](http://codemirror.net/mode/shell/index.html) (support for more syntax) and [Python](http://codemirror.net/mode/python/index.html) (better indentation) modes.
975
+ * New mode: [Cypher](http://codemirror.net/mode/cypher/index.html).
976
+ * New theme: [Neo](http://codemirror.net/demo/theme.html#neo).
977
+ * Support direct styling options (color, line style, width) in the [rulers](http://codemirror.net/doc/manual.html#addon_rulers) addon.
978
+ * Recognize per-editor configuration for the [show-hint](http://codemirror.net/doc/manual.html#addon_show-hint) and [foldcode](http://codemirror.net/doc/manual.html#addon_foldcode) addons.
979
+ * More intelligent scanning for existing close tags in [closetag](http://codemirror.net/doc/manual.html#addon_closetag) addon.
980
+ * In the [Vim bindings](http://codemirror.net/demo/vim.html): Fix bracket matching, support case conversion in visual mode, visual paste, append action.
981
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.1.0...4.2.0).
982
+
983
+ ## 4.1.0 (2014-04-22)
984
+
985
+ * _Slightly incompatible_: The [`"cursorActivity"`](http://codemirror.net/doc/manual.html#event_cursorActivity) event now fires after all other events for the operation (and only for handlers that were actually registered at the time the activity happened).
986
+ * New command: [`insertSoftTab`](http://codemirror.net/doc/manual.html#command_insertSoftTab).
987
+ * New mode: [Django](http://codemirror.net/mode/django/index.html).
988
+ * Improved modes: [Verilog](http://codemirror.net/mode/verilog/index.html) (rewritten), [Jinja2](http://codemirror.net/mode/jinja2/index.html), [Haxe](http://codemirror.net/mode/haxe/index.html), [PHP](http://codemirror.net/mode/php/index.html) (string interpolation highlighted), [JavaScript](http://codemirror.net/mode/javascript/index.html) (indentation of trailing else, template strings), [LiveScript](http://codemirror.net/mode/livescript/index.html) (multi-line strings).
989
+ * Many small issues from the 3.x→4.x transition were found and fixed.
990
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/4.0.3...4.1.0).
991
+
992
+ ## 3.24.0 (2014-04-22)
993
+
994
+ Merges the improvements from 4.1 that could easily be applied to the 3.x code. Also improves the way the editor size is updated when line widgets change.
995
+
996
+ ## 3.23.0 (2014-03-20)
997
+
998
+ * In the [XML mode](http://codemirror.net/mode/xml/index.html), add `brackets` style to angle brackets, fix case-sensitivity of tags for HTML.
999
+ * New mode: [Dylan](http://codemirror.net/mode/dylan/index.html).
1000
+ * Many improvements to the [Vim bindings](http://codemirror.net/demo/vim.html).
1001
+
1002
+ ## 3.22.0 (2014-02-21)
1003
+
1004
+ * Adds the [`findMarks`](http://codemirror.net/doc/manual.html#findMarks) method.
1005
+ * New addons: [rulers](http://codemirror.net/doc/manual.html#addon_rulers), markdown-fold, yaml-lint.
1006
+ * New theme: [mdn-like](http://codemirror.net/demo/theme.html#mdn-like).
1007
+ * New mode: [Solr](http://codemirror.net/mode/solr/index.html).
1008
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.21.0...3.22.0).
1009
+
1010
+ ## 3.21.0 (2014-01-16)
1011
+
1012
+ * Auto-indenting a block will no longer add trailing whitespace to blank lines.
1013
+ * Marking text has a new option [`clearWhenEmpty`](http://codemirror.net/doc/manual.html#markText) to control auto-removal.
1014
+ * Several bugfixes in the handling of bidirectional text.
1015
+ * The [XML](http://codemirror.net/mode/xml/index.html) and [CSS](http://codemirror.net/mode/css/index.html) modes were largely rewritten. [LESS](http://codemirror.net/mode/css/less.html) support was added to the CSS mode.
1016
+ * The OCaml mode was moved to an [mllike](http://codemirror.net/mode/mllike/index.html) mode, F# support added.
1017
+ * Make it possible to fetch multiple applicable helper values with [`getHelpers`](http://codemirror.net/doc/manual.html#getHelpers), and to register helpers matched on predicates with [`registerGlobalHelper`](http://codemirror.net/doc/manual.html#registerGlobalHelper).
1018
+ * New theme [pastel-on-dark](http://codemirror.net/demo/theme.html#pastel-on-dark).
1019
+ * Better ECMAScript 6 support in [JavaScript](http://codemirror.net/mode/javascript/index.html) mode.
1020
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.20.0...3.21.0).
1021
+
1022
+ ## 3.20.0 (2013-11-21)
1023
+
1024
+ * New modes: [Julia](http://codemirror.net/mode/julia/index.html) and [PEG.js](http://codemirror.net/mode/pegjs/index.html).
1025
+ * Support ECMAScript 6 in the [JavaScript mode](http://codemirror.net/mode/javascript/index.html).
1026
+ * Improved indentation for the [CoffeeScript mode](http://codemirror.net/mode/coffeescript/index.html).
1027
+ * Make non-printable-character representation [configurable](http://codemirror.net/doc/manual.html#option_specialChars).
1028
+ * Add ‘notification’ functionality to [dialog](http://codemirror.net/doc/manual.html#addon_dialog) addon.
1029
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.19.0...3.20.0).
1030
+
1031
+ ## 3.19.0 (2013-10-21)
1032
+
1033
+ * New modes: [Eiffel](http://codemirror.net/mode/eiffel/index.html), [Gherkin](http://codemirror.net/mode/gherkin/index.html), [MSSQL dialect](http://codemirror.net/mode/sql/?mime=text/x-mssql).
1034
+ * New addons: [hardwrap](http://codemirror.net/doc/manual.html#addon_hardwrap), [sql-hint](http://codemirror.net/doc/manual.html#addon_sql-hint).
1035
+ * New theme: [MBO](http://codemirror.net/demo/theme.html#mbo).
1036
+ * Add [support](http://codemirror.net/doc/manual.html#token_style_line) for line-level styling from mode tokenizers.
1037
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.18.0...3.19.0).
1038
+
1039
+ ## 3.18.0 (2013-09-23)
1040
+
1041
+ Emergency release to fix a problem in 3.17 where `.setOption("lineNumbers", false)` would raise an error.
1042
+
1043
+ ## 3.17.0 (2013-09-23)
1044
+
1045
+ * New modes: [Fortran](http://codemirror.net/mode/fortran/index.html), [Octave](http://codemirror.net/mode/octave/index.html) (Matlab), [TOML](http://codemirror.net/mode/toml/index.html), and [DTD](http://codemirror.net/mode/dtd/index.html).
1046
+ * New addons: [`css-lint`](http://codemirror.net/addon/lint/css-lint.js), [`css-hint`](http://codemirror.net/doc/manual.html#addon_css-hint).
1047
+ * Improve resilience to CSS 'frameworks' that globally mess up `box-sizing`.
1048
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.16.0...3.17.0).
1049
+
1050
+ ## 3.16.0 (2013-08-21)
1051
+
1052
+ * The whole codebase is now under a single [license](http://codemirror.net/LICENSE) file.
1053
+ * The project page was overhauled and redesigned.
1054
+ * New themes: [Paraiso](http://codemirror.net/demo/theme.html#paraiso-dark) ([light](http://codemirror.net/demo/theme.html#paraiso-light)), [The Matrix](http://codemirror.net/demo/theme.html#the-matrix).
1055
+ * Improved interaction between themes and [active-line](http://codemirror.net/doc/manual.html#addon_active-line)/[matchbrackets](http://codemirror.net/doc/manual.html#addon_matchbrackets) addons.
1056
+ * New [folding](http://codemirror.net/doc/manual.html#addon_foldcode) function `CodeMirror.fold.comment`.
1057
+ * Added [fullscreen](http://codemirror.net/doc/manual.html#addon_fullscreen) addon.
1058
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.15.0...3.16.0).
1059
+
1060
+ ## 3.15.0 (2013-07-29)
1061
+
1062
+ * New modes: [Jade](http://codemirror.net/mode/jade/index.html), [Nginx](http://codemirror.net/mode/nginx/index.html).
1063
+ * New addons: [Tern](http://codemirror.net/demo/tern.html), [matchtags](http://codemirror.net/doc/manual.html#addon_matchtags), and [foldgutter](http://codemirror.net/doc/manual.html#addon_foldgutter).
1064
+ * Introduced [_helper_](http://codemirror.net/doc/manual.html#getHelper) concept ([context](https://groups.google.com/forum/#!msg/codemirror/cOc0xvUUEUU/nLrX1-qnidgJ)).
1065
+ * New method: [`getModeAt`](http://codemirror.net/doc/manual.html#getModeAt).
1066
+ * New themes: base16 [dark](http://codemirror.net/demo/theme.html#base16-dark)/[light](http://codemirror.net/demo/theme.html#base16-light), 3024 [dark](http://codemirror.net/demo/theme.html#3024-night)/[light](http://codemirror.net/demo/theme.html#3024-day), [tomorrow-night](http://codemirror.net/demo/theme.html#tomorrow-night-eighties).
1067
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.14.0...3.15.0).
1068
+
1069
+ ## 3.14.0 (2013-06-20)
1070
+
1071
+ * New addons: [trailing space highlight](http://codemirror.net/doc/manual.html#addon_trailingspace), [XML completion](http://codemirror.net/doc/manual.html#addon_xml-hint) (rewritten), and [diff merging](http://codemirror.net/doc/manual.html#addon_merge).
1072
+ * [`markText`](http://codemirror.net/doc/manual.html#markText) and [`addLineWidget`](http://codemirror.net/doc/manual.html#addLineWidget) now take a `handleMouseEvents` option.
1073
+ * New methods: [`lineAtHeight`](http://codemirror.net/doc/manual.html#lineAtHeight), [`getTokenTypeAt`](http://codemirror.net/doc/manual.html#getTokenTypeAt).
1074
+ * More precise cleanness-tracking using [`changeGeneration`](http://codemirror.net/doc/manual.html#changeGeneration) and [`isClean`](http://codemirror.net/doc/manual.html#isClean).
1075
+ * Many extensions to [Emacs](http://codemirror.net/demo/emacs.html) mode (prefixes, more navigation units, and more).
1076
+ * New events [`"keyHandled"`](http://codemirror.net/doc/manual.html#event_keyHandled) and [`"inputRead"`](http://codemirror.net/doc/manual.html#event_inputRead).
1077
+ * Various improvements to [Ruby](http://codemirror.net/mode/ruby/index.html), [Smarty](http://codemirror.net/mode/smarty/index.html), [SQL](http://codemirror.net/mode/sql/index.html), and [Vim](http://codemirror.net/demo/vim.html) modes.
1078
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/3.13.0...3.14.0).
1079
+
1080
+ ## 3.13.0 (2013-05-20)
1081
+
1082
+ * New modes: [COBOL](http://codemirror.net/mode/cobol/index.html) and [HAML](http://codemirror.net/mode/haml/index.html).
1083
+ * New options: [`cursorScrollMargin`](http://codemirror.net/doc/manual.html#option_cursorScrollMargin) and [`coverGutterNextToScrollbar`](http://codemirror.net/doc/manual.html#option_coverGutterNextToScrollbar).
1084
+ * New addon: [commenting](http://codemirror.net/doc/manual.html#addon_comment).
1085
+ * More features added to the [Vim keymap](http://codemirror.net/demo/vim.html).
1086
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v3.12...3.13.0).
1087
+
1088
+ ## 3.12.0 (2013-04-19)
1089
+
1090
+ * New mode: [GNU assembler](http://codemirror.net/mode/gas/index.html).
1091
+ * New options: [`maxHighlightLength`](http://codemirror.net/doc/manual.html#option_maxHighlightLength) and [`historyEventDelay`](http://codemirror.net/doc/manual.html#option_historyEventDelay).
1092
+ * Added [`addToHistory`](http://codemirror.net/doc/manual.html#mark_addToHistory) option for `markText`.
1093
+ * Various fixes to JavaScript tokenization and indentation corner cases.
1094
+ * Further improvements to the vim mode.
1095
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v3.11...v3.12).
1096
+
1097
+ ## 3.11.0 (2013-03-20)
1098
+
1099
+ * **Removed code:** `collapserange`, `formatting`, and `simple-hint` addons. `plsql` and `mysql` modes (use [`sql`](http://codemirror.net/mode/sql/index.html) mode).
1100
+ * **Moved code:** the range-finding functions for folding now have [their own files](http://codemirror.net/addon/fold/).
1101
+ * **Changed interface:** the [`continuecomment`](http://codemirror.net/doc/manual.html#addon_continuecomment) addon now exposes an option, rather than a command.
1102
+ * New modes: [SCSS](http://codemirror.net/mode/css/scss.html), [Tcl](http://codemirror.net/mode/tcl/index.html), [LiveScript](http://codemirror.net/mode/livescript/index.html), and [mIRC](http://codemirror.net/mode/mirc/index.html).
1103
+ * New addons: [`placeholder`](http://codemirror.net/demo/placeholder.html), [HTML completion](http://codemirror.net/demo/html5complete.html).
1104
+ * New methods: [`hasFocus`](http://codemirror.net/doc/manual.html#hasFocus), [`defaultCharWidth`](http://codemirror.net/doc/manual.html#defaultCharWidth).
1105
+ * New events: [`beforeCursorEnter`](http://codemirror.net/doc/manual.html#event_beforeCursorEnter), [`renderLine`](http://codemirror.net/doc/manual.html#event_renderLine).
1106
+ * Many improvements to the [`show-hint`](http://codemirror.net/doc/manual.html#addon_show-hint) completion dialog addon.
1107
+ * Tweak behavior of by-word cursor motion.
1108
+ * Further improvements to the [vim mode](http://codemirror.net/demo/vim.html).
1109
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v3.1...v3.11).
1110
+
1111
+ ## 3.02.0 (2013-01-25)
1112
+
1113
+ Single-bugfix release. Fixes a problem that prevents CodeMirror instances from being garbage-collected after they become unused.
1114
+
1115
+ ## 3.01.0 (2013-01-21)
1116
+
1117
+ * Move all add-ons into an organized directory structure under [`/addon`](http://codemirror.net/addon/). **You might have to adjust your paths.**
1118
+ * New modes: [D](http://codemirror.net/mode/d/index.html), [Sass](http://codemirror.net/mode/sass/index.html), [APL](http://codemirror.net/mode/apl/index.html), [SQL](http://codemirror.net/mode/sql/index.html) (configurable), and [Asterisk](http://codemirror.net/mode/asterisk/index.html).
1119
+ * Several bugfixes in right-to-left text support.
1120
+ * Add [`rtlMoveVisually`](http://codemirror.net/doc/manual.html#option_rtlMoveVisually) option.
1121
+ * Improvements to vim keymap.
1122
+ * Add built-in (lightweight) [overlay mode](http://codemirror.net/doc/manual.html#addOverlay) support.
1123
+ * Support `showIfHidden` option for [line widgets](http://codemirror.net/doc/manual.html#addLineWidget).
1124
+ * Add simple [Python hinter](http://codemirror.net/doc/manual.html#addon_python-hint).
1125
+ * Bring back the [`fixedGutter`](http://codemirror.net/doc/manual.html#option_fixedGutter) option.
1126
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v3.0...v3.01).
1127
+
1128
+ ## 3.1.0 (2013-02-21)
1129
+
1130
+ * **Incompatible:** key handlers may now _return_, rather than _throw_ `CodeMirror.Pass` to signal they didn't handle the key.
1131
+ * Make documents a [first-class construct](http://codemirror.net/doc/manual.html#api_doc), support split views and subviews.
1132
+ * Add a [new module](http://codemirror.net/doc/manual.html#addon_show-hint) for showing completion hints. Deprecate `simple-hint.js`.
1133
+ * Extend [htmlmixed mode](http://codemirror.net/mode/htmlmixed/index.html) to allow custom handling of script types.
1134
+ * Support an `insertLeft` option to [`setBookmark`](http://codemirror.net/doc/manual.html#setBookmark).
1135
+ * Add an [`eachLine`](http://codemirror.net/doc/manual.html#eachLine) method to iterate over a document.
1136
+ * New addon modules: [selection marking](http://codemirror.net/demo/markselection.html), [linting](http://codemirror.net/demo/lint.html), and [automatic bracket closing](http://codemirror.net/demo/closebrackets.html).
1137
+ * Add [`"beforeChange"`](http://codemirror.net/doc/manual.html#event_beforeChange) and [`"beforeSelectionChange"`](http://codemirror.net/doc/manual.html#event_beforeSelectionChange) events.
1138
+ * Add [`"hide"`](http://codemirror.net/doc/manual.html#event_hide) and [`"unhide"`](http://codemirror.net/doc/manual.html#event_unhide) events to marked ranges.
1139
+ * Fix [`coordsChar`](http://codemirror.net/doc/manual.html#coordsChar)'s interpretation of its argument to match the documentation.
1140
+ * New modes: [Turtle](http://codemirror.net/mode/turtle/index.html) and [Q](http://codemirror.net/mode/q/index.html).
1141
+ * Further improvements to the [vim mode](http://codemirror.net/demo/vim.html).
1142
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v3.01...v3.1).
1143
+
1144
+ ## 3.0.0 (2012-12-10)
1145
+
1146
+ **New major version**. Only partially backwards-compatible. See the [upgrading guide](http://codemirror.net/doc/upgrade_v3.html) for more information. Changes since release candidate 2:
1147
+
1148
+ * Rewritten VIM mode.
1149
+ * Fix a few minor scrolling and sizing issues.
1150
+ * Work around Safari segfault when dragging.
1151
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v3.0rc2...v3.0).
1152
+
1153
+ ## 2.38.0 (2013-01-21)
1154
+
1155
+ Integrate some bugfixes, enhancements to the vim keymap, and new modes ([D](http://codemirror.net/mode/d/index.html), [Sass](http://codemirror.net/mode/sass/index.html), [APL](http://codemirror.net/mode/apl/index.html)) from the v3 branch.
1156
+
1157
+ ## 2.37.0 (2012-12-20)
1158
+
1159
+ * New mode: [SQL](http://codemirror.net/mode/sql/index.html) (will replace [plsql](http://codemirror.net/mode/plsql/index.html) and [mysql](http://codemirror.net/mode/mysql/index.html) modes).
1160
+ * Further work on the new VIM mode.
1161
+ * Fix Cmd/Ctrl keys on recent Operas on OS X.
1162
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v2.36...v2.37).
1163
+
1164
+ ## 2.36.0 (2012-11-20)
1165
+
1166
+ * New mode: [Z80 assembly](http://codemirror.net/mode/z80/index.html).
1167
+ * New theme: [Twilight](http://codemirror.net/demo/theme.html#twilight).
1168
+ * Add command-line compression helper.
1169
+ * Make [`scrollIntoView`](http://codemirror.net/doc/manual.html#scrollIntoView) public.
1170
+ * Add [`defaultTextHeight`](http://codemirror.net/doc/manual.html#defaultTextHeight) method.
1171
+ * Various extensions to the vim keymap.
1172
+ * Make [PHP mode](http://codemirror.net/mode/php/index.html) build on [mixed HTML mode](http://codemirror.net/mode/htmlmixed/index.html).
1173
+ * Add [comment-continuing](http://codemirror.net/doc/manual.html#addon_continuecomment) add-on.
1174
+ * Full [list of patches](http://codemirror.net/https://github.com/codemirror/CodeMirror/compare/v2.35...v2.36).
1175
+
1176
+ ## 2.35.0 (2012-10-22)
1177
+
1178
+ * New (sub) mode: [TypeScript](http://codemirror.net/mode/javascript/typescript.html).
1179
+ * Don't overwrite (insert key) when pasting.
1180
+ * Fix several bugs in [`markText`](http://codemirror.net/doc/manual.html#markText)/undo interaction.
1181
+ * Better indentation of JavaScript code without semicolons.
1182
+ * Add [`defineInitHook`](http://codemirror.net/doc/manual.html#defineInitHook) function.
1183
+ * Full [list of patches](https://github.com/codemirror/CodeMirror/compare/v2.34...v2.35).
1184
+
1185
+ ## 2.34.0 (2012-09-19)
1186
+
1187
+ * New mode: [Common Lisp](http://codemirror.net/mode/commonlisp/index.html).
1188
+ * Fix right-click select-all on most browsers.
1189
+ * Change the way highlighting happens:
1190
+ Saves memory and CPU cycles.
1191
+ `compareStates` is no longer needed.
1192
+ `onHighlightComplete` no longer works.
1193
+ * Integrate mode (Markdown, XQuery, CSS, sTex) tests in central testsuite.
1194
+ * Add a [`CodeMirror.version`](http://codemirror.net/doc/manual.html#version) property.
1195
+ * More robust handling of nested modes in [formatting](http://codemirror.net/demo/formatting.html) and [closetag](http://codemirror.net/demo/closetag.html) plug-ins.
1196
+ * Un/redo now preserves [marked text](http://codemirror.net/doc/manual.html#markText) and bookmarks.
1197
+ * [Full list](https://github.com/codemirror/CodeMirror/compare/v2.33...v2.34) of patches.
1198
+
1199
+ ## 2.33.0 (2012-08-23)
1200
+
1201
+ * New mode: [Sieve](http://codemirror.net/mode/sieve/index.html).
1202
+ * New [`getViewPort`](http://codemirror.net/doc/manual.html#getViewport) and [`onViewportChange`](http://codemirror.net/doc/manual.html#option_onViewportChange) API.
1203
+ * [Configurable](http://codemirror.net/doc/manual.html#option_cursorBlinkRate) cursor blink rate.
1204
+ * Make binding a key to `false` disabling handling (again).
1205
+ * Show non-printing characters as red dots.
1206
+ * More tweaks to the scrolling model.
1207
+ * Expanded testsuite. Basic linter added.
1208
+ * Remove most uses of `innerHTML`. Remove `CodeMirror.htmlEscape`.
1209
+ * [Full list](https://github.com/codemirror/CodeMirror/compare/v2.32...v2.33) of patches.
1210
+
1211
+ ## 2.32.0 (2012-07-23)
1212
+
1213
+ Emergency fix for a bug where an editor with line wrapping on IE will break when there is _no_ scrollbar.
1214
+
1215
+ ## 2.31.0 (2012-07-20)
1216
+
1217
+ * New modes: [OCaml](http://codemirror.net/mode/ocaml/index.html), [Haxe](http://codemirror.net/mode/haxe/index.html), and [VB.NET](http://codemirror.net/mode/vb/index.html).
1218
+ * Several fixes to the new scrolling model.
1219
+ * Add a [`setSize`](http://codemirror.net/doc/manual.html#setSize) method for programmatic resizing.
1220
+ * Add [`getHistory`](http://codemirror.net/doc/manual.html#getHistory) and [`setHistory`](http://codemirror.net/doc/manual.html#setHistory) methods.
1221
+ * Allow custom line separator string in [`getValue`](http://codemirror.net/doc/manual.html#getValue) and [`getRange`](http://codemirror.net/doc/manual.html#getRange).
1222
+ * Support double- and triple-click drag, double-clicking whitespace.
1223
+ * And more... [(all patches)](https://github.com/codemirror/CodeMirror/compare/v2.3...v2.31)
1224
+
1225
+ ## 2.30.0 (2012-06-22)
1226
+
1227
+ * **New scrollbar implementation**. Should flicker less. Changes DOM structure of the editor.
1228
+ * New theme: [vibrant-ink](http://codemirror.net/demo/theme.html#vibrant-ink).
1229
+ * Many extensions to the VIM keymap (including text objects).
1230
+ * Add [mode-multiplexing](http://codemirror.net/demo/multiplex.html) utility script.
1231
+ * Fix bug where right-click paste works in read-only mode.
1232
+ * Add a [`getScrollInfo`](http://codemirror.net/doc/manual.html#getScrollInfo) method.
1233
+ * Lots of other [fixes](https://github.com/codemirror/CodeMirror/compare/v2.25...v2.3).
1234
+
1235
+ ## 2.25.0 (2012-05-23)
1236
+
1237
+ * New mode: [Erlang](http://codemirror.net/mode/erlang/index.html).
1238
+ * **Remove xmlpure mode** (use [xml.js](http://codemirror.net/mode/xml/index.html)).
1239
+ * Fix line-wrapping in Opera.
1240
+ * Fix X Windows middle-click paste in Chrome.
1241
+ * Fix bug that broke pasting of huge documents.
1242
+ * Fix backspace and tab key repeat in Opera.
1243
+
1244
+ ## 2.24.0 (2012-04-23)
1245
+
1246
+ * **Drop support for Internet Explorer 6**.
1247
+ * New modes: [Shell](http://codemirror.net/mode/shell/index.html), [Tiki wiki](http://codemirror.net/mode/tiki/index.html), [Pig Latin](http://codemirror.net/mode/pig/index.html).
1248
+ * New themes: [Ambiance](http://codemirror.net/demo/theme.html#ambiance), [Blackboard](http://codemirror.net/demo/theme.html#blackboard).
1249
+ * More control over drag/drop with [`dragDrop`](http://codemirror.net/doc/manual.html#option_dragDrop) and [`onDragEvent`](http://codemirror.net/doc/manual.html#option_onDragEvent) options.
1250
+ * Make HTML mode a bit less pedantic.
1251
+ * Add [`compoundChange`](http://codemirror.net/doc/manual.html#compoundChange) API method.
1252
+ * Several fixes in undo history and line hiding.
1253
+ * Remove (broken) support for `catchall` in key maps, add `nofallthrough` boolean field instead.
1254
+
1255
+ ## 2.23.0 (2012-03-26)
1256
+
1257
+ * Change **default binding for tab**. Starting in 2.23, these bindings are default:
1258
+ * Tab: Insert tab character
1259
+ * Shift-tab: Reset line indentation to default
1260
+ * Ctrl/Cmd-[: Reduce line indentation (old tab behaviour)
1261
+ * Ctrl/Cmd-]: Increase line indentation (old shift-tab behaviour)
1262
+ * New modes: [XQuery](http://codemirror.net/mode/xquery/index.html) and [VBScript](http://codemirror.net/mode/vbscript/index.html).
1263
+ * Two new themes: [lesser-dark](http://codemirror.net/mode/less/index.html) and [xq-dark](http://codemirror.net/mode/xquery/index.html).
1264
+ * Differentiate between background and text styles in [`setLineClass`](http://codemirror.net/doc/manual.html#setLineClass).
1265
+ * Fix drag-and-drop in IE9+.
1266
+ * Extend [`charCoords`](http://codemirror.net/doc/manual.html#charCoords) and [`cursorCoords`](http://codemirror.net/doc/manual.html#cursorCoords) with a `mode` argument.
1267
+ * Add [`autofocus`](http://codemirror.net/doc/manual.html#option_autofocus) option.
1268
+ * Add [`findMarksAt`](http://codemirror.net/doc/manual.html#findMarksAt) method.
1269
+
1270
+ ## 2.22.0 (2012-02-27)
1271
+
1272
+ * Allow [key handlers](http://codemirror.net/doc/manual.html#keymaps) to pass up events, allow binding characters.
1273
+ * Add [`autoClearEmptyLines`](http://codemirror.net/doc/manual.html#option_autoClearEmptyLines) option.
1274
+ * Properly use tab stops when rendering tabs.
1275
+ * Make PHP mode more robust.
1276
+ * Support indentation blocks in [code folder](http://codemirror.net/doc/manual.html#addon_foldcode).
1277
+ * Add a script for [highlighting instances of the selection](http://codemirror.net/doc/manual.html#addon_match-highlighter).
1278
+ * New [.properties](http://codemirror.net/mode/properties/index.html) mode.
1279
+ * Fix many bugs.
1280
+
1281
+ ## 2.21.0 (2012-01-27)
1282
+
1283
+ * Added [LESS](http://codemirror.net/mode/less/index.html), [MySQL](http://codemirror.net/mode/mysql/index.html), [Go](http://codemirror.net/mode/go/index.html), and [Verilog](http://codemirror.net/mode/verilog/index.html) modes.
1284
+ * Add [`smartIndent`](http://codemirror.net/doc/manual.html#option_smartIndent) option.
1285
+ * Support a cursor in [`readOnly`](http://codemirror.net/doc/manual.html#option_readOnly)-mode.
1286
+ * Support assigning multiple styles to a token.
1287
+ * Use a new approach to drawing the selection.
1288
+ * Add [`scrollTo`](http://codemirror.net/doc/manual.html#scrollTo) method.
1289
+ * Allow undo/redo events to span non-adjacent lines.
1290
+ * Lots and lots of bugfixes.
1291
+
1292
+ ## 2.20.0 (2011-12-20)
1293
+
1294
+ * Slightly incompatible API changes. Read [this](http://codemirror.net/doc/upgrade_v2.2.html).
1295
+ * New approach to [binding](http://codemirror.net/doc/manual.html#option_extraKeys) keys, support for [custom bindings](http://codemirror.net/doc/manual.html#option_keyMap).
1296
+ * Support for overwrite (insert).
1297
+ * [Custom-width](http://codemirror.net/doc/manual.html#option_tabSize) and [stylable](http://codemirror.net/demo/visibletabs.html) tabs.
1298
+ * Moved more code into [add-on scripts](http://codemirror.net/doc/manual.html#addons).
1299
+ * Support for sane vertical cursor movement in wrapped lines.
1300
+ * More reliable handling of editing [marked text](http://codemirror.net/doc/manual.html#markText).
1301
+ * Add minimal [emacs](http://codemirror.net/demo/emacs.html) and [vim](http://codemirror.net/demo/vim.html) bindings.
1302
+ * Rename `coordsFromIndex` to [`posFromIndex`](http://codemirror.net/doc/manual.html#posFromIndex), add [`indexFromPos`](http://codemirror.net/doc/manual.html#indexFromPos) method.
1303
+
1304
+ ## 2.18.0 (2011-11-21)
1305
+
1306
+ Fixes `TextMarker.clear`, which is broken in 2.17.
1307
+
1308
+ ## 2.17.0 (2011-11-21)
1309
+
1310
+ * Add support for [line wrapping](http://codemirror.net/doc/manual.html#option_lineWrapping) and [code folding](http://codemirror.net/doc/manual.html#hideLine).
1311
+ * Add [Github-style Markdown](http://codemirror.net/mode/gfm/index.html) mode.
1312
+ * Add [Monokai](http://codemirror.net/theme/monokai.css) and [Rubyblue](http://codemirror.net/theme/rubyblue.css) themes.
1313
+ * Add [`setBookmark`](http://codemirror.net/doc/manual.html#setBookmark) method.
1314
+ * Move some of the demo code into reusable components under [`lib/util`](http://codemirror.net/addon/).
1315
+ * Make screen-coord-finding code faster and more reliable.
1316
+ * Fix drag-and-drop in Firefox.
1317
+ * Improve support for IME.
1318
+ * Speed up content rendering.
1319
+ * Fix browser's built-in search in Webkit.
1320
+ * Make double- and triple-click work in IE.
1321
+ * Various fixes to modes.
1322
+
1323
+ ## 2.16.0 (2011-10-27)
1324
+
1325
+ * Add [Perl](http://codemirror.net/mode/perl/index.html), [Rust](http://codemirror.net/mode/rust/index.html), [TiddlyWiki](http://codemirror.net/mode/tiddlywiki/index.html), and [Groovy](http://codemirror.net/mode/groovy/index.html) modes.
1326
+ * Dragging text inside the editor now moves, rather than copies.
1327
+ * Add a [`coordsFromIndex`](http://codemirror.net/doc/manual.html#coordsFromIndex) method.
1328
+ * **API change**: `setValue` now no longer clears history. Use [`clearHistory`](http://codemirror.net/doc/manual.html#clearHistory) for that.
1329
+ * **API change**: [`markText`](http://codemirror.net/doc/manual.html#markText) now returns an object with `clear` and `find` methods. Marked text is now more robust when edited.
1330
+ * Fix editing code with tabs in Internet Explorer.
1331
+
1332
+ ## 2.15.0 (2011-09-26)
1333
+
1334
+ Fix bug that snuck into 2.14: Clicking the character that currently has the cursor didn't re-focus the editor.
1335
+
1336
+ ## 2.14.0 (2011-09-26)
1337
+
1338
+ * Add [Clojure](http://codemirror.net/mode/clojure/index.html), [Pascal](http://codemirror.net/mode/pascal/index.html), [NTriples](http://codemirror.net/mode/ntriples/index.html), [Jinja2](http://codemirror.net/mode/jinja2/index.html), and [Markdown](http://codemirror.net/mode/markdown/index.html) modes.
1339
+ * Add [Cobalt](http://codemirror.net/theme/cobalt.css) and [Eclipse](http://codemirror.net/theme/eclipse.css) themes.
1340
+ * Add a [`fixedGutter`](http://codemirror.net/doc/manual.html#option_fixedGutter) option.
1341
+ * Fix bug with `setValue` breaking cursor movement.
1342
+ * Make gutter updates much more efficient.
1343
+ * Allow dragging of text out of the editor (on modern browsers).
1344
+
1345
+ ## 2.13.0 (2011-08-23)
1346
+
1347
+ * Add [Ruby](http://codemirror.net/mode/ruby/index.html), [R](http://codemirror.net/mode/r/index.html), [CoffeeScript](http://codemirror.net/mode/coffeescript/index.html), and [Velocity](http://codemirror.net/mode/velocity/index.html) modes.
1348
+ * Add [`getGutterElement`](http://codemirror.net/doc/manual.html#getGutterElement) to API.
1349
+ * Several fixes to scrolling and positioning.
1350
+ * Add [`smartHome`](http://codemirror.net/doc/manual.html#option_smartHome) option.
1351
+ * Add an experimental [pure XML](http://codemirror.net/mode/xmlpure/index.html) mode.
1352
+
1353
+ ## 2.12.0 (2011-07-25)
1354
+
1355
+ * Add a [SPARQL](http://codemirror.net/mode/sparql/index.html) mode.
1356
+ * Fix bug with cursor jumping around in an unfocused editor in IE.
1357
+ * Allow key and mouse events to bubble out of the editor. Ignore widget clicks.
1358
+ * Solve cursor flakiness after undo/redo.
1359
+ * Fix block-reindent ignoring the last few lines.
1360
+ * Fix parsing of multi-line attrs in XML mode.
1361
+ * Use `innerHTML` for HTML-escaping.
1362
+ * Some fixes to indentation in C-like mode.
1363
+ * Shrink horiz scrollbars when long lines removed.
1364
+ * Fix width feedback loop bug that caused the width of an inner DIV to shrink.
1365
+
1366
+ ## 2.11.0 (2011-07-04)
1367
+
1368
+ * Add a [Scheme mode](http://codemirror.net/mode/scheme/index.html).
1369
+ * Add a `replace` method to search cursors, for cursor-preserving replacements.
1370
+ * Make the [C-like mode](http://codemirror.net/mode/clike/index.html) mode more customizable.
1371
+ * Update XML mode to spot mismatched tags.
1372
+ * Add `getStateAfter` API and `compareState` mode API methods for finer-grained mode magic.
1373
+ * Add a `getScrollerElement` API method to manipulate the scrolling DIV.
1374
+ * Fix drag-and-drop for Firefox.
1375
+ * Add a C# configuration for the [C-like mode](http://codemirror.net/mode/clike/index.html).
1376
+ * Add [full-screen editing](http://codemirror.net/demo/fullscreen.html) and [mode-changing](http://codemirror.net/demo/changemode.html) demos.
1377
+
1378
+ ## 2.10.0 (2011-06-07)
1379
+
1380
+ Add a [theme](http://codemirror.net/doc/manual.html#option_theme) system ([demo](http://codemirror.net/demo/theme.html)). Note that this is not backwards-compatible—you'll have to update your styles and modes!
1381
+
1382
+ ## 2.2.0 (2011-06-07)
1383
+
1384
+ * Add a [Lua mode](http://codemirror.net/mode/lua/index.html).
1385
+ * Fix reverse-searching for a regexp.
1386
+ * Empty lines can no longer break highlighting.
1387
+ * Rework scrolling model (the outer wrapper no longer does the scrolling).
1388
+ * Solve horizontal jittering on long lines.
1389
+ * Add [runmode.js](http://codemirror.net/demo/runmode.html).
1390
+ * Immediately re-highlight text when typing.
1391
+ * Fix problem with 'sticking' horizontal scrollbar.
1392
+
1393
+ ## 2.1.0 (2011-05-26)
1394
+
1395
+ * Add a [Smalltalk mode](http://codemirror.net/mode/smalltalk/index.html).
1396
+ * Add a [reStructuredText mode](http://codemirror.net/mode/rst/index.html).
1397
+ * Add a [Python mode](http://codemirror.net/mode/python/index.html).
1398
+ * Add a [PL/SQL mode](http://codemirror.net/mode/plsql/index.html).
1399
+ * `coordsChar` now works
1400
+ * Fix a problem where `onCursorActivity` interfered with `onChange`.
1401
+ * Fix a number of scrolling and mouse-click-position glitches.
1402
+ * Pass information about the changed lines to `onChange`.
1403
+ * Support cmd-up/down on OS X.
1404
+ * Add triple-click line selection.
1405
+ * Don't handle shift when changing the selection through the API.
1406
+ * Support `"nocursor"` mode for `readOnly` option.
1407
+ * Add an `onHighlightComplete` option.
1408
+ * Fix the context menu for Firefox.
1409
+
1410
+ ## 2.0.0 (2011-03-28)
1411
+
1412
+ CodeMirror 2 is a complete rewrite that's faster, smaller, simpler to use, and less dependent on browser quirks. See [this](http://codemirror.net/doc/internals.html) and [this](http://groups.google.com/group/codemirror/browse_thread/thread/5a8e894024a9f580) for more information.
inc/lib/codemirror/CONTRIBUTING.md ADDED
@@ -0,0 +1,92 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # How to contribute
2
+
3
+ - [Getting help](#getting-help)
4
+ - [Submitting bug reports](#submitting-bug-reports)
5
+ - [Contributing code](#contributing-code)
6
+
7
+ ## Getting help
8
+
9
+ Community discussion, questions, and informal bug reporting is done on the
10
+ [discuss.CodeMirror forum](http://discuss.codemirror.net).
11
+
12
+ ## Submitting bug reports
13
+
14
+ The preferred way to report bugs is to use the
15
+ [GitHub issue tracker](http://github.com/codemirror/CodeMirror/issues). Before
16
+ reporting a bug, read these pointers.
17
+
18
+ **Note:** The issue tracker is for *bugs*, not requests for help. Questions
19
+ should be asked on the
20
+ [discuss.CodeMirror forum](http://discuss.codemirror.net) instead.
21
+
22
+ ### Reporting bugs effectively
23
+
24
+ - CodeMirror is maintained by volunteers. They don't owe you anything, so be
25
+ polite. Reports with an indignant or belligerent tone tend to be moved to the
26
+ bottom of the pile.
27
+
28
+ - Include information about **the browser in which the problem occurred**. Even
29
+ if you tested several browsers, and the problem occurred in all of them,
30
+ mention this fact in the bug report. Also include browser version numbers and
31
+ the operating system that you're on.
32
+
33
+ - Mention which release of CodeMirror you're using. Preferably, try also with
34
+ the current development snapshot, to ensure the problem has not already been
35
+ fixed.
36
+
37
+ - Mention very precisely what went wrong. "X is broken" is not a good bug
38
+ report. What did you expect to happen? What happened instead? Describe the
39
+ exact steps a maintainer has to take to make the problem occur. We can not
40
+ fix something that we can not observe.
41
+
42
+ - If the problem can not be reproduced in any of the demos included in the
43
+ CodeMirror distribution, please provide an HTML document that demonstrates
44
+ the problem. The best way to do this is to go to
45
+ [jsbin.com](http://jsbin.com/ihunin/edit), enter it there, press save, and
46
+ include the resulting link in your bug report.
47
+
48
+ ## Contributing code
49
+
50
+ Note that we are not accepting any new addons or modes into the main
51
+ distribution. If you've written such a module, please distribute it as
52
+ a separate NPM package.
53
+
54
+ - Make sure you have a [GitHub Account](https://github.com/signup/free)
55
+ - Fork [CodeMirror](https://github.com/codemirror/CodeMirror/)
56
+ ([how to fork a repo](https://help.github.com/articles/fork-a-repo))
57
+ - Make your changes
58
+ - If your changes are easy to test or likely to regress, add tests.
59
+ Tests for the core go into `test/test.js`, some modes have their own
60
+ test suite under `mode/XXX/test.js`. Feel free to add new test
61
+ suites to modes that don't have one yet (be sure to link the new
62
+ tests into `test/index.html`).
63
+ - Follow the general code style of the rest of the project (see
64
+ below). Run `bin/lint` to verify that the linter is happy.
65
+ - Make sure all tests pass. Visit `test/index.html` in your browser to
66
+ run them.
67
+ - Submit a pull request
68
+ ([how to create a pull request](https://help.github.com/articles/fork-a-repo)).
69
+ Don't put more than one feature/fix in a single pull request.
70
+
71
+ By contributing code to CodeMirror you
72
+
73
+ - agree to license the contributed code under CodeMirror's [MIT
74
+ license](http://codemirror.net/LICENSE).
75
+
76
+ - confirm that you have the right to contribute and license the code
77
+ in question. (Either you hold all rights on the code, or the rights
78
+ holder has explicitly granted the right to use it like this,
79
+ through a compatible open source license or through a direct
80
+ agreement with you.)
81
+
82
+ ### Coding standards
83
+
84
+ - 2 spaces per indentation level, no tabs.
85
+
86
+ - Note that the linter (`bin/lint`) which is run after each commit
87
+ complains about unused variables and functions. Prefix their names
88
+ with an underscore to muffle it.
89
+
90
+ - CodeMirror does *not* follow JSHint or JSLint prescribed style.
91
+ Patches that try to 'fix' code to pass one of these linters will be
92
+ unceremoniously discarded.
inc/lib/codemirror/LICENSE CHANGED
@@ -1,4 +1,6 @@
1
- Copyright (C) 2016 by Marijn Haverbeke <marijnh@gmail.com> and others
 
 
2
 
3
  Permission is hereby granted, free of charge, to any person obtaining a copy
4
  of this software and associated documentation files (the "Software"), to deal
1
+ MIT License
2
+
3
+ Copyright (C) 2017 by Marijn Haverbeke <marijnh@gmail.com> and others
4
 
5
  Permission is hereby granted, free of charge, to any person obtaining a copy
6
  of this software and associated documentation files (the "Software"), to deal
inc/lib/codemirror/README.md CHANGED
@@ -1,4 +1,5 @@
1
  # CodeMirror
 
2
  [![Build Status](https://travis-ci.org/codemirror/CodeMirror.svg)](https://travis-ci.org/codemirror/CodeMirror)
3
  [![NPM version](https://img.shields.io/npm/v/codemirror.svg)](https://www.npmjs.org/package/codemirror)
4
  [![Join the chat at https://gitter.im/codemirror/CodeMirror](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/codemirror/CodeMirror)
@@ -7,7 +8,8 @@
7
  CodeMirror is a versatile text editor implemented in JavaScript for
8
  the browser. It is specialized for editing code, and comes with over
9
  100 language modes and various addons that implement more advanced
10
- editing functionality.
 
11
 
12
  A rich programming API and a CSS theming system are available for
13
  customizing CodeMirror to fit your application, and extending it with
@@ -26,3 +28,22 @@ The CodeMirror community aims to be welcoming to everybody. We use the
26
  [Contributor Covenant
27
  (1.1)](http://contributor-covenant.org/version/1/1/0/) as our code of
28
  conduct.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  # CodeMirror
2
+
3
  [![Build Status](https://travis-ci.org/codemirror/CodeMirror.svg)](https://travis-ci.org/codemirror/CodeMirror)
4
  [![NPM version](https://img.shields.io/npm/v/codemirror.svg)](https://www.npmjs.org/package/codemirror)
5
  [![Join the chat at https://gitter.im/codemirror/CodeMirror](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/codemirror/CodeMirror)
8
  CodeMirror is a versatile text editor implemented in JavaScript for
9
  the browser. It is specialized for editing code, and comes with over
10
  100 language modes and various addons that implement more advanced
11
+ editing functionality. Every language comes with fully-featured code
12
+ and syntax highlighting to help with reading and editing complex code.
13
 
14
  A rich programming API and a CSS theming system are available for
15
  customizing CodeMirror to fit your application, and extending it with
28
  [Contributor Covenant
29
  (1.1)](http://contributor-covenant.org/version/1/1/0/) as our code of
30
  conduct.
31
+
32
+ ### Installation
33
+
34
+ Either get the [zip file](https://codemirror.net/codemirror.zip) with
35
+ the latest version, or make sure you have [Node](https://nodejs.org/)
36
+ installed and run:
37
+
38
+ npm install codemirror
39
+
40
+ **NOTE**: This is the source repository for the library, and not the
41
+ distribution channel. Cloning it is not the recommended way to install
42
+ the library, and will in fact not work unless you also run the build
43
+ step.
44
+
45
+ ### Quickstart
46
+
47
+ To build the project, make sure you have Node.js installed (at least version 6)
48
+ and then `npm install`. To run, just open `index.html` in your
49
+ browser (you don't need to run a webserver). Run the tests with `npm test`.
inc/lib/codemirror/{addons → addon/selection}/active-line.js RENAMED
@@ -1,12 +1,6 @@
1
  // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
  // Distributed under an MIT license: http://codemirror.net/LICENSE
3
 
4
- // Because sometimes you need to style the cursor's line.
5
- //
6
- // Adds an option 'styleActiveLine' which, when enabled, gives the
7
- // active line's wrapping <div> the CSS class "CodeMirror-activeline",
8
- // and gives its background <div> the class "CodeMirror-activeline-background".
9
-
10
  (function(mod) {
11
  if (typeof exports == "object" && typeof module == "object") // CommonJS
12
  mod(require("../../lib/codemirror"));
@@ -21,16 +15,18 @@
21
  var GUTT_CLASS = "CodeMirror-activeline-gutter";
22
 
23
  CodeMirror.defineOption("styleActiveLine", false, function(cm, val, old) {
24
- var prev = old && old != CodeMirror.Init;
25
- if (val && !prev) {
26
- cm.state.activeLines = [];
27
- updateActiveLines(cm, cm.listSelections());
28
- cm.on("beforeSelectionChange", selectionChange);
29
- } else if (!val && prev) {
30
  cm.off("beforeSelectionChange", selectionChange);
31
  clearActiveLines(cm);
32
  delete cm.state.activeLines;
33
  }
 
 
 
 
 
34
  });
35
 
36
  function clearActiveLines(cm) {
@@ -52,7 +48,9 @@
52
  var active = [];
53
  for (var i = 0; i < ranges.length; i++) {
54
  var range = ranges[i];
55
- if (!range.empty()) continue;
 
 
56
  var line = cm.getLineHandleVisualStart(range.head.line);
57
  if (active[active.length - 1] != line) active.push(line);
58
  }
1
  // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
  // Distributed under an MIT license: http://codemirror.net/LICENSE
3
 
 
 
 
 
 
 
4
  (function(mod) {
5
  if (typeof exports == "object" && typeof module == "object") // CommonJS
6
  mod(require("../../lib/codemirror"));
15
  var GUTT_CLASS = "CodeMirror-activeline-gutter";
16
 
17
  CodeMirror.defineOption("styleActiveLine", false, function(cm, val, old) {
18
+ var prev = old == CodeMirror.Init ? false : old;
19
+ if (val == prev) return
20
+ if (prev) {
 
 
 
21
  cm.off("beforeSelectionChange", selectionChange);
22
  clearActiveLines(cm);
23
  delete cm.state.activeLines;
24
  }
25
+ if (val) {
26
+ cm.state.activeLines = [];
27
+ updateActiveLines(cm, cm.listSelections());
28
+ cm.on("beforeSelectionChange", selectionChange);
29
+ }
30
  });
31
 
32
  function clearActiveLines(cm) {
48
  var active = [];
49
  for (var i = 0; i < ranges.length; i++) {
50
  var range = ranges[i];
51
+ var option = cm.getOption("styleActiveLine");
52
+ if (typeof option == "object" && option.nonEmpty ? range.anchor.line != range.head.line : !range.empty())
53
+ continue
54
  var line = cm.getLineHandleVisualStart(range.head.line);
55
  if (active[active.length - 1] != line) active.push(line);
56
  }
inc/lib/codemirror/codemirror.js DELETED
@@ -1,8935 +0,0 @@
1
- // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
- // Distributed under an MIT license: http://codemirror.net/LICENSE
3
-
4
- // This is CodeMirror (http://codemirror.net), a code editor
5
- // implemented in JavaScript on top of the browser's DOM.
6
- //
7
- // You can find some technical background for some of the code below
8
- // at http://marijnhaverbeke.nl/blog/#cm-internals .
9
-
10
- (function(mod) {
11
- if (typeof exports == "object" && typeof module == "object") // CommonJS
12
- module.exports = mod();
13
- else if (typeof define == "function" && define.amd) // AMD
14
- return define([], mod);
15
- else // Plain browser env
16
- (this || window).CodeMirror = mod();
17
- })(function() {
18
- "use strict";
19
-
20
- // BROWSER SNIFFING
21
-
22
- // Kludges for bugs and behavior differences that can't be feature
23
- // detected are enabled based on userAgent etc sniffing.
24
- var userAgent = navigator.userAgent;
25
- var platform = navigator.platform;
26
-
27
- var gecko = /gecko\/\d/i.test(userAgent);
28
- var ie_upto10 = /MSIE \d/.test(userAgent);
29
- var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent);
30
- var ie = ie_upto10 || ie_11up;
31
- var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1]);
32
- var webkit = /WebKit\//.test(userAgent);
33
- var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent);
34
- var chrome = /Chrome\//.test(userAgent);
35
- var presto = /Opera\//.test(userAgent);
36
- var safari = /Apple Computer/.test(navigator.vendor);
37
- var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent);
38
- var phantom = /PhantomJS/.test(userAgent);
39
-
40
- var ios = /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent);
41
- // This is woefully incomplete. Suggestions for alternative methods welcome.
42
- var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);
43
- var mac = ios || /Mac/.test(platform);
44
- var chromeOS = /\bCrOS\b/.test(userAgent);
45
- var windows = /win/i.test(platform);
46
-
47
- var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/);
48
- if (presto_version) presto_version = Number(presto_version[1]);
49
- if (presto_version && presto_version >= 15) { presto = false; webkit = true; }
50
- // Some browsers use the wrong event properties to signal cmd/ctrl on OS X
51
- var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));
52
- var captureRightClick = gecko || (ie && ie_version >= 9);
53
-
54
- // Optimize some code when these features are not used.
55
- var sawReadOnlySpans = false, sawCollapsedSpans = false;
56
-
57
- // EDITOR CONSTRUCTOR
58
-
59
- // A CodeMirror instance represents an editor. This is the object
60
- // that user code is usually dealing with.
61
-
62
- function CodeMirror(place, options) {
63
- if (!(this instanceof CodeMirror)) return new CodeMirror(place, options);
64
-
65
- this.options = options = options ? copyObj(options) : {};
66
- // Determine effective options based on given values and defaults.
67
- copyObj(defaults, options, false);
68
- setGuttersForLineNumbers(options);
69
-
70
- var doc = options.value;
71
- if (typeof doc == "string") doc = new Doc(doc, options.mode, null, options.lineSeparator);
72
- this.doc = doc;
73
-
74
- var input = new CodeMirror.inputStyles[options.inputStyle](this);
75
- var display = this.display = new Display(place, doc, input);
76
- display.wrapper.CodeMirror = this;
77
- updateGutters(this);
78
- themeChanged(this);
79
- if (options.lineWrapping)
80
- this.display.wrapper.className += " CodeMirror-wrap";
81
- if (options.autofocus && !mobile) display.input.focus();
82
- initScrollbars(this);
83
-
84
- this.state = {
85
- keyMaps: [], // stores maps added by addKeyMap
86
- overlays: [], // highlighting overlays, as added by addOverlay
87
- modeGen: 0, // bumped when mode/overlay changes, used to invalidate highlighting info
88
- overwrite: false,
89
- delayingBlurEvent: false,
90
- focused: false,
91
- suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
92
- pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll
93
- selectingText: false,
94
- draggingText: false,
95
- highlight: new Delayed(), // stores highlight worker timeout
96
- keySeq: null, // Unfinished key sequence
97
- specialChars: null
98
- };
99
-
100
- var cm = this;
101
-
102
- // Override magic textarea content restore that IE sometimes does
103
- // on our hidden textarea on reload
104
- if (ie && ie_version < 11) setTimeout(function() { cm.display.input.reset(true); }, 20);
105
-
106
- registerEventHandlers(this);
107
- ensureGlobalHandlers();
108
-
109
- startOperation(this);
110
- this.curOp.forceUpdate = true;
111
- attachDoc(this, doc);
112
-
113
- if ((options.autofocus && !mobile) || cm.hasFocus())
114
- setTimeout(bind(onFocus, this), 20);
115
- else
116
- onBlur(this);
117
-
118
- for (var opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))
119
- optionHandlers[opt](this, options[opt], Init);
120
- maybeUpdateLineNumberWidth(this);
121
- if (options.finishInit) options.finishInit(this);
122
- for (var i = 0; i < initHooks.length; ++i) initHooks[i](this);
123
- endOperation(this);
124
- // Suppress optimizelegibility in Webkit, since it breaks text
125
- // measuring on line wrapping boundaries.
126
- if (webkit && options.lineWrapping &&
127
- getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
128
- display.lineDiv.style.textRendering = "auto";
129
- }
130
-
131
- // DISPLAY CONSTRUCTOR
132
-
133
- // The display handles the DOM integration, both for input reading
134
- // and content drawing. It holds references to DOM nodes and
135
- // display-related state.
136
-
137
- function Display(place, doc, input) {
138
- var d = this;
139
- this.input = input;
140
-
141
- // Covers bottom-right square when both scrollbars are present.
142
- d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");
143
- d.scrollbarFiller.setAttribute("cm-not-content", "true");
144
- // Covers bottom of gutter when coverGutterNextToScrollbar is on
145
- // and h scrollbar is present.
146
- d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler");
147
- d.gutterFiller.setAttribute("cm-not-content", "true");
148
- // Will contain the actual code, positioned to cover the viewport.
149
- d.lineDiv = elt("div", null, "CodeMirror-code");
150
- // Elements are added to these to represent selection and cursors.
151
- d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");
152
- d.cursorDiv = elt("div", null, "CodeMirror-cursors");
153
- // A visibility: hidden element used to find the size of things.
154
- d.measure = elt("div", null, "CodeMirror-measure");
155
- // When lines outside of the viewport are measured, they are drawn in this.
156
- d.lineMeasure = elt("div", null, "CodeMirror-measure");
157
- // Wraps everything that needs to exist inside the vertically-padded coordinate system
158
- d.lineSpace = elt("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
159
- null, "position: relative; outline: none");
160
- // Moved around its parent to cover visible view.
161
- d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative");
162
- // Set to the height of the document, allowing scrolling.
163
- d.sizer = elt("div", [d.mover], "CodeMirror-sizer");
164
- d.sizerWidth = null;
165
- // Behavior of elts with overflow: auto and padding is
166
- // inconsistent across browsers. This is used to ensure the
167
- // scrollable area is big enough.
168
- d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;");
169
- // Will contain the gutters, if any.
170
- d.gutters = elt("div", null, "CodeMirror-gutters");
171
- d.lineGutter = null;
172
- // Actual scrollable element.
173
- d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll");
174
- d.scroller.setAttribute("tabIndex", "-1");
175
- // The element in which the editor lives.
176
- d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror");
177
-
178
- // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
179
- if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }
180
- if (!webkit && !(gecko && mobile)) d.scroller.draggable = true;
181
-
182
- if (place) {
183
- if (place.appendChild) place.appendChild(d.wrapper);
184
- else place(d.wrapper);
185
- }
186
-
187
- // Current rendered range (may be bigger than the view window).
188
- d.viewFrom = d.viewTo = doc.first;
189
- d.reportedViewFrom = d.reportedViewTo = doc.first;
190
- // Information about the rendered lines.
191
- d.view = [];
192
- d.renderedView = null;
193
- // Holds info about a single rendered line when it was rendered
194
- // for measurement, while not in view.
195
- d.externalMeasured = null;
196
- // Empty space (in pixels) above the view
197
- d.viewOffset = 0;
198
- d.lastWrapHeight = d.lastWrapWidth = 0;
199
- d.updateLineNumbers = null;
200
-
201
- d.nativeBarWidth = d.barHeight = d.barWidth = 0;
202
- d.scrollbarsClipped = false;
203
-
204
- // Used to only resize the line number gutter when necessary (when
205
- // the amount of lines crosses a boundary that makes its width change)
206
- d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;
207
- // Set to true when a non-horizontal-scrolling line widget is
208
- // added. As an optimization, line widget aligning is skipped when
209
- // this is false.
210
- d.alignWidgets = false;
211
-
212
- d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
213
-
214
- // Tracks the maximum line length so that the horizontal scrollbar
215
- // can be kept static when scrolling.
216
- d.maxLine = null;
217
- d.maxLineLength = 0;
218
- d.maxLineChanged = false;
219
-
220
- // Used for measuring wheel scrolling granularity
221
- d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;
222
-
223
- // True when shift is held down.
224
- d.shift = false;
225
-
226
- // Used to track whether anything happened since the context menu
227
- // was opened.
228
- d.selForContextMenu = null;
229
-
230
- d.activeTouch = null;
231
-
232
- input.init(d);
233
- }
234
-
235
- // STATE UPDATES
236
-
237
- // Used to get the editor into a consistent state again when options change.
238
-
239
- function loadMode(cm) {
240
- cm.doc.mode = CodeMirror.getMode(cm.options, cm.doc.modeOption);
241
- resetModeState(cm);
242
- }
243
-
244
- function resetModeState(cm) {
245
- cm.doc.iter(function(line) {
246
- if (line.stateAfter) line.stateAfter = null;
247
- if (line.styles) line.styles = null;
248
- });
249
- cm.doc.frontier = cm.doc.first;
250
- startWorker(cm, 100);
251
- cm.state.modeGen++;
252
- if (cm.curOp) regChange(cm);
253
- }
254
-
255
- function wrappingChanged(cm) {
256
- if (cm.options.lineWrapping) {
257
- addClass(cm.display.wrapper, "CodeMirror-wrap");
258
- cm.display.sizer.style.minWidth = "";
259
- cm.display.sizerWidth = null;
260
- } else {
261
- rmClass(cm.display.wrapper, "CodeMirror-wrap");
262
- findMaxLine(cm);
263
- }
264
- estimateLineHeights(cm);
265
- regChange(cm);
266
- clearCaches(cm);
267
- setTimeout(function(){updateScrollbars(cm);}, 100);
268
- }
269
-
270
- // Returns a function that estimates the height of a line, to use as
271
- // first approximation until the line becomes visible (and is thus
272
- // properly measurable).
273
- function estimateHeight(cm) {
274
- var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;
275
- var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);
276
- return function(line) {
277
- if (lineIsHidden(cm.doc, line)) return 0;
278
-
279
- var widgetsHeight = 0;
280
- if (line.widgets) for (var i = 0; i < line.widgets.length; i++) {
281
- if (line.widgets[i].height) widgetsHeight += line.widgets[i].height;
282
- }
283
-
284
- if (wrapping)
285
- return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th;
286
- else
287
- return widgetsHeight + th;
288
- };
289
- }
290
-
291
- function estimateLineHeights(cm) {
292
- var doc = cm.doc, est = estimateHeight(cm);
293
- doc.iter(function(line) {
294
- var estHeight = est(line);
295
- if (estHeight != line.height) updateLineHeight(line, estHeight);
296
- });
297
- }
298
-
299
- function themeChanged(cm) {
300
- cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
301
- cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");
302
- clearCaches(cm);
303
- }
304
-
305
- function guttersChanged(cm) {
306
- updateGutters(cm);
307
- regChange(cm);
308
- setTimeout(function(){alignHorizontally(cm);}, 20);
309
- }
310
-
311
- // Rebuild the gutter elements, ensure the margin to the left of the
312
- // code matches their width.
313
- function updateGutters(cm) {
314
- var gutters = cm.display.gutters, specs = cm.options.gutters;
315
- removeChildren(gutters);
316
- for (var i = 0; i < specs.length; ++i) {
317
- var gutterClass = specs[i];
318
- var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass));
319
- if (gutterClass == "CodeMirror-linenumbers") {
320
- cm.display.lineGutter = gElt;
321
- gElt.style.width = (cm.display.lineNumWidth || 1) + "px";
322
- }
323
- }
324
- gutters.style.display = i ? "" : "none";
325
- updateGutterSpace(cm);
326
- }
327
-
328
- function updateGutterSpace(cm) {
329
- var width = cm.display.gutters.offsetWidth;
330
- cm.display.sizer.style.marginLeft = width + "px";
331
- }
332
-
333
- // Compute the character length of a line, taking into account
334
- // collapsed ranges (see markText) that might hide parts, and join
335
- // other lines onto it.
336
- function lineLength(line) {
337
- if (line.height == 0) return 0;
338
- var len = line.text.length, merged, cur = line;
339
- while (merged = collapsedSpanAtStart(cur)) {
340
- var found = merged.find(0, true);
341
- cur = found.from.line;
342
- len += found.from.ch - found.to.ch;
343
- }
344
- cur = line;
345
- while (merged = collapsedSpanAtEnd(cur)) {
346
- var found = merged.find(0, true);
347
- len -= cur.text.length - found.from.ch;
348
- cur = found.to.line;
349
- len += cur.text.length - found.to.ch;
350
- }
351
- return len;
352
- }
353
-
354
- // Find the longest line in the document.
355
- function findMaxLine(cm) {
356
- var d = cm.display, doc = cm.doc;
357
- d.maxLine = getLine(doc, doc.first);
358
- d.maxLineLength = lineLength(d.maxLine);
359
- d.maxLineChanged = true;
360
- doc.iter(function(line) {
361
- var len = lineLength(line);
362
- if (len > d.maxLineLength) {
363
- d.maxLineLength = len;
364
- d.maxLine = line;
365
- }
366
- });
367
- }
368
-
369
- // Make sure the gutters options contains the element
370
- // "CodeMirror-linenumbers" when the lineNumbers option is true.
371
- function setGuttersForLineNumbers(options) {
372
- var found = indexOf(options.gutters, "CodeMirror-linenumbers");
373
- if (found == -1 && options.lineNumbers) {
374
- options.gutters = options.gutters.concat(["CodeMirror-linenumbers"]);
375
- } else if (found > -1 && !options.lineNumbers) {
376
- options.gutters = options.gutters.slice(0);
377
- options.gutters.splice(found, 1);
378
- }
379
- }
380
-
381
- // SCROLLBARS
382
-
383
- // Prepare DOM reads needed to update the scrollbars. Done in one
384
- // shot to minimize update/measure roundtrips.
385
- function measureForScrollbars(cm) {
386
- var d = cm.display, gutterW = d.gutters.offsetWidth;
387
- var docH = Math.round(cm.doc.height + paddingVert(cm.display));
388
- return {
389
- clientHeight: d.scroller.clientHeight,
390
- viewHeight: d.wrapper.clientHeight,
391
- scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
392
- viewWidth: d.wrapper.clientWidth,
393
- barLeft: cm.options.fixedGutter ? gutterW : 0,
394
- docHeight: docH,
395
- scrollHeight: docH + scrollGap(cm) + d.barHeight,
396
- nativeBarWidth: d.nativeBarWidth,
397
- gutterWidth: gutterW
398
- };
399
- }
400
-
401
- function NativeScrollbars(place, scroll, cm) {
402
- this.cm = cm;
403
- var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar");
404
- var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar");
405
- place(vert); place(horiz);
406
-
407
- on(vert, "scroll", function() {
408
- if (vert.clientHeight) scroll(vert.scrollTop, "vertical");
409
- });
410
- on(horiz, "scroll", function() {
411
- if (horiz.clientWidth) scroll(horiz.scrollLeft, "horizontal");
412
- });
413
-
414
- this.checkedZeroWidth = false;
415
- // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
416
- if (ie && ie_version < 8) this.horiz.style.minHeight = this.vert.style.minWidth = "18px";
417
- }
418
-
419
- NativeScrollbars.prototype = copyObj({
420
- update: function(measure) {
421
- var needsH = measure.scrollWidth > measure.clientWidth + 1;
422
- var needsV = measure.scrollHeight > measure.clientHeight + 1;
423
- var sWidth = measure.nativeBarWidth;
424
-
425
- if (needsV) {
426
- this.vert.style.display = "block";
427
- this.vert.style.bottom = needsH ? sWidth + "px" : "0";
428
- var totalHeight = measure.viewHeight - (needsH ? sWidth : 0);
429
- // A bug in IE8 can cause this value to be negative, so guard it.
430
- this.vert.firstChild.style.height =
431
- Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px";
432
- } else {
433
- this.vert.style.display = "";
434
- this.vert.firstChild.style.height = "0";
435
- }
436
-
437
- if (needsH) {
438
- this.horiz.style.display = "block";
439
- this.horiz.style.right = needsV ? sWidth + "px" : "0";
440
- this.horiz.style.left = measure.barLeft + "px";
441
- var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);
442
- this.horiz.firstChild.style.width =
443
- (measure.scrollWidth - measure.clientWidth + totalWidth) + "px";
444
- } else {
445
- this.horiz.style.display = "";
446
- this.horiz.firstChild.style.width = "0";
447
- }
448
-
449
- if (!this.checkedZeroWidth && measure.clientHeight > 0) {
450
- if (sWidth == 0) this.zeroWidthHack();
451
- this.checkedZeroWidth = true;
452
- }
453
-
454
- return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0};
455
- },
456
- setScrollLeft: function(pos) {
457
- if (this.horiz.scrollLeft != pos) this.horiz.scrollLeft = pos;
458
- if (this.disableHoriz) this.enableZeroWidthBar(this.horiz, this.disableHoriz);
459
- },
460
- setScrollTop: function(pos) {
461
- if (this.vert.scrollTop != pos) this.vert.scrollTop = pos;
462
- if (this.disableVert) this.enableZeroWidthBar(this.vert, this.disableVert);
463
- },
464
- zeroWidthHack: function() {
465
- var w = mac && !mac_geMountainLion ? "12px" : "18px";
466
- this.horiz.style.height = this.vert.style.width = w;
467
- this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none";
468
- this.disableHoriz = new Delayed;
469
- this.disableVert = new Delayed;
470
- },
471
- enableZeroWidthBar: function(bar, delay) {
472
- bar.style.pointerEvents = "auto";
473
- function maybeDisable() {
474
- // To find out whether the scrollbar is still visible, we
475
- // check whether the element under the pixel in the bottom
476
- // left corner of the scrollbar box is the scrollbar box
477
- // itself (when the bar is still visible) or its filler child
478
- // (when the bar is hidden). If it is still visible, we keep
479
- // it enabled, if it's hidden, we disable pointer events.
480
- var box = bar.getBoundingClientRect();
481
- var elt = document.elementFromPoint(box.left + 1, box.bottom - 1);
482
- if (elt != bar) bar.style.pointerEvents = "none";
483
- else delay.set(1000, maybeDisable);
484
- }
485
- delay.set(1000, maybeDisable);
486
- },
487
- clear: function() {
488
- var parent = this.horiz.parentNode;
489
- parent.removeChild(this.horiz);
490
- parent.removeChild(this.vert);
491
- }
492
- }, NativeScrollbars.prototype);
493
-
494
- function NullScrollbars() {}
495
-
496
- NullScrollbars.prototype = copyObj({
497
- update: function() { return {bottom: 0, right: 0}; },
498
- setScrollLeft: function() {},
499
- setScrollTop: function() {},
500
- clear: function() {}
501
- }, NullScrollbars.prototype);
502
-
503
- CodeMirror.scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars};
504
-
505
- function initScrollbars(cm) {
506
- if (cm.display.scrollbars) {
507
- cm.display.scrollbars.clear();
508
- if (cm.display.scrollbars.addClass)
509
- rmClass(cm.display.wrapper, cm.display.scrollbars.addClass);
510
- }
511
-
512
- cm.display.scrollbars = new CodeMirror.scrollbarModel[cm.options.scrollbarStyle](function(node) {
513
- cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller);
514
- // Prevent clicks in the scrollbars from killing focus
515
- on(node, "mousedown", function() {
516
- if (cm.state.focused) setTimeout(function() { cm.display.input.focus(); }, 0);
517
- });
518
- node.setAttribute("cm-not-content", "true");
519
- }, function(pos, axis) {
520
- if (axis == "horizontal") setScrollLeft(cm, pos);
521
- else setScrollTop(cm, pos);
522
- }, cm);
523
- if (cm.display.scrollbars.addClass)
524
- addClass(cm.display.wrapper, cm.display.scrollbars.addClass);
525
- }
526
-
527
- function updateScrollbars(cm, measure) {
528
- if (!measure) measure = measureForScrollbars(cm);
529
- var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight;
530
- updateScrollbarsInner(cm, measure);
531
- for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {
532
- if (startWidth != cm.display.barWidth && cm.options.lineWrapping)
533
- updateHeightsInViewport(cm);
534
- updateScrollbarsInner(cm, measureForScrollbars(cm));
535
- startWidth = cm.display.barWidth; startHeight = cm.display.barHeight;
536
- }
537
- }
538
-
539
- // Re-synchronize the fake scrollbars with the actual size of the
540
- // content.
541
- function updateScrollbarsInner(cm, measure) {
542
- var d = cm.display;
543
- var sizes = d.scrollbars.update(measure);
544
-
545
- d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px";
546
- d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px";
547
- d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent"
548
-
549
- if (sizes.right && sizes.bottom) {
550
- d.scrollbarFiller.style.display = "block";
551
- d.scrollbarFiller.style.height = sizes.bottom + "px";
552
- d.scrollbarFiller.style.width = sizes.right + "px";
553
- } else d.scrollbarFiller.style.display = "";
554
- if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
555
- d.gutterFiller.style.display = "block";
556
- d.gutterFiller.style.height = sizes.bottom + "px";
557
- d.gutterFiller.style.width = measure.gutterWidth + "px";
558
- } else d.gutterFiller.style.display = "";
559
- }
560
-
561
- // Compute the lines that are visible in a given viewport (defaults
562
- // the the current scroll position). viewport may contain top,
563
- // height, and ensure (see op.scrollToPos) properties.
564
- function visibleLines(display, doc, viewport) {
565
- var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop;
566
- top = Math.floor(top - paddingTop(display));
567
- var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight;
568
-
569
- var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom);
570
- // Ensure is a {from: {line, ch}, to: {line, ch}} object, and
571
- // forces those lines into the viewport (if possible).
572
- if (viewport && viewport.ensure) {
573
- var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line;
574
- if (ensureFrom < from) {
575
- from = ensureFrom;
576
- to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight);
577
- } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
578
- from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight);
579
- to = ensureTo;
580
- }
581
- }
582
- return {from: from, to: Math.max(to, from + 1)};
583
- }
584
-
585
- // LINE NUMBERS
586
-
587
- // Re-align line numbers and gutter marks to compensate for
588
- // horizontal scrolling.
589
- function alignHorizontally(cm) {
590
- var display = cm.display, view = display.view;
591
- if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return;
592
- var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;
593
- var gutterW = display.gutters.offsetWidth, left = comp + "px";
594
- for (var i = 0; i < view.length; i++) if (!view[i].hidden) {
595
- if (cm.options.fixedGutter && view[i].gutter)
596
- view[i].gutter.style.left = left;
597
- var align = view[i].alignable;
598
- if (align) for (var j = 0; j < align.length; j++)
599
- align[j].style.left = left;
600
- }
601
- if (cm.options.fixedGutter)
602
- display.gutters.style.left = (comp + gutterW) + "px";
603
- }
604
-
605
- // Used to ensure that the line number gutter is still the right
606
- // size for the current document size. Returns true when an update
607
- // is needed.
608
- function maybeUpdateLineNumberWidth(cm) {
609
- if (!cm.options.lineNumbers) return false;
610
- var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display;
611
- if (last.length != display.lineNumChars) {
612
- var test = display.measure.appendChild(elt("div", [elt("div", last)],
613
- "CodeMirror-linenumber CodeMirror-gutter-elt"));
614
- var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;
615
- display.lineGutter.style.width = "";
616
- display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1;
617
- display.lineNumWidth = display.lineNumInnerWidth + padding;
618
- display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;
619
- display.lineGutter.style.width = display.lineNumWidth + "px";
620
- updateGutterSpace(cm);
621
- return true;
622
- }
623
- return false;
624
- }
625
-
626
- function lineNumberFor(options, i) {
627
- return String(options.lineNumberFormatter(i + options.firstLineNumber));
628
- }
629
-
630
- // Computes display.scroller.scrollLeft + display.gutters.offsetWidth,
631
- // but using getBoundingClientRect to get a sub-pixel-accurate
632
- // result.
633
- function compensateForHScroll(display) {
634
- return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left;
635
- }
636
-
637
- // DISPLAY DRAWING
638
-
639
- function DisplayUpdate(cm, viewport, force) {
640
- var display = cm.display;
641
-
642
- this.viewport = viewport;
643
- // Store some values that we'll need later (but don't want to force a relayout for)
644
- this.visible = visibleLines(display, cm.doc, viewport);
645
- this.editorIsHidden = !display.wrapper.offsetWidth;
646
- this.wrapperHeight = display.wrapper.clientHeight;
647
- this.wrapperWidth = display.wrapper.clientWidth;
648
- this.oldDisplayWidth = displayWidth(cm);
649
- this.force = force;
650
- this.dims = getDimensions(cm);
651
- this.events = [];
652
- }
653
-
654
- DisplayUpdate.prototype.signal = function(emitter, type) {
655
- if (hasHandler(emitter, type))
656
- this.events.push(arguments);
657
- };
658
- DisplayUpdate.prototype.finish = function() {
659
- for (var i = 0; i < this.events.length; i++)
660
- signal.apply(null, this.events[i]);
661
- };
662
-
663
- function maybeClipScrollbars(cm) {
664
- var display = cm.display;
665
- if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
666
- display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth;
667
- display.heightForcer.style.height = scrollGap(cm) + "px";
668
- display.sizer.style.marginBottom = -display.nativeBarWidth + "px";
669
- display.sizer.style.borderRightWidth = scrollGap(cm) + "px";
670
- display.scrollbarsClipped = true;
671
- }
672
- }
673
-
674
- // Does the actual updating of the line display. Bails out
675
- // (returning false) when there is nothing to be done and forced is
676
- // false.
677
- function updateDisplayIfNeeded(cm, update) {
678
- var display = cm.display, doc = cm.doc;
679
-
680
- if (update.editorIsHidden) {
681
- resetView(cm);
682
- return false;
683
- }
684
-
685
- // Bail out if the visible area is already rendered and nothing changed.
686
- if (!update.force &&
687
- update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
688
- (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
689
- display.renderedView == display.view && countDirtyView(cm) == 0)
690
- return false;
691
-
692
- if (maybeUpdateLineNumberWidth(cm)) {
693
- resetView(cm);
694
- update.dims = getDimensions(cm);
695
- }
696
-
697
- // Compute a suitable new viewport (from & to)
698
- var end = doc.first + doc.size;
699
- var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first);
700
- var to = Math.min(end, update.visible.to + cm.options.viewportMargin);
701
- if (display.viewFrom < from && from - display.viewFrom < 20) from = Math.max(doc.first, display.viewFrom);
702
- if (display.viewTo > to && display.viewTo - to < 20) to = Math.min(end, display.viewTo);
703
- if (sawCollapsedSpans) {
704
- from = visualLineNo(cm.doc, from);
705
- to = visualLineEndNo(cm.doc, to);
706
- }
707
-
708
- var different = from != display.viewFrom || to != display.viewTo ||
709
- display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth;
710
- adjustView(cm, from, to);
711
-
712
- display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom));
713
- // Position the mover div to align with the current scroll position
714
- cm.display.mover.style.top = display.viewOffset + "px";
715
-
716
- var toUpdate = countDirtyView(cm);
717
- if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
718
- (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
719
- return false;
720
-
721
- // For big changes, we hide the enclosing element during the
722
- // update, since that speeds up the operations on most browsers.
723
- var focused = activeElt();
724
- if (toUpdate > 4) display.lineDiv.style.display = "none";
725
- patchDisplay(cm, display.updateLineNumbers, update.dims);
726
- if (toUpdate > 4) display.lineDiv.style.display = "";
727
- display.renderedView = display.view;
728
- // There might have been a widget with a focused element that got
729
- // hidden or updated, if so re-focus it.
730
- if (focused && activeElt() != focused && focused.offsetHeight) focused.focus();
731
-
732
- // Prevent selection and cursors from interfering with the scroll
733
- // width and height.
734
- removeChildren(display.cursorDiv);
735
- removeChildren(display.selectionDiv);
736
- display.gutters.style.height = display.sizer.style.minHeight = 0;
737
-
738
- if (different) {
739
- display.lastWrapHeight = update.wrapperHeight;
740
- display.lastWrapWidth = update.wrapperWidth;
741
- startWorker(cm, 400);
742
- }
743
-
744
- display.updateLineNumbers = null;
745
-
746
- return true;
747
- }
748
-
749
- function postUpdateDisplay(cm, update) {
750
- var viewport = update.viewport;
751
-
752
- for (var first = true;; first = false) {
753
- if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {
754
- // Clip forced viewport to actual scrollable area.
755
- if (viewport && viewport.top != null)
756
- viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)};
757
- // Updated line heights might result in the drawn area not
758
- // actually covering the viewport. Keep looping until it does.
759
- update.visible = visibleLines(cm.display, cm.doc, viewport);
760
- if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
761
- break;
762
- }
763
- if (!updateDisplayIfNeeded(cm, update)) break;
764
- updateHeightsInViewport(cm);
765
- var barMeasure = measureForScrollbars(cm);
766
- updateSelection(cm);
767
- updateScrollbars(cm, barMeasure);
768
- setDocumentHeight(cm, barMeasure);
769
- }
770
-
771
- update.signal(cm, "update", cm);
772
- if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
773
- update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo);
774
- cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo;
775
- }
776
- }
777
-
778
- function updateDisplaySimple(cm, viewport) {
779
- var update = new DisplayUpdate(cm, viewport);
780
- if (updateDisplayIfNeeded(cm, update)) {
781
- updateHeightsInViewport(cm);
782
- postUpdateDisplay(cm, update);
783
- var barMeasure = measureForScrollbars(cm);
784
- updateSelection(cm);
785
- updateScrollbars(cm, barMeasure);
786
- setDocumentHeight(cm, barMeasure);
787
- update.finish();
788
- }
789
- }
790
-
791
- function setDocumentHeight(cm, measure) {
792
- cm.display.sizer.style.minHeight = measure.docHeight + "px";
793
- cm.display.heightForcer.style.top = measure.docHeight + "px";
794
- cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px";
795
- }
796
-
797
- // Read the actual heights of the rendered lines, and update their
798
- // stored heights to match.
799
- function updateHeightsInViewport(cm) {
800
- var display = cm.display;
801
- var prevBottom = display.lineDiv.offsetTop;
802
- for (var i = 0; i < display.view.length; i++) {
803
- var cur = display.view[i], height;
804
- if (cur.hidden) continue;
805
- if (ie && ie_version < 8) {
806
- var bot = cur.node.offsetTop + cur.node.offsetHeight;
807
- height = bot - prevBottom;
808
- prevBottom = bot;
809
- } else {
810
- var box = cur.node.getBoundingClientRect();
811
- height = box.bottom - box.top;
812
- }
813
- var diff = cur.line.height - height;
814
- if (height < 2) height = textHeight(display);
815
- if (diff > .001 || diff < -.001) {
816
- updateLineHeight(cur.line, height);
817
- updateWidgetHeight(cur.line);
818
- if (cur.rest) for (var j = 0; j < cur.rest.length; j++)
819
- updateWidgetHeight(cur.rest[j]);
820
- }
821
- }
822
- }
823
-
824
- // Read and store the height of line widgets associated with the
825
- // given line.
826
- function updateWidgetHeight(line) {
827
- if (line.widgets) for (var i = 0; i < line.widgets.length; ++i)
828
- line.widgets[i].height = line.widgets[i].node.parentNode.offsetHeight;
829
- }
830
-
831
- // Do a bulk-read of the DOM positions and sizes needed to draw the
832
- // view, so that we don't interleave reading and writing to the DOM.
833
- function getDimensions(cm) {
834
- var d = cm.display, left = {}, width = {};
835
- var gutterLeft = d.gutters.clientLeft;
836
- for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
837
- left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft;
838
- width[cm.options.gutters[i]] = n.clientWidth;
839
- }
840
- return {fixedPos: compensateForHScroll(d),
841
- gutterTotalWidth: d.gutters.offsetWidth,
842
- gutterLeft: left,
843
- gutterWidth: width,
844
- wrapperWidth: d.wrapper.clientWidth};
845
- }
846
-
847
- // Sync the actual display DOM structure with display.view, removing
848
- // nodes for lines that are no longer in view, and creating the ones
849
- // that are not there yet, and updating the ones that are out of
850
- // date.
851
- function patchDisplay(cm, updateNumbersFrom, dims) {
852
- var display = cm.display, lineNumbers = cm.options.lineNumbers;
853
- var container = display.lineDiv, cur = container.firstChild;
854
-
855
- function rm(node) {
856
- var next = node.nextSibling;
857
- // Works around a throw-scroll bug in OS X Webkit
858
- if (webkit && mac && cm.display.currentWheelTarget == node)
859
- node.style.display = "none";
860
- else
861
- node.parentNode.removeChild(node);
862
- return next;
863
- }
864
-
865
- var view = display.view, lineN = display.viewFrom;
866
- // Loop over the elements in the view, syncing cur (the DOM nodes
867
- // in display.lineDiv) with the view as we go.
868
- for (var i = 0; i < view.length; i++) {
869
- var lineView = view[i];
870
- if (lineView.hidden) {
871
- } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet
872
- var node = buildLineElement(cm, lineView, lineN, dims);
873
- container.insertBefore(node, cur);
874
- } else { // Already drawn
875
- while (cur != lineView.node) cur = rm(cur);
876
- var updateNumber = lineNumbers && updateNumbersFrom != null &&
877
- updateNumbersFrom <= lineN && lineView.lineNumber;
878
- if (lineView.changes) {
879
- if (indexOf(lineView.changes, "gutter") > -1) updateNumber = false;
880
- updateLineForChanges(cm, lineView, lineN, dims);
881
- }
882
- if (updateNumber) {
883
- removeChildren(lineView.lineNumber);
884
- lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)));
885
- }
886
- cur = lineView.node.nextSibling;
887
- }
888
- lineN += lineView.size;
889
- }
890
- while (cur) cur = rm(cur);
891
- }
892
-
893
- // When an aspect of a line changes, a string is added to
894
- // lineView.changes. This updates the relevant part of the line's
895
- // DOM structure.
896
- function updateLineForChanges(cm, lineView, lineN, dims) {
897
- for (var j = 0; j < lineView.changes.length; j++) {
898
- var type = lineView.changes[j];
899
- if (type == "text") updateLineText(cm, lineView);
900
- else if (type == "gutter") updateLineGutter(cm, lineView, lineN, dims);
901
- else if (type == "class") updateLineClasses(lineView);
902
- else if (type == "widget") updateLineWidgets(cm, lineView, dims);
903
- }
904
- lineView.changes = null;
905
- }
906
-
907
- // Lines with gutter elements, widgets or a background class need to
908
- // be wrapped, and have the extra elements added to the wrapper div
909
- function ensureLineWrapped(lineView) {
910
- if (lineView.node == lineView.text) {
911
- lineView.node = elt("div", null, null, "position: relative");
912
- if (lineView.text.parentNode)
913
- lineView.text.parentNode.replaceChild(lineView.node, lineView.text);
914
- lineView.node.appendChild(lineView.text);
915
- if (ie && ie_version < 8) lineView.node.style.zIndex = 2;
916
- }
917
- return lineView.node;
918
- }
919
-
920
- function updateLineBackground(lineView) {
921
- var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass;
922
- if (cls) cls += " CodeMirror-linebackground";
923
- if (lineView.background) {
924
- if (cls) lineView.background.className = cls;
925
- else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null; }
926
- } else if (cls) {
927
- var wrap = ensureLineWrapped(lineView);
928
- lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild);
929
- }
930
- }
931
-
932
- // Wrapper around buildLineContent which will reuse the structure
933
- // in display.externalMeasured when possible.
934
- function getLineContent(cm, lineView) {
935
- var ext = cm.display.externalMeasured;
936
- if (ext && ext.line == lineView.line) {
937
- cm.display.externalMeasured = null;
938
- lineView.measure = ext.measure;
939
- return ext.built;
940
- }
941
- return buildLineContent(cm, lineView);
942
- }
943
-
944
- // Redraw the line's text. Interacts with the background and text
945
- // classes because the mode may output tokens that influence these
946
- // classes.
947
- function updateLineText(cm, lineView) {
948
- var cls = lineView.text.className;
949
- var built = getLineContent(cm, lineView);
950
- if (lineView.text == lineView.node) lineView.node = built.pre;
951
- lineView.text.parentNode.replaceChild(built.pre, lineView.text);
952
- lineView.text = built.pre;
953
- if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
954
- lineView.bgClass = built.bgClass;
955
- lineView.textClass = built.textClass;
956
- updateLineClasses(lineView);
957
- } else if (cls) {
958
- lineView.text.className = cls;
959
- }
960
- }
961
-
962
- function updateLineClasses(lineView) {
963
- updateLineBackground(lineView);
964
- if (lineView.line.wrapClass)
965
- ensureLineWrapped(lineView).className = lineView.line.wrapClass;
966
- else if (lineView.node != lineView.text)
967
- lineView.node.className = "";
968
- var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass;
969
- lineView.text.className = textClass || "";
970
- }
971
-
972
- function updateLineGutter(cm, lineView, lineN, dims) {
973
- if (lineView.gutter) {
974
- lineView.node.removeChild(lineView.gutter);
975
- lineView.gutter = null;
976
- }
977
- if (lineView.gutterBackground) {
978
- lineView.node.removeChild(lineView.gutterBackground);
979
- lineView.gutterBackground = null;
980
- }
981
- if (lineView.line.gutterClass) {
982
- var wrap = ensureLineWrapped(lineView);
983
- lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass,
984
- "left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) +
985
- "px; width: " + dims.gutterTotalWidth + "px");
986
- wrap.insertBefore(lineView.gutterBackground, lineView.text);
987
- }
988
- var markers = lineView.line.gutterMarkers;
989
- if (cm.options.lineNumbers || markers) {
990
- var wrap = ensureLineWrapped(lineView);
991
- var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", "left: " +
992
- (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px");
993
- cm.display.input.setUneditable(gutterWrap);
994
- wrap.insertBefore(gutterWrap, lineView.text);
995
- if (lineView.line.gutterClass)
996
- gutterWrap.className += " " + lineView.line.gutterClass;
997
- if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
998
- lineView.lineNumber = gutterWrap.appendChild(
999
- elt("div", lineNumberFor(cm.options, lineN),
1000
- "CodeMirror-linenumber CodeMirror-gutter-elt",
1001
- "left: " + dims.gutterLeft["CodeMirror-linenumbers"] + "px; width: "
1002
- + cm.display.lineNumInnerWidth + "px"));
1003
- if (markers) for (var k = 0; k < cm.options.gutters.length; ++k) {
1004
- var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id];
1005
- if (found)
1006
- gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", "left: " +
1007
- dims.gutterLeft[id] + "px; width: " + dims.gutterWidth[id] + "px"));
1008
- }
1009
- }
1010
- }
1011
-
1012
- function updateLineWidgets(cm, lineView, dims) {
1013
- if (lineView.alignable) lineView.alignable = null;
1014
- for (var node = lineView.node.firstChild, next; node; node = next) {
1015
- var next = node.nextSibling;
1016
- if (node.className == "CodeMirror-linewidget")
1017
- lineView.node.removeChild(node);
1018
- }
1019
- insertLineWidgets(cm, lineView, dims);
1020
- }
1021
-
1022
- // Build a line's DOM representation from scratch
1023
- function buildLineElement(cm, lineView, lineN, dims) {
1024
- var built = getLineContent(cm, lineView);
1025
- lineView.text = lineView.node = built.pre;
1026
- if (built.bgClass) lineView.bgClass = built.bgClass;
1027
- if (built.textClass) lineView.textClass = built.textClass;
1028
-
1029
- updateLineClasses(lineView);
1030
- updateLineGutter(cm, lineView, lineN, dims);
1031
- insertLineWidgets(cm, lineView, dims);
1032
- return lineView.node;
1033
- }
1034
-
1035
- // A lineView may contain multiple logical lines (when merged by
1036
- // collapsed spans). The widgets for all of them need to be drawn.
1037
- function insertLineWidgets(cm, lineView, dims) {
1038
- insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);
1039
- if (lineView.rest) for (var i = 0; i < lineView.rest.length; i++)
1040
- insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false);
1041
- }
1042
-
1043
- function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
1044
- if (!line.widgets) return;
1045
- var wrap = ensureLineWrapped(lineView);
1046
- for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
1047
- var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget");
1048
- if (!widget.handleMouseEvents) node.setAttribute("cm-ignore-events", "true");
1049
- positionLineWidget(widget, node, lineView, dims);
1050
- cm.display.input.setUneditable(node);
1051
- if (allowAbove && widget.above)
1052
- wrap.insertBefore(node, lineView.gutter || lineView.text);
1053
- else
1054
- wrap.appendChild(node);
1055
- signalLater(widget, "redraw");
1056
- }
1057
- }
1058
-
1059
- function positionLineWidget(widget, node, lineView, dims) {
1060
- if (widget.noHScroll) {
1061
- (lineView.alignable || (lineView.alignable = [])).push(node);
1062
- var width = dims.wrapperWidth;
1063
- node.style.left = dims.fixedPos + "px";
1064
- if (!widget.coverGutter) {
1065
- width -= dims.gutterTotalWidth;
1066
- node.style.paddingLeft = dims.gutterTotalWidth + "px";
1067
- }
1068
- node.style.width = width + "px";
1069
- }
1070
- if (widget.coverGutter) {
1071
- node.style.zIndex = 5;
1072
- node.style.position = "relative";
1073
- if (!widget.noHScroll) node.style.marginLeft = -dims.gutterTotalWidth + "px";
1074
- }
1075
- }
1076
-
1077
- // POSITION OBJECT
1078
-
1079
- // A Pos instance represents a position within the text.
1080
- var Pos = CodeMirror.Pos = function(line, ch) {
1081
- if (!(this instanceof Pos)) return new Pos(line, ch);
1082
- this.line = line; this.ch = ch;
1083
- };
1084
-
1085
- // Compare two positions, return 0 if they are the same, a negative
1086
- // number when a is less, and a positive number otherwise.
1087
- var cmp = CodeMirror.cmpPos = function(a, b) { return a.line - b.line || a.ch - b.ch; };
1088
-
1089
- function copyPos(x) {return Pos(x.line, x.ch);}
1090
- function maxPos(a, b) { return cmp(a, b) < 0 ? b : a; }
1091
- function minPos(a, b) { return cmp(a, b) < 0 ? a : b; }
1092
-
1093
- // INPUT HANDLING
1094
-
1095
- function ensureFocus(cm) {
1096
- if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm); }
1097
- }
1098
-
1099
- // This will be set to a {lineWise: bool, text: [string]} object, so
1100
- // that, when pasting, we know what kind of selections the copied
1101
- // text was made out of.
1102
- var lastCopied = null;
1103
-
1104
- function applyTextInput(cm, inserted, deleted, sel, origin) {
1105
- var doc = cm.doc;
1106
- cm.display.shift = false;
1107
- if (!sel) sel = doc.sel;
1108
-
1109
- var paste = cm.state.pasteIncoming || origin == "paste";
1110
- var textLines = doc.splitLines(inserted), multiPaste = null
1111
- // When pasing N lines into N selections, insert one line per selection
1112
- if (paste && sel.ranges.length > 1) {
1113
- if (lastCopied && lastCopied.text.join("\n") == inserted) {
1114
- if (sel.ranges.length % lastCopied.text.length == 0) {
1115
- multiPaste = [];
1116
- for (var i = 0; i < lastCopied.text.length; i++)
1117
- multiPaste.push(doc.splitLines(lastCopied.text[i]));
1118
- }
1119
- } else if (textLines.length == sel.ranges.length) {
1120
- multiPaste = map(textLines, function(l) { return [l]; });
1121
- }
1122
- }
1123
-
1124
- // Normal behavior is to insert the new text into every selection
1125
- for (var i = sel.ranges.length - 1; i >= 0; i--) {
1126
- var range = sel.ranges[i];
1127
- var from = range.from(), to = range.to();
1128
- if (range.empty()) {
1129
- if (deleted && deleted > 0) // Handle deletion
1130
- from = Pos(from.line, from.ch - deleted);
1131
- else if (cm.state.overwrite && !paste) // Handle overwrite
1132
- to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length));
1133
- else if (lastCopied && lastCopied.lineWise && lastCopied.text.join("\n") == inserted)
1134
- from = to = Pos(from.line, 0)
1135
- }
1136
- var updateInput = cm.curOp.updateInput;
1137
- var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i % multiPaste.length] : textLines,
1138
- origin: origin || (paste ? "paste" : cm.state.cutIncoming ? "cut" : "+input")};
1139
- makeChange(cm.doc, changeEvent);
1140
- signalLater(cm, "inputRead", cm, changeEvent);
1141
- }
1142
- if (inserted && !paste)
1143
- triggerElectric(cm, inserted);
1144
-
1145
- ensureCursorVisible(cm);
1146
- cm.curOp.updateInput = updateInput;
1147
- cm.curOp.typing = true;
1148
- cm.state.pasteIncoming = cm.state.cutIncoming = false;
1149
- }
1150
-
1151
- function handlePaste(e, cm) {
1152
- var pasted = e.clipboardData && e.clipboardData.getData("text/plain");
1153
- if (pasted) {
1154
- e.preventDefault();
1155
- if (!cm.isReadOnly() && !cm.options.disableInput)
1156
- runInOp(cm, function() { applyTextInput(cm, pasted, 0, null, "paste"); });
1157
- return true;
1158
- }
1159
- }
1160
-
1161
- function triggerElectric(cm, inserted) {
1162
- // When an 'electric' character is inserted, immediately trigger a reindent
1163
- if (!cm.options.electricChars || !cm.options.smartIndent) return;
1164
- var sel = cm.doc.sel;
1165
-
1166
- for (var i = sel.ranges.length - 1; i >= 0; i--) {
1167
- var range = sel.ranges[i];
1168
- if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) continue;
1169
- var mode = cm.getModeAt(range.head);
1170
- var indented = false;
1171
- if (mode.electricChars) {
1172
- for (var j = 0; j < mode.electricChars.length; j++)
1173
- if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
1174
- indented = indentLine(cm, range.head.line, "smart");
1175
- break;
1176
- }
1177
- } else if (mode.electricInput) {
1178
- if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))
1179
- indented = indentLine(cm, range.head.line, "smart");
1180
- }
1181
- if (indented) signalLater(cm, "electricInput", cm, range.head.line);
1182
- }
1183
- }
1184
-
1185
- function copyableRanges(cm) {
1186
- var text = [], ranges = [];
1187
- for (var i = 0; i < cm.doc.sel.ranges.length; i++) {
1188
- var line = cm.doc.sel.ranges[i].head.line;
1189
- var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)};
1190
- ranges.push(lineRange);
1191
- text.push(cm.getRange(lineRange.anchor, lineRange.head));
1192
- }
1193
- return {text: text, ranges: ranges};
1194
- }
1195
-
1196
- function disableBrowserMagic(field) {
1197
- field.setAttribute("autocorrect", "off");
1198
- field.setAttribute("autocapitalize", "off");
1199
- field.setAttribute("spellcheck", "false");
1200
- }
1201
-
1202
- // TEXTAREA INPUT STYLE
1203
-
1204
- function TextareaInput(cm) {
1205
- this.cm = cm;
1206
- // See input.poll and input.reset
1207
- this.prevInput = "";
1208
-
1209
- // Flag that indicates whether we expect input to appear real soon
1210
- // now (after some event like 'keypress' or 'input') and are
1211
- // polling intensively.
1212
- this.pollingFast = false;
1213
- // Self-resetting timeout for the poller
1214
- this.polling = new Delayed();
1215
- // Tracks when input.reset has punted to just putting a short
1216
- // string into the textarea instead of the full selection.
1217
- this.inaccurateSelection = false;
1218
- // Used to work around IE issue with selection being forgotten when focus moves away from textarea
1219
- this.hasSelection = false;
1220
- this.composing = null;
1221
- };
1222
-
1223
- function hiddenTextarea() {
1224
- var te = elt("textarea", null, null, "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none");
1225
- var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;");
1226
- // The textarea is kept positioned near the cursor to prevent the
1227
- // fact that it'll be scrolled into view on input from scrolling
1228
- // our fake cursor out of view. On webkit, when wrap=off, paste is
1229
- // very slow. So make the area wide instead.
1230
- if (webkit) te.style.width = "1000px";
1231
- else te.setAttribute("wrap", "off");
1232
- // If border: 0; -- iOS fails to open keyboard (issue #1287)
1233
- if (ios) te.style.border = "1px solid black";
1234
- disableBrowserMagic(te);
1235
- return div;
1236
- }
1237
-
1238
- TextareaInput.prototype = copyObj({
1239
- init: function(display) {
1240
- var input = this, cm = this.cm;
1241
-
1242
- // Wraps and hides input textarea
1243
- var div = this.wrapper = hiddenTextarea();
1244
- // The semihidden textarea that is focused when the editor is
1245
- // focused, and receives input.
1246
- var te = this.textarea = div.firstChild;
1247
- display.wrapper.insertBefore(div, display.wrapper.firstChild);
1248
-
1249
- // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
1250
- if (ios) te.style.width = "0px";
1251
-
1252
- on(te, "input", function() {
1253
- if (ie && ie_version >= 9 && input.hasSelection) input.hasSelection = null;
1254
- input.poll();
1255
- });
1256
-
1257
- on(te, "paste", function(e) {
1258
- if (signalDOMEvent(cm, e) || handlePaste(e, cm)) return
1259
-
1260
- cm.state.pasteIncoming = true;
1261
- input.fastPoll();
1262
- });
1263
-
1264
- function prepareCopyCut(e) {
1265
- if (signalDOMEvent(cm, e)) return
1266
- if (cm.somethingSelected()) {
1267
- lastCopied = {lineWise: false, text: cm.getSelections()};
1268
- if (input.inaccurateSelection) {
1269
- input.prevInput = "";
1270
- input.inaccurateSelection = false;
1271
- te.value = lastCopied.text.join("\n");
1272
- selectInput(te);
1273
- }
1274
- } else if (!cm.options.lineWiseCopyCut) {
1275
- return;
1276
- } else {
1277
- var ranges = copyableRanges(cm);
1278
- lastCopied = {lineWise: true, text: ranges.text};
1279
- if (e.type == "cut") {
1280
- cm.setSelections(ranges.ranges, null, sel_dontScroll);
1281
- } else {
1282
- input.prevInput = "";
1283
- te.value = ranges.text.join("\n");
1284
- selectInput(te);
1285
- }
1286
- }
1287
- if (e.type == "cut") cm.state.cutIncoming = true;
1288
- }
1289
- on(te, "cut", prepareCopyCut);
1290
- on(te, "copy", prepareCopyCut);
1291
-
1292
- on(display.scroller, "paste", function(e) {
1293
- if (eventInWidget(display, e) || signalDOMEvent(cm, e)) return;
1294
- cm.state.pasteIncoming = true;
1295
- input.focus();
1296
- });
1297
-
1298
- // Prevent normal selection in the editor (we handle our own)
1299
- on(display.lineSpace, "selectstart", function(e) {
1300
- if (!eventInWidget(display, e)) e_preventDefault(e);
1301
- });
1302
-
1303
- on(te, "compositionstart", function() {
1304
- var start = cm.getCursor("from");
1305
- if (input.composing) input.composing.range.clear()
1306
- input.composing = {
1307
- start: start,
1308
- range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"})
1309
- };
1310
- });
1311
- on(te, "compositionend", function() {
1312
- if (input.composing) {
1313
- input.poll();
1314
- input.composing.range.clear();
1315
- input.composing = null;
1316
- }
1317
- });
1318
- },
1319
-
1320
- prepareSelection: function() {
1321
- // Redraw the selection and/or cursor
1322
- var cm = this.cm, display = cm.display, doc = cm.doc;
1323
- var result = prepareSelection(cm);
1324
-
1325
- // Move the hidden textarea near the cursor to prevent scrolling artifacts
1326
- if (cm.options.moveInputWithCursor) {
1327
- var headPos = cursorCoords(cm, doc.sel.primary().head, "div");
1328
- var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect();
1329
- result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
1330
- headPos.top + lineOff.top - wrapOff.top));
1331
- result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
1332
- headPos.left + lineOff.left - wrapOff.left));
1333
- }
1334
-
1335
- return result;
1336
- },
1337
-
1338
- showSelection: function(drawn) {
1339
- var cm = this.cm, display = cm.display;
1340
- removeChildrenAndAdd(display.cursorDiv, drawn.cursors);
1341
- removeChildrenAndAdd(display.selectionDiv, drawn.selection);
1342
- if (drawn.teTop != null) {
1343
- this.wrapper.style.top = drawn.teTop + "px";
1344
- this.wrapper.style.left = drawn.teLeft + "px";
1345
- }
1346
- },
1347
-
1348
- // Reset the input to correspond to the selection (or to be empty,
1349
- // when not typing and nothing is selected)
1350
- reset: function(typing) {
1351
- if (this.contextMenuPending) return;
1352
- var minimal, selected, cm = this.cm, doc = cm.doc;
1353
- if (cm.somethingSelected()) {
1354
- this.prevInput = "";
1355
- var range = doc.sel.primary();
1356
- minimal = hasCopyEvent &&
1357
- (range.to().line - range.from().line > 100 || (selected = cm.getSelection()).length > 1000);
1358
- var content = minimal ? "-" : selected || cm.getSelection();
1359
- this.textarea.value = content;
1360
- if (cm.state.focused) selectInput(this.textarea);
1361
- if (ie && ie_version >= 9) this.hasSelection = content;
1362
- } else if (!typing) {
1363
- this.prevInput = this.textarea.value = "";
1364
- if (ie && ie_version >= 9) this.hasSelection = null;
1365
- }
1366
- this.inaccurateSelection = minimal;
1367
- },
1368
-
1369
- getField: function() { return this.textarea; },
1370
-
1371
- supportsTouch: function() { return false; },
1372
-
1373
- focus: function() {
1374
- if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) {
1375
- try { this.textarea.focus(); }
1376
- catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
1377
- }
1378
- },
1379
-
1380
- blur: function() { this.textarea.blur(); },
1381
-
1382
- resetPosition: function() {
1383
- this.wrapper.style.top = this.wrapper.style.left = 0;
1384
- },
1385
-
1386
- receivedFocus: function() { this.slowPoll(); },
1387
-
1388
- // Poll for input changes, using the normal rate of polling. This
1389
- // runs as long as the editor is focused.
1390
- slowPoll: function() {
1391
- var input = this;
1392
- if (input.pollingFast) return;
1393
- input.polling.set(this.cm.options.pollInterval, function() {
1394
- input.poll();
1395
- if (input.cm.state.focused) input.slowPoll();
1396
- });
1397
- },
1398
-
1399
- // When an event has just come in that is likely to add or change
1400
- // something in the input textarea, we poll faster, to ensure that
1401
- // the change appears on the screen quickly.
1402
- fastPoll: function() {
1403
- var missed = false, input = this;
1404
- input.pollingFast = true;
1405
- function p() {
1406
- var changed = input.poll();
1407
- if (!changed && !missed) {missed = true; input.polling.set(60, p);}
1408
- else {input.pollingFast = false; input.slowPoll();}
1409
- }
1410
- input.polling.set(20, p);
1411
- },
1412
-
1413
- // Read input from the textarea, and update the document to match.
1414
- // When something is selected, it is present in the textarea, and
1415
- // selected (unless it is huge, in which case a placeholder is
1416
- // used). When nothing is selected, the cursor sits after previously
1417
- // seen text (can be empty), which is stored in prevInput (we must
1418
- // not reset the textarea when typing, because that breaks IME).
1419
- poll: function() {
1420
- var cm = this.cm, input = this.textarea, prevInput = this.prevInput;
1421
- // Since this is called a *lot*, try to bail out as cheaply as
1422
- // possible when it is clear that nothing happened. hasSelection
1423
- // will be the case when there is a lot of text in the textarea,
1424
- // in which case reading its value would be expensive.
1425
- if (this.contextMenuPending || !cm.state.focused ||
1426
- (hasSelection(input) && !prevInput && !this.composing) ||
1427
- cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)
1428
- return false;
1429
-
1430
- var text = input.value;
1431
- // If nothing changed, bail.
1432
- if (text == prevInput && !cm.somethingSelected()) return false;
1433
- // Work around nonsensical selection resetting in IE9/10, and
1434
- // inexplicable appearance of private area unicode characters on
1435
- // some key combos in Mac (#2689).
1436
- if (ie && ie_version >= 9 && this.hasSelection === text ||
1437
- mac && /[\uf700-\uf7ff]/.test(text)) {
1438
- cm.display.input.reset();
1439
- return false;
1440
- }
1441
-
1442
- if (cm.doc.sel == cm.display.selForContextMenu) {
1443
- var first = text.charCodeAt(0);
1444
- if (first == 0x200b && !prevInput) prevInput = "\u200b";
1445
- if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo"); }
1446
- }
1447
- // Find the part of the input that is actually new
1448
- var same = 0, l = Math.min(prevInput.length, text.length);
1449
- while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) ++same;
1450
-
1451
- var self = this;
1452
- runInOp(cm, function() {
1453
- applyTextInput(cm, text.slice(same), prevInput.length - same,
1454
- null, self.composing ? "*compose" : null);
1455
-
1456
- // Don't leave long text in the textarea, since it makes further polling slow
1457
- if (text.length > 1000 || text.indexOf("\n") > -1) input.value = self.prevInput = "";
1458
- else self.prevInput = text;
1459
-
1460
- if (self.composing) {
1461
- self.composing.range.clear();
1462
- self.composing.range = cm.markText(self.composing.start, cm.getCursor("to"),
1463
- {className: "CodeMirror-composing"});
1464
- }
1465
- });
1466
- return true;
1467
- },
1468
-
1469
- ensurePolled: function() {
1470
- if (this.pollingFast && this.poll()) this.pollingFast = false;
1471
- },
1472
-
1473
- onKeyPress: function() {
1474
- if (ie && ie_version >= 9) this.hasSelection = null;
1475
- this.fastPoll();
1476
- },
1477
-
1478
- onContextMenu: function(e) {
1479
- var input = this, cm = input.cm, display = cm.display, te = input.textarea;
1480
- var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop;
1481
- if (!pos || presto) return; // Opera is difficult.
1482
-
1483
- // Reset the current text selection only if the click is done outside of the selection
1484
- // and 'resetSelectionOnContextMenu' option is true.
1485
- var reset = cm.options.resetSelectionOnContextMenu;
1486
- if (reset && cm.doc.sel.contains(pos) == -1)
1487
- operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll);
1488
-
1489
- var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText;
1490
- input.wrapper.style.cssText = "position: absolute"
1491
- var wrapperBox = input.wrapper.getBoundingClientRect()
1492
- te.style.cssText = "position: absolute; width: 30px; height: 30px; top: " + (e.clientY - wrapperBox.top - 5) +
1493
- "px; left: " + (e.clientX - wrapperBox.left - 5) + "px; z-index: 1000; background: " +
1494
- (ie ? "rgba(255, 255, 255, .05)" : "transparent") +
1495
- "; outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);";
1496
- if (webkit) var oldScrollY = window.scrollY; // Work around Chrome issue (#2712)
1497
- display.input.focus();
1498
- if (webkit) window.scrollTo(null, oldScrollY);
1499
- display.input.reset();
1500
- // Adds "Select all" to context menu in FF
1501
- if (!cm.somethingSelected()) te.value = input.prevInput = " ";
1502
- input.contextMenuPending = true;
1503
- display.selForContextMenu = cm.doc.sel;
1504
- clearTimeout(display.detectingSelectAll);
1505
-
1506
- // Select-all will be greyed out if there's nothing to select, so
1507
- // this adds a zero-width space so that we can later check whether
1508
- // it got selected.
1509
- function prepareSelectAllHack() {
1510
- if (te.selectionStart != null) {
1511
- var selected = cm.somethingSelected();
1512
- var extval = "\u200b" + (selected ? te.value : "");
1513
- te.value = "\u21da"; // Used to catch context-menu undo
1514
- te.value = extval;
1515
- input.prevInput = selected ? "" : "\u200b";
1516
- te.selectionStart = 1; te.selectionEnd = extval.length;
1517
- // Re-set this, in case some other handler touched the
1518
- // selection in the meantime.
1519
- display.selForContextMenu = cm.doc.sel;
1520
- }
1521
- }
1522
- function rehide() {
1523
- input.contextMenuPending = false;
1524
- input.wrapper.style.cssText = oldWrapperCSS
1525
- te.style.cssText = oldCSS;
1526
- if (ie && ie_version < 9) display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos);
1527
-
1528
- // Try to detect the user choosing select-all
1529
- if (te.selectionStart != null) {
1530
- if (!ie || (ie && ie_version < 9)) prepareSelectAllHack();
1531
- var i = 0, poll = function() {
1532
- if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&
1533
- te.selectionEnd > 0 && input.prevInput == "\u200b")
1534
- operation(cm, commands.selectAll)(cm);
1535
- else if (i++ < 10) display.detectingSelectAll = setTimeout(poll, 500);
1536
- else display.input.reset();
1537
- };
1538
- display.detectingSelectAll = setTimeout(poll, 200);
1539
- }
1540
- }
1541
-
1542
- if (ie && ie_version >= 9) prepareSelectAllHack();
1543
- if (captureRightClick) {
1544
- e_stop(e);
1545
- var mouseup = function() {
1546
- off(window, "mouseup", mouseup);
1547
- setTimeout(rehide, 20);
1548
- };
1549
- on(window, "mouseup", mouseup);
1550
- } else {
1551
- setTimeout(rehide, 50);
1552
- }
1553
- },
1554
-
1555
- readOnlyChanged: function(val) {
1556
- if (!val) this.reset();
1557
- },
1558
-
1559
- setUneditable: nothing,
1560
-
1561
- needsContentAttribute: false
1562
- }, TextareaInput.prototype);
1563
-
1564
- // CONTENTEDITABLE INPUT STYLE
1565
-
1566
- function ContentEditableInput(cm) {
1567
- this.cm = cm;
1568
- this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null;
1569
- this.polling = new Delayed();
1570
- this.gracePeriod = false;
1571
- }
1572
-
1573
- ContentEditableInput.prototype = copyObj({
1574
- init: function(display) {
1575
- var input = this, cm = input.cm;
1576
- var div = input.div = display.lineDiv;
1577
- disableBrowserMagic(div);
1578
-
1579
- on(div, "paste", function(e) {
1580
- if (!signalDOMEvent(cm, e)) handlePaste(e, cm);
1581
- })
1582
-
1583
- on(div, "compositionstart", function(e) {
1584
- var data = e.data;
1585
- input.composing = {sel: cm.doc.sel, data: data, startData: data};
1586
- if (!data) return;
1587
- var prim = cm.doc.sel.primary();
1588
- var line = cm.getLine(prim.head.line);
1589
- var found = line.indexOf(data, Math.max(0, prim.head.ch - data.length));
1590
- if (found > -1 && found <= prim.head.ch)
1591
- input.composing.sel = simpleSelection(Pos(prim.head.line, found),
1592
- Pos(prim.head.line, found + data.length));
1593
- });
1594
- on(div, "compositionupdate", function(e) {
1595
- input.composing.data = e.data;
1596
- });
1597
- on(div, "compositionend", function(e) {
1598
- var ours = input.composing;
1599
- if (!ours) return;
1600
- if (e.data != ours.startData && !/\u200b/.test(e.data))
1601
- ours.data = e.data;
1602
- // Need a small delay to prevent other code (input event,
1603
- // selection polling) from doing damage when fired right after
1604
- // compositionend.
1605
- setTimeout(function() {
1606
- if (!ours.handled)
1607
- input.applyComposition(ours);
1608
- if (input.composing == ours)
1609
- input.composing = null;
1610
- }, 50);
1611
- });
1612
-
1613
- on(div, "touchstart", function() {
1614
- input.forceCompositionEnd();
1615
- });
1616
-
1617
- on(div, "input", function() {
1618
- if (input.composing) return;
1619
- if (cm.isReadOnly() || !input.pollContent())
1620
- runInOp(input.cm, function() {regChange(cm);});
1621
- });
1622
-
1623
- function onCopyCut(e) {
1624
- if (signalDOMEvent(cm, e)) return
1625
- if (cm.somethingSelected()) {
1626
- lastCopied = {lineWise: false, text: cm.getSelections()};
1627
- if (e.type == "cut") cm.replaceSelection("", null, "cut");
1628
- } else if (!cm.options.lineWiseCopyCut) {
1629
- return;
1630
- } else {
1631
- var ranges = copyableRanges(cm);
1632
- lastCopied = {lineWise: true, text: ranges.text};
1633
- if (e.type == "cut") {
1634
- cm.operation(function() {
1635
- cm.setSelections(ranges.ranges, 0, sel_dontScroll);
1636
- cm.replaceSelection("", null, "cut");
1637
- });
1638
- }
1639
- }
1640
- // iOS exposes the clipboard API, but seems to discard content inserted into it
1641
- if (e.clipboardData && !ios) {
1642
- e.preventDefault();
1643
- e.clipboardData.clearData();
1644
- e.clipboardData.setData("text/plain", lastCopied.text.join("\n"));
1645
- } else {
1646
- // Old-fashioned briefly-focus-a-textarea hack
1647
- var kludge = hiddenTextarea(), te = kludge.firstChild;
1648
- cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild);
1649
- te.value = lastCopied.text.join("\n");
1650
- var hadFocus = document.activeElement;
1651
- selectInput(te);
1652
- setTimeout(function() {
1653
- cm.display.lineSpace.removeChild(kludge);
1654
- hadFocus.focus();
1655
- }, 50);
1656
- }
1657
- }
1658
- on(div, "copy", onCopyCut);
1659
- on(div, "cut", onCopyCut);
1660
- },
1661
-
1662
- prepareSelection: function() {
1663
- var result = prepareSelection(this.cm, false);
1664
- result.focus = this.cm.state.focused;
1665
- return result;
1666
- },
1667
-
1668
- showSelection: function(info, takeFocus) {
1669
- if (!info || !this.cm.display.view.length) return;
1670
- if (info.focus || takeFocus) this.showPrimarySelection();
1671
- this.showMultipleSelections(info);
1672
- },
1673
-
1674
- showPrimarySelection: function() {
1675
- var sel = window.getSelection(), prim = this.cm.doc.sel.primary();
1676
- var curAnchor = domToPos(this.cm, sel.anchorNode, sel.anchorOffset);
1677
- var curFocus = domToPos(this.cm, sel.focusNode, sel.focusOffset);
1678
- if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&
1679
- cmp(minPos(curAnchor, curFocus), prim.from()) == 0 &&
1680
- cmp(maxPos(curAnchor, curFocus), prim.to()) == 0)
1681
- return;
1682
-
1683
- var start = posToDOM(this.cm, prim.from());
1684
- var end = posToDOM(this.cm, prim.to());
1685
- if (!start && !end) return;
1686
-
1687
- var view = this.cm.display.view;
1688
- var old = sel.rangeCount && sel.getRangeAt(0);
1689
- if (!start) {
1690
- start = {node: view[0].measure.map[2], offset: 0};
1691
- } else if (!end) { // FIXME dangerously hacky
1692
- var measure = view[view.length - 1].measure;
1693
- var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map;
1694
- end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]};
1695
- }
1696
-
1697
- try { var rng = range(start.node, start.offset, end.offset, end.node); }
1698
- catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible
1699
- if (rng) {
1700
- if (!gecko && this.cm.state.focused) {
1701
- sel.collapse(start.node, start.offset);
1702
- if (!rng.collapsed) sel.addRange(rng);
1703
- } else {
1704
- sel.removeAllRanges();
1705
- sel.addRange(rng);
1706
- }
1707
- if (old && sel.anchorNode == null) sel.addRange(old);
1708
- else if (gecko) this.startGracePeriod();
1709
- }
1710
- this.rememberSelection();
1711
- },
1712
-
1713
- startGracePeriod: function() {
1714
- var input = this;
1715
- clearTimeout(this.gracePeriod);
1716
- this.gracePeriod = setTimeout(function() {
1717
- input.gracePeriod = false;
1718
- if (input.selectionChanged())
1719
- input.cm.operation(function() { input.cm.curOp.selectionChanged = true; });
1720
- }, 20);
1721
- },
1722
-
1723
- showMultipleSelections: function(info) {
1724
- removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors);
1725
- removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection);
1726
- },
1727
-
1728
- rememberSelection: function() {
1729
- var sel = window.getSelection();
1730
- this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset;
1731
- this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset;
1732
- },
1733
-
1734
- selectionInEditor: function() {
1735
- var sel = window.getSelection();
1736
- if (!sel.rangeCount) return false;
1737
- var node = sel.getRangeAt(0).commonAncestorContainer;
1738
- return contains(this.div, node);
1739
- },
1740
-
1741
- focus: function() {
1742
- if (this.cm.options.readOnly != "nocursor") this.div.focus();
1743
- },
1744
- blur: function() { this.div.blur(); },
1745
- getField: function() { return this.div; },
1746
-
1747
- supportsTouch: function() { return true; },
1748
-
1749
- receivedFocus: function() {
1750
- var input = this;
1751
- if (this.selectionInEditor())
1752
- this.pollSelection();
1753
- else
1754
- runInOp(this.cm, function() { input.cm.curOp.selectionChanged = true; });
1755
-
1756
- function poll() {
1757
- if (input.cm.state.focused) {
1758
- input.pollSelection();
1759
- input.polling.set(input.cm.options.pollInterval, poll);
1760
- }
1761
- }
1762
- this.polling.set(this.cm.options.pollInterval, poll);
1763
- },
1764
-
1765
- selectionChanged: function() {
1766
- var sel = window.getSelection();
1767
- return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
1768
- sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset;
1769
- },
1770
-
1771
- pollSelection: function() {
1772
- if (!this.composing && !this.gracePeriod && this.selectionChanged()) {
1773
- var sel = window.getSelection(), cm = this.cm;
1774
- this.rememberSelection();
1775
- var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);
1776
- var head = domToPos(cm, sel.focusNode, sel.focusOffset);
1777
- if (anchor && head) runInOp(cm, function() {
1778
- setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll);
1779
- if (anchor.bad || head.bad) cm.curOp.selectionChanged = true;
1780
- });
1781
- }
1782
- },
1783
-
1784
- pollContent: function() {
1785
- var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary();
1786
- var from = sel.from(), to = sel.to();
1787
- if (from.line < display.viewFrom || to.line > display.viewTo - 1) return false;
1788
-
1789
- var fromIndex;
1790
- if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {
1791
- var fromLine = lineNo(display.view[0].line);
1792
- var fromNode = display.view[0].node;
1793
- } else {
1794
- var fromLine = lineNo(display.view[fromIndex].line);
1795
- var fromNode = display.view[fromIndex - 1].node.nextSibling;
1796
- }
1797
- var toIndex = findViewIndex(cm, to.line);
1798
- if (toIndex == display.view.length - 1) {
1799
- var toLine = display.viewTo - 1;
1800
- var toNode = display.lineDiv.lastChild;
1801
- } else {
1802
- var toLine = lineNo(display.view[toIndex + 1].line) - 1;
1803
- var toNode = display.view[toIndex + 1].node.previousSibling;
1804
- }
1805
-
1806
- var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine));
1807
- var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length));
1808
- while (newText.length > 1 && oldText.length > 1) {
1809
- if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine--; }
1810
- else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++; }
1811
- else break;
1812
- }
1813
-
1814
- var cutFront = 0, cutEnd = 0;
1815
- var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length);
1816
- while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))
1817
- ++cutFront;
1818
- var newBot = lst(newText), oldBot = lst(oldText);
1819
- var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),
1820
- oldBot.length - (oldText.length == 1 ? cutFront : 0));
1821
- while (cutEnd < maxCutEnd &&
1822
- newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))
1823
- ++cutEnd;
1824
-
1825
- newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd);
1826
- newText[0] = newText[0].slice(cutFront);
1827
-
1828
- var chFrom = Pos(fromLine, cutFront);
1829
- var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0);
1830
- if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
1831
- replaceRange(cm.doc, newText, chFrom, chTo, "+input");
1832
- return true;
1833
- }
1834
- },
1835
-
1836
- ensurePolled: function() {
1837
- this.forceCompositionEnd();
1838
- },
1839
- reset: function() {
1840
- this.forceCompositionEnd();
1841
- },
1842
- forceCompositionEnd: function() {
1843
- if (!this.composing || this.composing.handled) return;
1844
- this.applyComposition(this.composing);
1845
- this.composing.handled = true;
1846
- this.div.blur();
1847
- this.div.focus();
1848
- },
1849
- applyComposition: function(composing) {
1850
- if (this.cm.isReadOnly())
1851
- operation(this.cm, regChange)(this.cm)
1852
- else if (composing.data && composing.data != composing.startData)
1853
- operation(this.cm, applyTextInput)(this.cm, composing.data, 0, composing.sel);
1854
- },
1855
-
1856
- setUneditable: function(node) {
1857
- node.contentEditable = "false"
1858
- },
1859
-
1860
- onKeyPress: function(e) {
1861
- e.preventDefault();
1862
- if (!this.cm.isReadOnly())
1863
- operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0);
1864
- },
1865
-
1866
- readOnlyChanged: function(val) {
1867
- this.div.contentEditable = String(val != "nocursor")
1868
- },
1869
-
1870
- onContextMenu: nothing,
1871
- resetPosition: nothing,
1872
-
1873
- needsContentAttribute: true
1874
- }, ContentEditableInput.prototype);
1875
-
1876
- function posToDOM(cm, pos) {
1877
- var view = findViewForLine(cm, pos.line);
1878
- if (!view || view.hidden) return null;
1879
- var line = getLine(cm.doc, pos.line);
1880
- var info = mapFromLineView(view, line, pos.line);
1881
-
1882
- var order = getOrder(line), side = "left";
1883
- if (order) {
1884
- var partPos = getBidiPartAt(order, pos.ch);
1885
- side = partPos % 2 ? "right" : "left";
1886
- }
1887
- var result = nodeAndOffsetInLineMap(info.map, pos.ch, side);
1888
- result.offset = result.collapse == "right" ? result.end : result.start;
1889
- return result;
1890
- }
1891
-
1892
- function badPos(pos, bad) { if (bad) pos.bad = true; return pos; }
1893
-
1894
- function domToPos(cm, node, offset) {
1895
- var lineNode;
1896
- if (node == cm.display.lineDiv) {
1897
- lineNode = cm.display.lineDiv.childNodes[offset];
1898
- if (!lineNode) return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true);
1899
- node = null; offset = 0;
1900
- } else {
1901
- for (lineNode = node;; lineNode = lineNode.parentNode) {
1902
- if (!lineNode || lineNode == cm.display.lineDiv) return null;
1903
- if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) break;
1904
- }
1905
- }
1906
- for (var i = 0; i < cm.display.view.length; i++) {
1907
- var lineView = cm.display.view[i];
1908
- if (lineView.node == lineNode)
1909
- return locateNodeInLineView(lineView, node, offset);
1910
- }
1911
- }
1912
-
1913
- function locateNodeInLineView(lineView, node, offset) {
1914
- var wrapper = lineView.text.firstChild, bad = false;
1915
- if (!node || !contains(wrapper, node)) return badPos(Pos(lineNo(lineView.line), 0), true);
1916
- if (node == wrapper) {
1917
- bad = true;
1918
- node = wrapper.childNodes[offset];
1919
- offset = 0;
1920
- if (!node) {
1921
- var line = lineView.rest ? lst(lineView.rest) : lineView.line;
1922
- return badPos(Pos(lineNo(line), line.text.length), bad);
1923
- }
1924
- }
1925
-
1926
- var textNode = node.nodeType == 3 ? node : null, topNode = node;
1927
- if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {
1928
- textNode = node.firstChild;
1929
- if (offset) offset = textNode.nodeValue.length;
1930
- }
1931
- while (topNode.parentNode != wrapper) topNode = topNode.parentNode;
1932
- var measure = lineView.measure, maps = measure.maps;
1933
-
1934
- function find(textNode, topNode, offset) {
1935
- for (var i = -1; i < (maps ? maps.length : 0); i++) {
1936
- var map = i < 0 ? measure.map : maps[i];
1937
- for (var j = 0; j < map.length; j += 3) {
1938
- var curNode = map[j + 2];
1939
- if (curNode == textNode || curNode == topNode) {
1940
- var line = lineNo(i < 0 ? lineView.line : lineView.rest[i]);
1941
- var ch = map[j] + offset;
1942
- if (offset < 0 || curNode != textNode) ch = map[j + (offset ? 1 : 0)];
1943
- return Pos(line, ch);
1944
- }
1945
- }
1946
- }
1947
- }
1948
- var found = find(textNode, topNode, offset);
1949
- if (found) return badPos(found, bad);
1950
-
1951
- // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems
1952
- for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {
1953
- found = find(after, after.firstChild, 0);
1954
- if (found)
1955
- return badPos(Pos(found.line, found.ch - dist), bad);
1956
- else
1957
- dist += after.textContent.length;
1958
- }
1959
- for (var before = topNode.previousSibling, dist = offset; before; before = before.previousSibling) {
1960
- found = find(before, before.firstChild, -1);
1961
- if (found)
1962
- return badPos(Pos(found.line, found.ch + dist), bad);
1963
- else
1964
- dist += after.textContent.length;
1965
- }
1966
- }
1967
-
1968
- function domTextBetween(cm, from, to, fromLine, toLine) {
1969
- var text = "", closing = false, lineSep = cm.doc.lineSeparator();
1970
- function recognizeMarker(id) { return function(marker) { return marker.id == id; }; }
1971
- function walk(node) {
1972
- if (node.nodeType == 1) {
1973
- var cmText = node.getAttribute("cm-text");
1974
- if (cmText != null) {
1975
- if (cmText == "") cmText = node.textContent.replace(/\u200b/g, "");
1976
- text += cmText;
1977
- return;
1978
- }
1979
- var markerID = node.getAttribute("cm-marker"), range;
1980
- if (markerID) {
1981
- var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID));
1982
- if (found.length && (range = found[0].find()))
1983
- text += getBetween(cm.doc, range.from, range.to).join(lineSep);
1984
- return;
1985
- }
1986
- if (node.getAttribute("contenteditable") == "false") return;
1987
- for (var i = 0; i < node.childNodes.length; i++)
1988
- walk(node.childNodes[i]);
1989
- if (/^(pre|div|p)$/i.test(node.nodeName))
1990
- closing = true;
1991
- } else if (node.nodeType == 3) {
1992
- var val = node.nodeValue;
1993
- if (!val) return;
1994
- if (closing) {
1995
- text += lineSep;
1996
- closing = false;
1997
- }
1998
- text += val;
1999
- }
2000
- }
2001
- for (;;) {
2002
- walk(from);
2003
- if (from == to) break;
2004
- from = from.nextSibling;
2005
- }
2006
- return text;
2007
- }
2008
-
2009
- CodeMirror.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput};
2010
-
2011
- // SELECTION / CURSOR
2012
-
2013
- // Selection objects are immutable. A new one is created every time
2014
- // the selection changes. A selection is one or more non-overlapping
2015
- // (and non-touching) ranges, sorted, and an integer that indicates
2016
- // which one is the primary selection (the one that's scrolled into
2017
- // view, that getCursor returns, etc).
2018
- function Selection(ranges, primIndex) {
2019
- this.ranges = ranges;
2020
- this.primIndex = primIndex;
2021
- }
2022
-
2023
- Selection.prototype = {
2024
- primary: function() { return this.ranges[this.primIndex]; },
2025
- equals: function(other) {
2026
- if (other == this) return true;
2027
- if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) return false;
2028
- for (var i = 0; i < this.ranges.length; i++) {
2029
- var here = this.ranges[i], there = other.ranges[i];
2030
- if (cmp(here.anchor, there.anchor) != 0 || cmp(here.head, there.head) != 0) return false;
2031
- }
2032
- return true;
2033
- },
2034
- deepCopy: function() {
2035
- for (var out = [], i = 0; i < this.ranges.length; i++)
2036
- out[i] = new Range(copyPos(this.ranges[i].anchor), copyPos(this.ranges[i].head));
2037
- return new Selection(out, this.primIndex);
2038
- },
2039
- somethingSelected: function() {
2040
- for (var i = 0; i < this.ranges.length; i++)
2041
- if (!this.ranges[i].empty()) return true;
2042
- return false;
2043
- },
2044
- contains: function(pos, end) {
2045
- if (!end) end = pos;
2046
- for (var i = 0; i < this.ranges.length; i++) {
2047
- var range = this.ranges[i];
2048
- if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
2049
- return i;
2050
- }
2051
- return -1;
2052
- }
2053
- };
2054
-
2055
- function Range(anchor, head) {
2056
- this.anchor = anchor; this.head = head;
2057
- }
2058
-
2059
- Range.prototype = {
2060
- from: function() { return minPos(this.anchor, this.head); },
2061
- to: function() { return maxPos(this.anchor, this.head); },
2062
- empty: function() {
2063
- return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch;
2064
- }
2065
- };
2066
-
2067
- // Take an unsorted, potentially overlapping set of ranges, and
2068
- // build a selection out of it. 'Consumes' ranges array (modifying
2069
- // it).
2070
- function normalizeSelection(ranges, primIndex) {
2071
- var prim = ranges[primIndex];
2072
- ranges.sort(function(a, b) { return cmp(a.from(), b.from()); });
2073
- primIndex = indexOf(ranges, prim);
2074
- for (var i = 1; i < ranges.length; i++) {
2075
- var cur = ranges[i], prev = ranges[i - 1];
2076
- if (cmp(prev.to(), cur.from()) >= 0) {
2077
- var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to());
2078
- var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head;
2079
- if (i <= primIndex) --primIndex;
2080
- ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to));
2081
- }
2082
- }
2083
- return new Selection(ranges, primIndex);
2084
- }
2085
-
2086
- function simpleSelection(anchor, head) {
2087
- return new Selection([new Range(anchor, head || anchor)], 0);
2088
- }
2089
-
2090
- // Most of the external API clips given positions to make sure they
2091
- // actually exist within the document.
2092
- function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1));}
2093
- function clipPos(doc, pos) {
2094
- if (pos.line < doc.first) return Pos(doc.first, 0);
2095
- var last = doc.first + doc.size - 1;
2096
- if (pos.line > last) return Pos(last, getLine(doc, last).text.length);
2097
- return clipToLen(pos, getLine(doc, pos.line).text.length);
2098
- }
2099
- function clipToLen(pos, linelen) {
2100
- var ch = pos.ch;
2101
- if (ch == null || ch > linelen) return Pos(pos.line, linelen);
2102
- else if (ch < 0) return Pos(pos.line, 0);
2103
- else return pos;
2104
- }
2105
- function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size;}
2106
- function clipPosArray(doc, array) {
2107
- for (var out = [], i = 0; i < array.length; i++) out[i] = clipPos(doc, array[i]);
2108
- return out;
2109
- }
2110
-
2111
- // SELECTION UPDATES
2112
-
2113
- // The 'scroll' parameter given to many of these indicated whether
2114
- // the new cursor position should be scrolled into view after
2115
- // modifying the selection.
2116
-
2117
- // If shift is held or the extend flag is set, extends a range to
2118
- // include a given position (and optionally a second position).
2119
- // Otherwise, simply returns the range between the given positions.
2120
- // Used for cursor motion and such.
2121
- function extendRange(doc, range, head, other) {
2122
- if (doc.cm && doc.cm.display.shift || doc.extend) {
2123
- var anchor = range.anchor;
2124
- if (other) {
2125
- var posBefore = cmp(head, anchor) < 0;
2126
- if (posBefore != (cmp(other, anchor) < 0)) {
2127
- anchor = head;
2128
- head = other;
2129
- } else if (posBefore != (cmp(head, other) < 0)) {
2130
- head = other;
2131
- }
2132
- }
2133
- return new Range(anchor, head);
2134
- } else {
2135
- return new Range(other || head, head);
2136
- }
2137
- }
2138
-
2139
- // Extend the primary selection range, discard the rest.
2140
- function extendSelection(doc, head, other, options) {
2141
- setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options);
2142
- }
2143
-
2144
- // Extend all selections (pos is an array of selections with length
2145
- // equal the number of selections)
2146
- function extendSelections(doc, heads, options) {
2147
- for (var out = [], i = 0; i < doc.sel.ranges.length; i++)
2148
- out[i] = extendRange(doc, doc.sel.ranges[i], heads[i], null);
2149
- var newSel = normalizeSelection(out, doc.sel.primIndex);
2150
- setSelection(doc, newSel, options);
2151
- }
2152
-
2153
- // Updates a single range in the selection.
2154
- function replaceOneSelection(doc, i, range, options) {
2155
- var ranges = doc.sel.ranges.slice(0);
2156
- ranges[i] = range;
2157
- setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options);
2158
- }
2159
-
2160
- // Reset the selection to a single range.
2161
- function setSimpleSelection(doc, anchor, head, options) {
2162
- setSelection(doc, simpleSelection(anchor, head), options);
2163
- }
2164
-
2165
- // Give beforeSelectionChange handlers a change to influence a
2166
- // selection update.
2167
- function filterSelectionChange(doc, sel, options) {
2168
- var obj = {
2169
- ranges: sel.ranges,
2170
- update: function(ranges) {
2171
- this.ranges = [];
2172
- for (var i = 0; i < ranges.length; i++)
2173
- this.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),
2174
- clipPos(doc, ranges[i].head));
2175
- },
2176
- origin: options && options.origin
2177
- };
2178
- signal(doc, "beforeSelectionChange", doc, obj);
2179
- if (doc.cm) signal(doc.cm, "beforeSelectionChange", doc.cm, obj);
2180
- if (obj.ranges != sel.ranges) return normalizeSelection(obj.ranges, obj.ranges.length - 1);
2181
- else return sel;
2182
- }
2183
-
2184
- function setSelectionReplaceHistory(doc, sel, options) {
2185
- var done = doc.history.done, last = lst(done);
2186
- if (last && last.ranges) {
2187
- done[done.length - 1] = sel;
2188
- setSelectionNoUndo(doc, sel, options);
2189
- } else {
2190
- setSelection(doc, sel, options);
2191
- }
2192
- }
2193
-
2194
- // Set a new selection.
2195
- function setSelection(doc, sel, options) {
2196
- setSelectionNoUndo(doc, sel, options);
2197
- addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options);
2198
- }
2199
-
2200
- function setSelectionNoUndo(doc, sel, options) {
2201
- if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
2202
- sel = filterSelectionChange(doc, sel, options);
2203
-
2204
- var bias = options && options.bias ||
2205
- (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1);
2206
- setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true));
2207
-
2208
- if (!(options && options.scroll === false) && doc.cm)
2209
- ensureCursorVisible(doc.cm);
2210
- }
2211
-
2212
- function setSelectionInner(doc, sel) {
2213
- if (sel.equals(doc.sel)) return;
2214
-
2215
- doc.sel = sel;
2216
-
2217
- if (doc.cm) {
2218
- doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true;
2219
- signalCursorActivity(doc.cm);
2220
- }
2221
- signalLater(doc, "cursorActivity", doc);
2222
- }
2223
-
2224
- // Verify that the selection does not partially select any atomic
2225
- // marked ranges.
2226
- function reCheckSelection(doc) {
2227
- setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false), sel_dontScroll);
2228
- }
2229
-
2230
- // Return a selection that does not partially select any atomic
2231
- // ranges.
2232
- function skipAtomicInSelection(doc, sel, bias, mayClear) {
2233
- var out;
2234
- for (var i = 0; i < sel.ranges.length; i++) {
2235
- var range = sel.ranges[i];
2236
- var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i];
2237
- var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear);
2238
- var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear);
2239
- if (out || newAnchor != range.anchor || newHead != range.head) {
2240
- if (!out) out = sel.ranges.slice(0, i);
2241
- out[i] = new Range(newAnchor, newHead);
2242
- }
2243
- }
2244
- return out ? normalizeSelection(out, sel.primIndex) : sel;
2245
- }
2246
-
2247
- function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {
2248
- var line = getLine(doc, pos.line);
2249
- if (line.markedSpans) for (var i = 0; i < line.markedSpans.length; ++i) {
2250
- var sp = line.markedSpans[i], m = sp.marker;
2251
- if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) &&
2252
- (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) {
2253
- if (mayClear) {
2254
- signal(m, "beforeCursorEnter");
2255
- if (m.explicitlyCleared) {
2256
- if (!line.markedSpans) break;
2257
- else {--i; continue;}
2258
- }
2259
- }
2260
- if (!m.atomic) continue;
2261
-
2262
- if (oldPos) {
2263
- var near = m.find(dir < 0 ? 1 : -1), diff;
2264
- if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)
2265
- near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null);
2266
- if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))
2267
- return skipAtomicInner(doc, near, pos, dir, mayClear);
2268
- }
2269
-
2270
- var far = m.find(dir < 0 ? -1 : 1);
2271
- if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)
2272
- far = movePos(doc, far, dir, far.line == pos.line ? line : null);
2273
- return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null;
2274
- }
2275
- }
2276
- return pos;
2277
- }
2278
-
2279
- // Ensure a given position is not inside an atomic range.
2280
- function skipAtomic(doc, pos, oldPos, bias, mayClear) {
2281
- var dir = bias || 1;
2282
- var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||
2283
- (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||
2284
- skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||
2285
- (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true));
2286
- if (!found) {
2287
- doc.cantEdit = true;
2288
- return Pos(doc.first, 0);
2289
- }
2290
- return found;
2291
- }
2292
-
2293
- function movePos(doc, pos, dir, line) {
2294
- if (dir < 0 && pos.ch == 0) {
2295
- if (pos.line > doc.first) return clipPos(doc, Pos(pos.line - 1));
2296
- else return null;
2297
- } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {
2298
- if (pos.line < doc.first + doc.size - 1) return Pos(pos.line + 1, 0);
2299
- else return null;
2300
- } else {
2301
- return new Pos(pos.line, pos.ch + dir);
2302
- }
2303
- }
2304
-
2305
- // SELECTION DRAWING
2306
-
2307
- function updateSelection(cm) {
2308
- cm.display.input.showSelection(cm.display.input.prepareSelection());
2309
- }
2310
-
2311
- function prepareSelection(cm, primary) {
2312
- var doc = cm.doc, result = {};
2313
- var curFragment = result.cursors = document.createDocumentFragment();
2314
- var selFragment = result.selection = document.createDocumentFragment();
2315
-
2316
- for (var i = 0; i < doc.sel.ranges.length; i++) {
2317
- if (primary === false && i == doc.sel.primIndex) continue;
2318
- var range = doc.sel.ranges[i];
2319
- if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) continue;
2320
- var collapsed = range.empty();
2321
- if (collapsed || cm.options.showCursorWhenSelecting)
2322
- drawSelectionCursor(cm, range.head, curFragment);
2323
- if (!collapsed)
2324
- drawSelectionRange(cm, range, selFragment);
2325
- }
2326
- return result;
2327
- }
2328
-
2329
- // Draws a cursor for the given range
2330
- function drawSelectionCursor(cm, head, output) {
2331
- var pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine);
2332
-
2333
- var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"));
2334
- cursor.style.left = pos.left + "px";
2335
- cursor.style.top = pos.top + "px";
2336
- cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px";
2337
-
2338
- if (pos.other) {
2339
- // Secondary cursor, shown when on a 'jump' in bi-directional text
2340
- var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"));
2341
- otherCursor.style.display = "";
2342
- otherCursor.style.left = pos.other.left + "px";
2343
- otherCursor.style.top = pos.other.top + "px";
2344
- otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px";
2345
- }
2346
- }
2347
-
2348
- // Draws the given range as a highlighted selection
2349
- function drawSelectionRange(cm, range, output) {
2350
- var display = cm.display, doc = cm.doc;
2351
- var fragment = document.createDocumentFragment();
2352
- var padding = paddingH(cm.display), leftSide = padding.left;
2353
- var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right;
2354
-
2355
- function add(left, top, width, bottom) {
2356
- if (top < 0) top = 0;
2357
- top = Math.round(top);
2358
- bottom = Math.round(bottom);
2359
- fragment.appendChild(elt("div", null, "CodeMirror-selected", "position: absolute; left: " + left +
2360
- "px; top: " + top + "px; width: " + (width == null ? rightSide - left : width) +
2361
- "px; height: " + (bottom - top) + "px"));
2362
- }
2363
-
2364
- function drawForLine(line, fromArg, toArg) {
2365
- var lineObj = getLine(doc, line);
2366
- var lineLen = lineObj.text.length;
2367
- var start, end;
2368
- function coords(ch, bias) {
2369
- return charCoords(cm, Pos(line, ch), "div", lineObj, bias);
2370
- }
2371
-
2372
- iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function(from, to, dir) {
2373
- var leftPos = coords(from, "left"), rightPos, left, right;
2374
- if (from == to) {
2375
- rightPos = leftPos;
2376
- left = right = leftPos.left;
2377
- } else {
2378
- rightPos = coords(to - 1, "right");
2379
- if (dir == "rtl") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp; }
2380
- left = leftPos.left;
2381
- right = rightPos.right;
2382
- }
2383
- if (fromArg == null && from == 0) left = leftSide;
2384
- if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part
2385
- add(left, leftPos.top, null, leftPos.bottom);
2386
- left = leftSide;
2387
- if (leftPos.bottom < rightPos.top) add(left, leftPos.bottom, null, rightPos.top);
2388
- }
2389
- if (toArg == null && to == lineLen) right = rightSide;
2390
- if (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left)
2391
- start = leftPos;
2392
- if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right)
2393
- end = rightPos;
2394
- if (left < leftSide + 1) left = leftSide;
2395
- add(left, rightPos.top, right - left, rightPos.bottom);
2396
- });
2397
- return {start: start, end: end};
2398
- }
2399
-
2400
- var sFrom = range.from(), sTo = range.to();
2401
- if (sFrom.line == sTo.line) {
2402
- drawForLine(sFrom.line, sFrom.ch, sTo.ch);
2403
- } else {
2404
- var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line);
2405
- var singleVLine = visualLine(fromLine) == visualLine(toLine);
2406
- var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end;
2407
- var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start;
2408
- if (singleVLine) {
2409
- if (leftEnd.top < rightStart.top - 2) {
2410
- add(leftEnd.right, leftEnd.top, null, leftEnd.bottom);
2411
- add(leftSide, rightStart.top, rightStart.left, rightStart.bottom);
2412
- } else {
2413
- add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom);
2414
- }
2415
- }
2416
- if (leftEnd.bottom < rightStart.top)
2417
- add(leftSide, leftEnd.bottom, null, rightStart.top);
2418
- }
2419
-
2420
- output.appendChild(fragment);
2421
- }
2422
-
2423
- // Cursor-blinking
2424
- function restartBlink(cm) {
2425
- if (!cm.state.focused) return;
2426
- var display = cm.display;
2427
- clearInterval(display.blinker);
2428
- var on = true;
2429
- display.cursorDiv.style.visibility = "";
2430
- if (cm.options.cursorBlinkRate > 0)
2431
- display.blinker = setInterval(function() {
2432
- display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden";
2433
- }, cm.options.cursorBlinkRate);
2434
- else if (cm.options.cursorBlinkRate < 0)
2435
- display.cursorDiv.style.visibility = "hidden";
2436
- }
2437
-
2438
- // HIGHLIGHT WORKER
2439
-
2440
- function startWorker(cm, time) {
2441
- if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)
2442
- cm.state.highlight.set(time, bind(highlightWorker, cm));
2443
- }
2444
-
2445
- function highlightWorker(cm) {
2446
- var doc = cm.doc;
2447
- if (doc.frontier < doc.first) doc.frontier = doc.first;
2448
- if (doc.frontier >= cm.display.viewTo) return;
2449
- var end = +new Date + cm.options.workTime;
2450
- var state = copyState(doc.mode, getStateBefore(cm, doc.frontier));
2451
- var changedLines = [];
2452
-
2453
- doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function(line) {
2454
- if (doc.frontier >= cm.display.viewFrom) { // Visible
2455
- var oldStyles = line.styles, tooLong = line.text.length > cm.options.maxHighlightLength;
2456
- var highlighted = highlightLine(cm, line, tooLong ? copyState(doc.mode, state) : state, true);
2457
- line.styles = highlighted.styles;
2458
- var oldCls = line.styleClasses, newCls = highlighted.classes;
2459
- if (newCls) line.styleClasses = newCls;
2460
- else if (oldCls) line.styleClasses = null;
2461
- var ischange = !oldStyles || oldStyles.length != line.styles.length ||
2462
- oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass);
2463
- for (var i = 0; !ischange && i < oldStyles.length; ++i) ischange = oldStyles[i] != line.styles[i];
2464
- if (ischange) changedLines.push(doc.frontier);
2465
- line.stateAfter = tooLong ? state : copyState(doc.mode, state);
2466
- } else {
2467
- if (line.text.length <= cm.options.maxHighlightLength)
2468
- processLine(cm, line.text, state);
2469
- line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null;
2470
- }
2471
- ++doc.frontier;
2472
- if (+new Date > end) {
2473
- startWorker(cm, cm.options.workDelay);
2474
- return true;
2475
- }
2476
- });
2477
- if (changedLines.length) runInOp(cm, function() {
2478
- for (var i = 0; i < changedLines.length; i++)
2479
- regLineChange(cm, changedLines[i], "text");
2480
- });
2481
- }
2482
-
2483
- // Finds the line to start with when starting a parse. Tries to
2484
- // find a line with a stateAfter, so that it can start with a
2485
- // valid state. If that fails, it returns the line with the
2486
- // smallest indentation, which tends to need the least context to
2487
- // parse correctly.
2488
- function findStartLine(cm, n, precise) {
2489
- var minindent, minline, doc = cm.doc;
2490
- var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100);
2491
- for (var search = n; search > lim; --search) {
2492
- if (search <= doc.first) return doc.first;
2493
- var line = getLine(doc, search - 1);
2494
- if (line.stateAfter && (!precise || search <= doc.frontier)) return search;
2495
- var indented = countColumn(line.text, null, cm.options.tabSize);
2496
- if (minline == null || minindent > indented) {
2497
- minline = search - 1;
2498
- minindent = indented;
2499
- }
2500
- }
2501
- return minline;
2502
- }
2503
-
2504
- function getStateBefore(cm, n, precise) {
2505
- var doc = cm.doc, display = cm.display;
2506
- if (!doc.mode.startState) return true;
2507
- var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos-1).stateAfter;
2508
- if (!state) state = startState(doc.mode);
2509
- else state = copyState(doc.mode, state);
2510
- doc.iter(pos, n, function(line) {
2511
- processLine(cm, line.text, state);
2512
- var save = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo;
2513
- line.stateAfter = save ? copyState(doc.mode, state) : null;
2514
- ++pos;
2515
- });
2516
- if (precise) doc.frontier = pos;
2517
- return state;
2518
- }
2519
-
2520
- // POSITION MEASUREMENT
2521
-
2522
- function paddingTop(display) {return display.lineSpace.offsetTop;}
2523
- function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight;}
2524
- function paddingH(display) {
2525
- if (display.cachedPaddingH) return display.cachedPaddingH;
2526
- var e = removeChildrenAndAdd(display.measure, elt("pre", "x"));
2527
- var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle;
2528
- var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)};
2529
- if (!isNaN(data.left) && !isNaN(data.right)) display.cachedPaddingH = data;
2530
- return data;
2531
- }
2532
-
2533
- function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth; }
2534
- function displayWidth(cm) {
2535
- return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth;
2536
- }
2537
- function displayHeight(cm) {
2538
- return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight;
2539
- }
2540
-
2541
- // Ensure the lineView.wrapping.heights array is populated. This is
2542
- // an array of bottom offsets for the lines that make up a drawn
2543
- // line. When lineWrapping is on, there might be more than one
2544
- // height.
2545
- function ensureLineHeights(cm, lineView, rect) {
2546
- var wrapping = cm.options.lineWrapping;
2547
- var curWidth = wrapping && displayWidth(cm);
2548
- if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
2549
- var heights = lineView.measure.heights = [];
2550
- if (wrapping) {
2551
- lineView.measure.width = curWidth;
2552
- var rects = lineView.text.firstChild.getClientRects();
2553
- for (var i = 0; i < rects.length - 1; i++) {
2554
- var cur = rects[i], next = rects[i + 1];
2555
- if (Math.abs(cur.bottom - next.bottom) > 2)
2556
- heights.push((cur.bottom + next.top) / 2 - rect.top);
2557
- }
2558
- }
2559
- heights.push(rect.bottom - rect.top);
2560
- }
2561
- }
2562
-
2563
- // Find a line map (mapping character offsets to text nodes) and a
2564
- // measurement cache for the given line number. (A line view might
2565
- // contain multiple lines when collapsed ranges are present.)
2566
- function mapFromLineView(lineView, line, lineN) {
2567
- if (lineView.line == line)
2568
- return {map: lineView.measure.map, cache: lineView.measure.cache};
2569
- for (var i = 0; i < lineView.rest.length; i++)
2570
- if (lineView.rest[i] == line)
2571
- return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]};
2572
- for (var i = 0; i < lineView.rest.length; i++)
2573
- if (lineNo(lineView.rest[i]) > lineN)
2574
- return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i], before: true};
2575
- }
2576
-
2577
- // Render a line into the hidden node display.externalMeasured. Used
2578
- // when measurement is needed for a line that's not in the viewport.
2579
- function updateExternalMeasurement(cm, line) {
2580
- line = visualLine(line);
2581
- var lineN = lineNo(line);
2582
- var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN);
2583
- view.lineN = lineN;
2584
- var built = view.built = buildLineContent(cm, view);
2585
- view.text = built.pre;
2586
- removeChildrenAndAdd(cm.display.lineMeasure, built.pre);
2587
- return view;
2588
- }
2589
-
2590
- // Get a {top, bottom, left, right} box (in line-local coordinates)
2591
- // for a given character.
2592
- function measureChar(cm, line, ch, bias) {
2593
- return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias);
2594
- }
2595
-
2596
- // Find a line view that corresponds to the given line number.
2597
- function findViewForLine(cm, lineN) {
2598
- if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
2599
- return cm.display.view[findViewIndex(cm, lineN)];
2600
- var ext = cm.display.externalMeasured;
2601
- if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
2602
- return ext;
2603
- }
2604
-
2605
- // Measurement can be split in two steps, the set-up work that
2606
- // applies to the whole line, and the measurement of the actual
2607
- // character. Functions like coordsChar, that need to do a lot of
2608
- // measurements in a row, can thus ensure that the set-up work is
2609
- // only done once.
2610
- function prepareMeasureForLine(cm, line) {
2611
- var lineN = lineNo(line);
2612
- var view = findViewForLine(cm, lineN);
2613
- if (view && !view.text) {
2614
- view = null;
2615
- } else if (view && view.changes) {
2616
- updateLineForChanges(cm, view, lineN, getDimensions(cm));
2617
- cm.curOp.forceUpdate = true;
2618
- }
2619
- if (!view)
2620
- view = updateExternalMeasurement(cm, line);
2621
-
2622
- var info = mapFromLineView(view, line, lineN);
2623
- return {
2624
- line: line, view: view, rect: null,
2625
- map: info.map, cache: info.cache, before: info.before,
2626
- hasHeights: false
2627
- };
2628
- }
2629
-
2630
- // Given a prepared measurement object, measures the position of an
2631
- // actual character (or fetches it from the cache).
2632
- function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
2633
- if (prepared.before) ch = -1;
2634
- var key = ch + (bias || ""), found;
2635
- if (prepared.cache.hasOwnProperty(key)) {
2636
- found = prepared.cache[key];
2637
- } else {
2638
- if (!prepared.rect)
2639
- prepared.rect = prepared.view.text.getBoundingClientRect();
2640
- if (!prepared.hasHeights) {
2641
- ensureLineHeights(cm, prepared.view, prepared.rect);
2642
- prepared.hasHeights = true;
2643
- }
2644
- found = measureCharInner(cm, prepared, ch, bias);
2645
- if (!found.bogus) prepared.cache[key] = found;
2646
- }
2647
- return {left: found.left, right: found.right,
2648
- top: varHeight ? found.rtop : found.top,
2649
- bottom: varHeight ? found.rbottom : found.bottom};
2650
- }
2651
-
2652
- var nullRect = {left: 0, right: 0, top: 0, bottom: 0};
2653
-
2654
- function nodeAndOffsetInLineMap(map, ch, bias) {
2655
- var node, start, end, collapse;
2656
- // First, search the line map for the text node corresponding to,
2657
- // or closest to, the target character.
2658
- for (var i = 0; i < map.length; i += 3) {
2659
- var mStart = map[i], mEnd = map[i + 1];
2660
- if (ch < mStart) {
2661
- start = 0; end = 1;
2662
- collapse = "left";
2663
- } else if (ch < mEnd) {
2664
- start = ch - mStart;
2665
- end = start + 1;
2666
- } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {
2667
- end = mEnd - mStart;
2668
- start = end - 1;
2669
- if (ch >= mEnd) collapse = "right";
2670
- }
2671
- if (start != null) {
2672
- node = map[i + 2];
2673
- if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right"))
2674
- collapse = bias;
2675
- if (bias == "left" && start == 0)
2676
- while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {
2677
- node = map[(i -= 3) + 2];
2678
- collapse = "left";
2679
- }
2680
- if (bias == "right" && start == mEnd - mStart)
2681
- while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {
2682
- node = map[(i += 3) + 2];
2683
- collapse = "right";
2684
- }
2685
- break;
2686
- }
2687
- }
2688
- return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd};
2689
- }
2690
-
2691
- function getUsefulRect(rects, bias) {
2692
- var rect = nullRect
2693
- if (bias == "left") for (var i = 0; i < rects.length; i++) {
2694
- if ((rect = rects[i]).left != rect.right) break
2695
- } else for (var i = rects.length - 1; i >= 0; i--) {
2696
- if ((rect = rects[i]).left != rect.right) break
2697
- }
2698
- return rect
2699
- }
2700
-
2701
- function measureCharInner(cm, prepared, ch, bias) {
2702
- var place = nodeAndOffsetInLineMap(prepared.map, ch, bias);
2703
- var node = place.node, start = place.start, end = place.end, collapse = place.collapse;
2704
-
2705
- var rect;
2706
- if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
2707
- for (var i = 0; i < 4; i++) { // Retry a maximum of 4 times when nonsense rectangles are returned
2708
- while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) --start;
2709
- while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) ++end;
2710
- if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)
2711
- rect = node.parentNode.getBoundingClientRect();
2712
- else
2713
- rect = getUsefulRect(range(node, start, end).getClientRects(), bias)
2714
- if (rect.left || rect.right || start == 0) break;
2715
- end = start;
2716
- start = start - 1;
2717
- collapse = "right";
2718
- }
2719
- if (ie && ie_version < 11) rect = maybeUpdateRectForZooming(cm.display.measure, rect);
2720
- } else { // If it is a widget, simply get the box for the whole widget.
2721
- if (start > 0) collapse = bias = "right";
2722
- var rects;
2723
- if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
2724
- rect = rects[bias == "right" ? rects.length - 1 : 0];
2725
- else
2726
- rect = node.getBoundingClientRect();
2727
- }
2728
- if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
2729
- var rSpan = node.parentNode.getClientRects()[0];
2730
- if (rSpan)
2731
- rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom};
2732
- else
2733
- rect = nullRect;
2734
- }
2735
-
2736
- var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top;
2737
- var mid = (rtop + rbot) / 2;
2738
- var heights = prepared.view.measure.heights;
2739
- for (var i = 0; i < heights.length - 1; i++)
2740
- if (mid < heights[i]) break;
2741
- var top = i ? heights[i - 1] : 0, bot = heights[i];
2742
- var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left,
2743
- right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left,
2744
- top: top, bottom: bot};
2745
- if (!rect.left && !rect.right) result.bogus = true;
2746
- if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot; }
2747
-
2748
- return result;
2749
- }
2750
-
2751
- // Work around problem with bounding client rects on ranges being
2752
- // returned incorrectly when zoomed on IE10 and below.
2753
- function maybeUpdateRectForZooming(measure, rect) {
2754
- if (!window.screen || screen.logicalXDPI == null ||
2755
- screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
2756
- return rect;
2757
- var scaleX = screen.logicalXDPI / screen.deviceXDPI;
2758
- var scaleY = screen.logicalYDPI / screen.deviceYDPI;
2759
- return {left: rect.left * scaleX, right: rect.right * scaleX,
2760
- top: rect.top * scaleY, bottom: rect.bottom * scaleY};
2761
- }
2762
-
2763
- function clearLineMeasurementCacheFor(lineView) {
2764
- if (lineView.measure) {
2765
- lineView.measure.cache = {};
2766
- lineView.measure.heights = null;
2767
- if (lineView.rest) for (var i = 0; i < lineView.rest.length; i++)
2768
- lineView.measure.caches[i] = {};
2769
- }
2770
- }
2771
-
2772
- function clearLineMeasurementCache(cm) {
2773
- cm.display.externalMeasure = null;
2774
- removeChildren(cm.display.lineMeasure);
2775
- for (var i = 0; i < cm.display.view.length; i++)
2776
- clearLineMeasurementCacheFor(cm.display.view[i]);
2777
- }
2778
-
2779
- function clearCaches(cm) {
2780
- clearLineMeasurementCache(cm);
2781
- cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null;
2782
- if (!cm.options.lineWrapping) cm.display.maxLineChanged = true;
2783
- cm.display.lineNumChars = null;
2784
- }
2785
-
2786
- function pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft; }
2787
- function pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop; }
2788
-
2789
- // Converts a {top, bottom, left, right} box from line-local
2790
- // coordinates into another coordinate system. Context may be one of
2791
- // "line", "div" (display.lineDiv), "local"/null (editor), "window",
2792
- // or "page".
2793
- function intoCoordSystem(cm, lineObj, rect, context) {
2794
- if (lineObj.widgets) for (var i = 0; i < lineObj.widgets.length; ++i) if (lineObj.widgets[i].above) {
2795
- var size = widgetHeight(lineObj.widgets[i]);
2796
- rect.top += size; rect.bottom += size;
2797
- }
2798
- if (context == "line") return rect;
2799
- if (!context) context = "local";
2800
- var yOff = heightAtLine(lineObj);
2801
- if (context == "local") yOff += paddingTop(cm.display);
2802
- else yOff -= cm.display.viewOffset;
2803
- if (context == "page" || context == "window") {
2804
- var lOff = cm.display.lineSpace.getBoundingClientRect();
2805
- yOff += lOff.top + (context == "window" ? 0 : pageScrollY());
2806
- var xOff = lOff.left + (context == "window" ? 0 : pageScrollX());
2807
- rect.left += xOff; rect.right += xOff;
2808
- }
2809
- rect.top += yOff; rect.bottom += yOff;
2810
- return rect;
2811
- }
2812
-
2813
- // Coverts a box from "div" coords to another coordinate system.
2814
- // Context may be "window", "page", "div", or "local"/null.
2815
- function fromCoordSystem(cm, coords, context) {
2816
- if (context == "div") return coords;
2817
- var left = coords.left, top = coords.top;
2818
- // First move into "page" coordinate system
2819
- if (context == "page") {
2820
- left -= pageScrollX();
2821
- top -= pageScrollY();
2822
- } else if (context == "local" || !context) {
2823
- var localBox = cm.display.sizer.getBoundingClientRect();
2824
- left += localBox.left;
2825
- top += localBox.top;
2826
- }
2827
-
2828
- var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();
2829
- return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top};
2830
- }
2831
-
2832
- function charCoords(cm, pos, context, lineObj, bias) {
2833
- if (!lineObj) lineObj = getLine(cm.doc, pos.line);
2834
- return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context);
2835
- }
2836
-
2837
- // Returns a box for a given cursor position, which may have an
2838
- // 'other' property containing the position of the secondary cursor
2839
- // on a bidi boundary.
2840
- function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
2841
- lineObj = lineObj || getLine(cm.doc, pos.line);
2842
- if (!preparedMeasure) preparedMeasure = prepareMeasureForLine(cm, lineObj);
2843
- function get(ch, right) {
2844
- var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight);
2845
- if (right) m.left = m.right; else m.right = m.left;
2846
- return intoCoordSystem(cm, lineObj, m, context);
2847
- }
2848
- function getBidi(ch, partPos) {
2849
- var part = order[partPos], right = part.level % 2;
2850
- if (ch == bidiLeft(part) && partPos && part.level < order[partPos - 1].level) {
2851
- part = order[--partPos];
2852
- ch = bidiRight(part) - (part.level % 2 ? 0 : 1);
2853
- right = true;
2854
- } else if (ch == bidiRight(part) && partPos < order.length - 1 && part.level < order[partPos + 1].level) {
2855
- part = order[++partPos];
2856
- ch = bidiLeft(part) - part.level % 2;
2857
- right = false;
2858
- }
2859
- if (right && ch == part.to && ch > part.from) return get(ch - 1);
2860
- return get(ch, right);
2861
- }
2862
- var order = getOrder(lineObj), ch = pos.ch;
2863
- if (!order) return get(ch);
2864
- var partPos = getBidiPartAt(order, ch);
2865
- var val = getBidi(ch, partPos);
2866
- if (bidiOther != null) val.other = getBidi(ch, bidiOther);
2867
- return val;
2868
- }
2869
-
2870
- // Used to cheaply estimate the coordinates for a position. Used for
2871
- // intermediate scroll updates.
2872
- function estimateCoords(cm, pos) {
2873
- var left = 0, pos = clipPos(cm.doc, pos);
2874
- if (!cm.options.lineWrapping) left = charWidth(cm.display) * pos.ch;
2875
- var lineObj = getLine(cm.doc, pos.line);
2876
- var top = heightAtLine(lineObj) + paddingTop(cm.display);
2877
- return {left: left, right: left, top: top, bottom: top + lineObj.height};
2878
- }
2879
-
2880
- // Positions returned by coordsChar contain some extra information.
2881
- // xRel is the relative x position of the input coordinates compared
2882
- // to the found position (so xRel > 0 means the coordinates are to
2883
- // the right of the character position, for example). When outside
2884
- // is true, that means the coordinates lie outside the line's
2885
- // vertical range.
2886
- function PosWithInfo(line, ch, outside, xRel) {
2887
- var pos = Pos(line, ch);
2888
- pos.xRel = xRel;
2889
- if (outside) pos.outside = true;
2890
- return pos;
2891
- }
2892
-
2893
- // Compute the character position closest to the given coordinates.
2894
- // Input must be lineSpace-local ("div" coordinate system).
2895
- function coordsChar(cm, x, y) {
2896
- var doc = cm.doc;
2897
- y += cm.display.viewOffset;
2898
- if (y < 0) return PosWithInfo(doc.first, 0, true, -1);
2899
- var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1;
2900
- if (lineN > last)
2901
- return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, true, 1);
2902
- if (x < 0) x = 0;
2903
-
2904
- var lineObj = getLine(doc, lineN);
2905
- for (;;) {
2906
- var found = coordsCharInner(cm, lineObj, lineN, x, y);
2907
- var merged = collapsedSpanAtEnd(lineObj);
2908
- var mergedPos = merged && merged.find(0, true);
2909
- if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0))
2910
- lineN = lineNo(lineObj = mergedPos.to.line);
2911
- else
2912
- return found;
2913
- }
2914
- }
2915
-
2916
- function coordsCharInner(cm, lineObj, lineNo, x, y) {
2917
- var innerOff = y - heightAtLine(lineObj);
2918
- var wrongLine = false, adjust = 2 * cm.display.wrapper.clientWidth;
2919
- var preparedMeasure = prepareMeasureForLine(cm, lineObj);
2920
-
2921
- function getX(ch) {
2922
- var sp = cursorCoords(cm, Pos(lineNo, ch), "line", lineObj, preparedMeasure);
2923
- wrongLine = true;
2924
- if (innerOff > sp.bottom) return sp.left - adjust;
2925
- else if (innerOff < sp.top) return sp.left + adjust;
2926
- else wrongLine = false;
2927
- return sp.left;
2928
- }
2929
-
2930
- var bidi = getOrder(lineObj), dist = lineObj.text.length;
2931
- var from = lineLeft(lineObj), to = lineRight(lineObj);
2932
- var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine;
2933
-
2934
- if (x > toX) return PosWithInfo(lineNo, to, toOutside, 1);
2935
- // Do a binary search between these bounds.
2936
- for (;;) {
2937
- if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {
2938
- var ch = x < fromX || x - fromX <= toX - x ? from : to;
2939
- var outside = ch == from ? fromOutside : toOutside
2940
- var xDiff = x - (ch == from ? fromX : toX);
2941
- // This is a kludge to handle the case where the coordinates
2942
- // are after a line-wrapped line. We should replace it with a
2943
- // more general handling of cursor positions around line
2944
- // breaks. (Issue #4078)
2945
- if (toOutside && !bidi && !/\s/.test(lineObj.text.charAt(ch)) && xDiff > 0 &&
2946
- ch < lineObj.text.length && preparedMeasure.view.measure.heights.length > 1) {
2947
- var charSize = measureCharPrepared(cm, preparedMeasure, ch, "right");
2948
- if (innerOff <= charSize.bottom && innerOff >= charSize.top && Math.abs(x - charSize.right) < xDiff) {
2949
- outside = false
2950
- ch++
2951
- xDiff = x - charSize.right
2952
- }
2953
- }
2954
- while (isExtendingChar(lineObj.text.charAt(ch))) ++ch;
2955
- var pos = PosWithInfo(lineNo, ch, outside, xDiff < -1 ? -1 : xDiff > 1 ? 1 : 0);
2956
- return pos;
2957
- }
2958
- var step = Math.ceil(dist / 2), middle = from + step;
2959
- if (bidi) {
2960
- middle = from;
2961
- for (var i = 0; i < step; ++i) middle = moveVisually(lineObj, middle, 1);
2962
- }
2963
- var middleX = getX(middle);
2964
- if (middleX > x) {to = middle; toX = middleX; if (toOutside = wrongLine) toX += 1000; dist = step;}
2965
- else {from = middle; fromX = middleX; fromOutside = wrongLine; dist -= step;}
2966
- }
2967
- }
2968
-
2969
- var measureText;
2970
- // Compute the default text height.
2971
- function textHeight(display) {
2972
- if (display.cachedTextHeight != null) return display.cachedTextHeight;
2973
- if (measureText == null) {
2974
- measureText = elt("pre");
2975
- // Measure a bunch of lines, for browsers that compute
2976
- // fractional heights.
2977
- for (var i = 0; i < 49; ++i) {
2978
- measureText.appendChild(document.createTextNode("x"));
2979
- measureText.appendChild(elt("br"));
2980
- }
2981
- measureText.appendChild(document.createTextNode("x"));
2982
- }
2983
- removeChildrenAndAdd(display.measure, measureText);
2984
- var height = measureText.offsetHeight / 50;
2985
- if (height > 3) display.cachedTextHeight = height;
2986
- removeChildren(display.measure);
2987
- return height || 1;
2988
- }
2989
-
2990
- // Compute the default character width.
2991
- function charWidth(display) {
2992
- if (display.cachedCharWidth != null) return display.cachedCharWidth;
2993
- var anchor = elt("span", "xxxxxxxxxx");
2994
- var pre = elt("pre", [anchor]);
2995
- removeChildrenAndAdd(display.measure, pre);
2996
- var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10;
2997
- if (width > 2) display.cachedCharWidth = width;
2998
- return width || 10;
2999
- }
3000
-
3001
- // OPERATIONS
3002
-
3003
- // Operations are used to wrap a series of changes to the editor
3004
- // state in such a way that each change won't have to update the
3005
- // cursor and display (which would be awkward, slow, and
3006
- // error-prone). Instead, display updates are batched and then all
3007
- // combined and executed at once.
3008
-
3009
- var operationGroup = null;
3010
-
3011
- var nextOpId = 0;
3012
- // Start a new operation.
3013
- function startOperation(cm) {
3014
- cm.curOp = {
3015
- cm: cm,
3016
- viewChanged: false, // Flag that indicates that lines might need to be redrawn
3017
- startHeight: cm.doc.height, // Used to detect need to update scrollbar
3018
- forceUpdate: false, // Used to force a redraw
3019
- updateInput: null, // Whether to reset the input textarea
3020
- typing: false, // Whether this reset should be careful to leave existing text (for compositing)
3021
- changeObjs: null, // Accumulated changes, for firing change events
3022
- cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
3023
- cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
3024
- selectionChanged: false, // Whether the selection needs to be redrawn
3025
- updateMaxLine: false, // Set when the widest line needs to be determined anew
3026
- scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
3027
- scrollToPos: null, // Used to scroll to a specific position
3028
- focus: false,
3029
- id: ++nextOpId // Unique ID
3030
- };
3031
- if (operationGroup) {
3032
- operationGroup.ops.push(cm.curOp);
3033
- } else {
3034
- cm.curOp.ownsGroup = operationGroup = {
3035
- ops: [cm.curOp],
3036
- delayedCallbacks: []
3037
- };
3038
- }
3039
- }
3040
-
3041
- function fireCallbacksForOps(group) {
3042
- // Calls delayed callbacks and cursorActivity handlers until no
3043
- // new ones appear
3044
- var callbacks = group.delayedCallbacks, i = 0;
3045
- do {
3046
- for (; i < callbacks.length; i++)
3047
- callbacks[i].call(null);
3048
- for (var j = 0; j < group.ops.length; j++) {
3049
- var op = group.ops[j];
3050
- if (op.cursorActivityHandlers)
3051
- while (op.cursorActivityCalled < op.cursorActivityHandlers.length)
3052
- op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm);
3053
- }
3054
- } while (i < callbacks.length);
3055
- }
3056
-
3057
- // Finish an operation, updating the display and signalling delayed events
3058
- function endOperation(cm) {
3059
- var op = cm.curOp, group = op.ownsGroup;
3060
- if (!group) return;
3061
-
3062
- try { fireCallbacksForOps(group); }
3063
- finally {
3064
- operationGroup = null;
3065
- for (var i = 0; i < group.ops.length; i++)
3066
- group.ops[i].cm.curOp = null;
3067
- endOperations(group);
3068
- }
3069
- }
3070
-
3071
- // The DOM updates done when an operation finishes are batched so
3072
- // that the minimum number of relayouts are required.
3073
- function endOperations(group) {
3074
- var ops = group.ops;
3075
- for (var i = 0; i < ops.length; i++) // Read DOM
3076
- endOperation_R1(ops[i]);
3077
- for (var i = 0; i < ops.length; i++) // Write DOM (maybe)
3078
- endOperation_W1(ops[i]);
3079
- for (var i = 0; i < ops.length; i++) // Read DOM
3080
- endOperation_R2(ops[i]);
3081
- for (var i = 0; i < ops.length; i++) // Write DOM (maybe)
3082
- endOperation_W2(ops[i]);
3083
- for (var i = 0; i < ops.length; i++) // Read DOM
3084
- endOperation_finish(ops[i]);
3085
- }
3086
-
3087
- function endOperation_R1(op) {
3088
- var cm = op.cm, display = cm.display;
3089
- maybeClipScrollbars(cm);
3090
- if (op.updateMaxLine) findMaxLine(cm);
3091
-
3092
- op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
3093
- op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
3094
- op.scrollToPos.to.line >= display.viewTo) ||
3095
- display.maxLineChanged && cm.options.lineWrapping;
3096
- op.update = op.mustUpdate &&
3097
- new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate);
3098
- }
3099
-
3100
- function endOperation_W1(op) {
3101
- op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update);
3102
- }
3103
-
3104
- function endOperation_R2(op) {
3105
- var cm = op.cm, display = cm.display;
3106
- if (op.updatedDisplay) updateHeightsInViewport(cm);
3107
-
3108
- op.barMeasure = measureForScrollbars(cm);
3109
-
3110
- // If the max line changed since it was last measured, measure it,
3111
- // and ensure the document's width matches it.
3112
- // updateDisplay_W2 will use these properties to do the actual resizing
3113
- if (display.maxLineChanged && !cm.options.lineWrapping) {
3114
- op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3;
3115
- cm.display.sizerWidth = op.adjustWidthTo;
3116
- op.barMeasure.scrollWidth =
3117
- Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth);
3118
- op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm));
3119
- }
3120
-
3121
- if (op.updatedDisplay || op.selectionChanged)
3122
- op.preparedSelection = display.input.prepareSelection(op.focus);
3123
- }
3124
-
3125
- function endOperation_W2(op) {
3126
- var cm = op.cm;
3127
-
3128
- if (op.adjustWidthTo != null) {
3129
- cm.display.sizer.style.minWidth = op.adjustWidthTo + "px";
3130
- if (op.maxScrollLeft < cm.doc.scrollLeft)
3131
- setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true);
3132
- cm.display.maxLineChanged = false;
3133
- }
3134
-
3135
- var takeFocus = op.focus && op.focus == activeElt() && (!document.hasFocus || document.hasFocus())
3136
- if (op.preparedSelection)
3137
- cm.display.input.showSelection(op.preparedSelection, takeFocus);
3138
- if (op.updatedDisplay || op.startHeight != cm.doc.height)
3139
- updateScrollbars(cm, op.barMeasure);
3140
- if (op.updatedDisplay)
3141
- setDocumentHeight(cm, op.barMeasure);
3142
-
3143
- if (op.selectionChanged) restartBlink(cm);
3144
-
3145
- if (cm.state.focused && op.updateInput)
3146
- cm.display.input.reset(op.typing);
3147
- if (takeFocus) ensureFocus(op.cm);
3148
- }
3149
-
3150
- function endOperation_finish(op) {
3151
- var cm = op.cm, display = cm.display, doc = cm.doc;
3152
-
3153
- if (op.updatedDisplay) postUpdateDisplay(cm, op.update);
3154
-
3155
- // Abort mouse wheel delta measurement, when scrolling explicitly
3156
- if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
3157
- display.wheelStartX = display.wheelStartY = null;
3158
-
3159
- // Propagate the scroll position to the actual DOM scroller
3160
- if (op.scrollTop != null && (display.scroller.scrollTop != op.scrollTop || op.forceScroll)) {
3161
- doc.scrollTop = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, op.scrollTop));
3162
- display.scrollbars.setScrollTop(doc.scrollTop);
3163
- display.scroller.scrollTop = doc.scrollTop;
3164
- }
3165
- if (op.scrollLeft != null && (display.scroller.scrollLeft != op.scrollLeft || op.forceScroll)) {
3166
- doc.scrollLeft = Math.max(0, Math.min(display.scroller.scrollWidth - display.scroller.clientWidth, op.scrollLeft));
3167
- display.scrollbars.setScrollLeft(doc.scrollLeft);
3168
- display.scroller.scrollLeft = doc.scrollLeft;
3169
- alignHorizontally(cm);
3170
- }
3171
- // If we need to scroll a specific position into view, do so.
3172
- if (op.scrollToPos) {
3173
- var coords = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
3174
- clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin);
3175
- if (op.scrollToPos.isCursor && cm.state.focused) maybeScrollWindow(cm, coords);
3176
- }
3177
-
3178
- // Fire events for markers that are hidden/unidden by editing or
3179
- // undoing
3180
- var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers;
3181
- if (hidden) for (var i = 0; i < hidden.length; ++i)
3182
- if (!hidden[i].lines.length) signal(hidden[i], "hide");
3183
- if (unhidden) for (var i = 0; i < unhidden.length; ++i)
3184
- if (unhidden[i].lines.length) signal(unhidden[i], "unhide");
3185
-
3186
- if (display.wrapper.offsetHeight)
3187
- doc.scrollTop = cm.display.scroller.scrollTop;
3188
-
3189
- // Fire change events, and delayed event handlers
3190
- if (op.changeObjs)
3191
- signal(cm, "changes", cm, op.changeObjs);
3192
- if (op.update)
3193
- op.update.finish();
3194
- }
3195
-
3196
- // Run the given function in an operation
3197
- function runInOp(cm, f) {
3198
- if (cm.curOp) return f();
3199
- startOperation(cm);
3200
- try { return f(); }
3201
- finally { endOperation(cm); }
3202
- }
3203
- // Wraps a function in an operation. Returns the wrapped function.
3204
- function operation(cm, f) {
3205
- return function() {
3206
- if (cm.curOp) return f.apply(cm, arguments);
3207
- startOperation(cm);
3208
- try { return f.apply(cm, arguments); }
3209
- finally { endOperation(cm); }
3210
- };
3211
- }
3212
- // Used to add methods to editor and doc instances, wrapping them in
3213
- // operations.
3214
- function methodOp(f) {
3215
- return function() {
3216
- if (this.curOp) return f.apply(this, arguments);
3217
- startOperation(this);
3218
- try { return f.apply(this, arguments); }
3219
- finally { endOperation(this); }
3220
- };
3221
- }
3222
- function docMethodOp(f) {
3223
- return function() {
3224
- var cm = this.cm;
3225
- if (!cm || cm.curOp) return f.apply(this, arguments);
3226
- startOperation(cm);
3227
- try { return f.apply(this, arguments); }
3228
- finally { endOperation(cm); }
3229
- };
3230
- }
3231
-
3232
- // VIEW TRACKING
3233
-
3234
- // These objects are used to represent the visible (currently drawn)
3235
- // part of the document. A LineView may correspond to multiple
3236
- // logical lines, if those are connected by collapsed ranges.
3237
- function LineView(doc, line, lineN) {
3238
- // The starting line
3239
- this.line = line;
3240
- // Continuing lines, if any
3241
- this.rest = visualLineContinued(line);
3242
- // Number of logical lines in this visual line
3243
- this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;
3244
- this.node = this.text = null;
3245
- this.hidden = lineIsHidden(doc, line);
3246
- }
3247
-
3248
- // Create a range of LineView objects for the given lines.
3249
- function buildViewArray(cm, from, to) {
3250
- var array = [], nextPos;
3251
- for (var pos = from; pos < to; pos = nextPos) {
3252
- var view = new LineView(cm.doc, getLine(cm.doc, pos), pos);
3253
- nextPos = pos + view.size;
3254
- array.push(view);
3255
- }
3256
- return array;
3257
- }
3258
-
3259
- // Updates the display.view data structure for a given change to the
3260
- // document. From and to are in pre-change coordinates. Lendiff is
3261
- // the amount of lines added or subtracted by the change. This is
3262
- // used for changes that span multiple lines, or change the way
3263
- // lines are divided into visual lines. regLineChange (below)
3264
- // registers single-line changes.
3265
- function regChange(cm, from, to, lendiff) {
3266
- if (from == null) from = cm.doc.first;
3267
- if (to == null) to = cm.doc.first + cm.doc.size;
3268
- if (!lendiff) lendiff = 0;
3269
-
3270
- var display = cm.display;
3271
- if (lendiff && to < display.viewTo &&
3272
- (display.updateLineNumbers == null || display.updateLineNumbers > from))
3273
- display.updateLineNumbers = from;
3274
-
3275
- cm.curOp.viewChanged = true;
3276
-
3277
- if (from >= display.viewTo) { // Change after
3278
- if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
3279
- resetView(cm);
3280
- } else if (to <= display.viewFrom) { // Change before
3281
- if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
3282
- resetView(cm);
3283
- } else {
3284
- display.viewFrom += lendiff;
3285
- display.viewTo += lendiff;
3286
- }
3287
- } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
3288
- resetView(cm);
3289
- } else if (from <= display.viewFrom) { // Top overlap
3290
- var cut = viewCuttingPoint(cm, to, to + lendiff, 1);
3291
- if (cut) {
3292
- display.view = display.view.slice(cut.index);
3293
- display.viewFrom = cut.lineN;
3294
- display.viewTo += lendiff;
3295
- } else {
3296
- resetView(cm);
3297
- }
3298
- } else if (to >= display.viewTo) { // Bottom overlap
3299
- var cut = viewCuttingPoint(cm, from, from, -1);
3300
- if (cut) {
3301
- display.view = display.view.slice(0, cut.index);
3302
- display.viewTo = cut.lineN;
3303
- } else {
3304
- resetView(cm);
3305
- }
3306
- } else { // Gap in the middle
3307
- var cutTop = viewCuttingPoint(cm, from, from, -1);
3308
- var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1);
3309
- if (cutTop && cutBot) {
3310
- display.view = display.view.slice(0, cutTop.index)
3311
- .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
3312
- .concat(display.view.slice(cutBot.index));
3313
- display.viewTo += lendiff;
3314
- } else {
3315
- resetView(cm);
3316
- }
3317
- }
3318
-
3319
- var ext = display.externalMeasured;
3320
- if (ext) {
3321
- if (to < ext.lineN)
3322
- ext.lineN += lendiff;
3323
- else if (from < ext.lineN + ext.size)
3324
- display.externalMeasured = null;
3325
- }
3326
- }
3327
-
3328
- // Register a change to a single line. Type must be one of "text",
3329
- // "gutter", "class", "widget"
3330
- function regLineChange(cm, line, type) {
3331
- cm.curOp.viewChanged = true;
3332
- var display = cm.display, ext = cm.display.externalMeasured;
3333
- if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
3334
- display.externalMeasured = null;
3335
-
3336
- if (line < display.viewFrom || line >= display.viewTo) return;
3337
- var lineView = display.view[findViewIndex(cm, line)];
3338
- if (lineView.node == null) return;
3339
- var arr = lineView.changes || (lineView.changes = []);
3340
- if (indexOf(arr, type) == -1) arr.push(type);
3341
- }
3342
-
3343
- // Clear the view.
3344
- function resetView(cm) {
3345
- cm.display.viewFrom = cm.display.viewTo = cm.doc.first;
3346
- cm.display.view = [];
3347
- cm.display.viewOffset = 0;
3348
- }
3349
-
3350
- // Find the view element corresponding to a given line. Return null
3351
- // when the line isn't visible.
3352
- function findViewIndex(cm, n) {
3353
- if (n >= cm.display.viewTo) return null;
3354
- n -= cm.display.viewFrom;
3355
- if (n < 0) return null;
3356
- var view = cm.display.view;
3357
- for (var i = 0; i < view.length; i++) {
3358
- n -= view[i].size;
3359
- if (n < 0) return i;
3360
- }
3361
- }
3362
-
3363
- function viewCuttingPoint(cm, oldN, newN, dir) {
3364
- var index = findViewIndex(cm, oldN), diff, view = cm.display.view;
3365
- if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)
3366
- return {index: index, lineN: newN};
3367
- for (var i = 0, n = cm.display.viewFrom; i < index; i++)
3368
- n += view[i].size;
3369
- if (n != oldN) {
3370
- if (dir > 0) {
3371
- if (index == view.length - 1) return null;
3372
- diff = (n + view[index].size) - oldN;
3373
- index++;
3374
- } else {
3375
- diff = n - oldN;
3376
- }
3377
- oldN += diff; newN += diff;
3378
- }
3379
- while (visualLineNo(cm.doc, newN) != newN) {
3380
- if (index == (dir < 0 ? 0 : view.length - 1)) return null;
3381
- newN += dir * view[index - (dir < 0 ? 1 : 0)].size;
3382
- index += dir;
3383
- }
3384
- return {index: index, lineN: newN};
3385
- }
3386
-
3387
- // Force the view to cover a given range, adding empty view element
3388
- // or clipping off existing ones as needed.
3389
- function adjustView(cm, from, to) {
3390
- var display = cm.display, view = display.view;
3391
- if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
3392
- display.view = buildViewArray(cm, from, to);
3393
- display.viewFrom = from;
3394
- } else {
3395
- if (display.viewFrom > from)
3396
- display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view);
3397
- else if (display.viewFrom < from)
3398
- display.view = display.view.slice(findViewIndex(cm, from));
3399
- display.viewFrom = from;
3400
- if (display.viewTo < to)
3401
- display.view = display.view.concat(buildViewArray(cm, display.viewTo, to));
3402
- else if (display.viewTo > to)
3403
- display.view = display.view.slice(0, findViewIndex(cm, to));
3404
- }
3405
- display.viewTo = to;
3406
- }
3407
-
3408
- // Count the number of lines in the view whose DOM representation is
3409
- // out of date (or nonexistent).
3410
- function countDirtyView(cm) {
3411
- var view = cm.display.view, dirty = 0;
3412
- for (var i = 0; i < view.length; i++) {
3413
- var lineView = view[i];
3414
- if (!lineView.hidden && (!lineView.node || lineView.changes)) ++dirty;
3415
- }
3416
- return dirty;
3417
- }
3418
-
3419
- // EVENT HANDLERS
3420
-
3421
- // Attach the necessary event handlers when initializing the editor
3422
- function registerEventHandlers(cm) {
3423
- var d = cm.display;
3424
- on(d.scroller, "mousedown", operation(cm, onMouseDown));
3425
- // Older IE's will not fire a second mousedown for a double click
3426
- if (ie && ie_version < 11)
3427
- on(d.scroller, "dblclick", operation(cm, function(e) {
3428
- if (signalDOMEvent(cm, e)) return;
3429
- var pos = posFromMouse(cm, e);
3430
- if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return;
3431
- e_preventDefault(e);
3432
- var word = cm.findWordAt(pos);
3433
- extendSelection(cm.doc, word.anchor, word.head);
3434
- }));
3435
- else
3436
- on(d.scroller, "dblclick", function(e) { signalDOMEvent(cm, e) || e_preventDefault(e); });
3437
- // Some browsers fire contextmenu *after* opening the menu, at
3438
- // which point we can't mess with it anymore. Context menu is
3439
- // handled in onMouseDown for these browsers.
3440
- if (!captureRightClick) on(d.scroller, "contextmenu", function(e) {onContextMenu(cm, e);});
3441
-
3442
- // Used to suppress mouse event handling when a touch happens
3443
- var touchFinished, prevTouch = {end: 0};
3444
- function finishTouch() {
3445
- if (d.activeTouch) {
3446
- touchFinished = setTimeout(function() {d.activeTouch = null;}, 1000);
3447
- prevTouch = d.activeTouch;
3448
- prevTouch.end = +new Date;
3449
- }
3450
- };
3451
- function isMouseLikeTouchEvent(e) {
3452
- if (e.touches.length != 1) return false;
3453
- var touch = e.touches[0];
3454
- return touch.radiusX <= 1 && touch.radiusY <= 1;
3455
- }
3456
- function farAway(touch, other) {
3457
- if (other.left == null) return true;
3458
- var dx = other.left - touch.left, dy = other.top - touch.top;
3459
- return dx * dx + dy * dy > 20 * 20;
3460
- }
3461
- on(d.scroller, "touchstart", function(e) {
3462
- if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e)) {
3463
- clearTimeout(touchFinished);
3464
- var now = +new Date;
3465
- d.activeTouch = {start: now, moved: false,
3466
- prev: now - prevTouch.end <= 300 ? prevTouch : null};
3467
- if (e.touches.length == 1) {
3468
- d.activeTouch.left = e.touches[0].pageX;
3469
- d.activeTouch.top = e.touches[0].pageY;
3470
- }
3471
- }
3472
- });
3473
- on(d.scroller, "touchmove", function() {
3474
- if (d.activeTouch) d.activeTouch.moved = true;
3475
- });
3476
- on(d.scroller, "touchend", function(e) {
3477
- var touch = d.activeTouch;
3478
- if (touch && !eventInWidget(d, e) && touch.left != null &&
3479
- !touch.moved && new Date - touch.start < 300) {
3480
- var pos = cm.coordsChar(d.activeTouch, "page"), range;
3481
- if (!touch.prev || farAway(touch, touch.prev)) // Single tap
3482
- range = new Range(pos, pos);
3483
- else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
3484
- range = cm.findWordAt(pos);
3485
- else // Triple tap
3486
- range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)));
3487
- cm.setSelection(range.anchor, range.head);
3488
- cm.focus();
3489
- e_preventDefault(e);
3490
- }
3491
- finishTouch();
3492
- });
3493
- on(d.scroller, "touchcancel", finishTouch);
3494
-
3495
- // Sync scrolling between fake scrollbars and real scrollable
3496
- // area, ensure viewport is updated when scrolling.
3497
- on(d.scroller, "scroll", function() {
3498
- if (d.scroller.clientHeight) {
3499
- setScrollTop(cm, d.scroller.scrollTop);
3500
- setScrollLeft(cm, d.scroller.scrollLeft, true);
3501
- signal(cm, "scroll", cm);
3502
- }
3503
- });
3504
-
3505
- // Listen to wheel events in order to try and update the viewport on time.
3506
- on(d.scroller, "mousewheel", function(e){onScrollWheel(cm, e);});
3507
- on(d.scroller, "DOMMouseScroll", function(e){onScrollWheel(cm, e);});
3508
-
3509
- // Prevent wrapper from ever scrolling
3510
- on(d.wrapper, "scroll", function() { d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });
3511
-
3512
- d.dragFunctions = {
3513
- enter: function(e) {if (!signalDOMEvent(cm, e)) e_stop(e);},
3514
- over: function(e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e); }},
3515
- start: function(e){onDragStart(cm, e);},
3516
- drop: operation(cm, onDrop),
3517
- leave: function(e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm); }}
3518
- };
3519
-
3520
- var inp = d.input.getField();
3521
- on(inp, "keyup", function(e) { onKeyUp.call(cm, e); });
3522
- on(inp, "keydown", operation(cm, onKeyDown));
3523
- on(inp, "keypress", operation(cm, onKeyPress));
3524
- on(inp, "focus", bind(onFocus, cm));
3525
- on(inp, "blur", bind(onBlur, cm));
3526
- }
3527
-
3528
- function dragDropChanged(cm, value, old) {
3529
- var wasOn = old && old != CodeMirror.Init;
3530
- if (!value != !wasOn) {
3531
- var funcs = cm.display.dragFunctions;
3532
- var toggle = value ? on : off;
3533
- toggle(cm.display.scroller, "dragstart", funcs.start);
3534
- toggle(cm.display.scroller, "dragenter", funcs.enter);
3535
- toggle(cm.display.scroller, "dragover", funcs.over);
3536
- toggle(cm.display.scroller, "dragleave", funcs.leave);
3537
- toggle(cm.display.scroller, "drop", funcs.drop);
3538
- }
3539
- }
3540
-
3541
- // Called when the window resizes
3542
- function onResize(cm) {
3543
- var d = cm.display;
3544
- if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)
3545
- return;
3546
- // Might be a text scaling operation, clear size caches.
3547
- d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
3548
- d.scrollbarsClipped = false;
3549
- cm.setSize();
3550
- }
3551
-
3552
- // MOUSE EVENTS
3553
-
3554
- // Return true when the given mouse event happened in a widget
3555
- function eventInWidget(display, e) {
3556
- for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
3557
- if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
3558
- (n.parentNode == display.sizer && n != display.mover))
3559
- return true;
3560
- }
3561
- }
3562
-
3563
- // Given a mouse event, find the corresponding position. If liberal
3564
- // is false, it checks whether a gutter or scrollbar was clicked,
3565
- // and returns null if it was. forRect is used by rectangular
3566
- // selections, and tries to estimate a character position even for
3567
- // coordinates beyond the right of the text.
3568
- function posFromMouse(cm, e, liberal, forRect) {
3569
- var display = cm.display;
3570
- if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") return null;
3571
-
3572
- var x, y, space = display.lineSpace.getBoundingClientRect();
3573
- // Fails unpredictably on IE[67] when mouse is dragged around quickly.
3574
- try { x = e.clientX - space.left; y = e.clientY - space.top; }
3575
- catch (e) { return null; }
3576
- var coords = coordsChar(cm, x, y), line;
3577
- if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {
3578
- var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length;
3579
- coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff));
3580
- }
3581
- return coords;
3582
- }
3583
-
3584
- // A mouse down can be a single click, double click, triple click,
3585
- // start of selection drag, start of text drag, new cursor
3586
- // (ctrl-click), rectangle drag (alt-drag), or xwin
3587
- // middle-click-paste. Or it might be a click on something we should
3588
- // not interfere with, such as a scrollbar or widget.
3589
- function onMouseDown(e) {
3590
- var cm = this, display = cm.display;
3591
- if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) return;
3592
- display.shift = e.shiftKey;
3593
-
3594
- if (eventInWidget(display, e)) {
3595
- if (!webkit) {
3596
- // Briefly turn off draggability, to allow widgets to do
3597
- // normal dragging things.
3598
- display.scroller.draggable = false;
3599
- setTimeout(function(){display.scroller.draggable = true;}, 100);
3600
- }
3601
- return;
3602
- }
3603
- if (clickInGutter(cm, e)) return;
3604
- var start = posFromMouse(cm, e);
3605
- window.focus();
3606
-
3607
- switch (e_button(e)) {
3608
- case 1:
3609
- // #3261: make sure, that we're not starting a second selection
3610
- if (cm.state.selectingText)
3611
- cm.state.selectingText(e);
3612
- else if (start)
3613
- leftButtonDown(cm, e, start);
3614
- else if (e_target(e) == display.scroller)
3615
- e_preventDefault(e);
3616
- break;
3617
- case 2:
3618
- if (webkit) cm.state.lastMiddleDown = +new Date;
3619
- if (start) extendSelection(cm.doc, start);
3620
- setTimeout(function() {display.input.focus();}, 20);
3621
- e_preventDefault(e);
3622
- break;
3623
- case 3:
3624
- if (captureRightClick) onContextMenu(cm, e);
3625
- else delayBlurEvent(cm);
3626
- break;
3627
- }
3628
- }
3629
-
3630
- var lastClick, lastDoubleClick;
3631
- function leftButtonDown(cm, e, start) {
3632
- if (ie) setTimeout(bind(ensureFocus, cm), 0);
3633
- else cm.curOp.focus = activeElt();
3634
-
3635
- var now = +new Date, type;
3636
- if (lastDoubleClick && lastDoubleClick.time > now - 400 && cmp(lastDoubleClick.pos, start) == 0) {
3637
- type = "triple";
3638
- } else if (lastClick && lastClick.time > now - 400 && cmp(lastClick.pos, start) == 0) {
3639
- type = "double";
3640
- lastDoubleClick = {time: now, pos: start};
3641
- } else {
3642
- type = "single";
3643
- lastClick = {time: now, pos: start};
3644
- }
3645
-
3646
- var sel = cm.doc.sel, modifier = mac ? e.metaKey : e.ctrlKey, contained;
3647
- if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&
3648
- type == "single" && (contained = sel.contains(start)) > -1 &&
3649
- (cmp((contained = sel.ranges[contained]).from(), start) < 0 || start.xRel > 0) &&
3650
- (cmp(contained.to(), start) > 0 || start.xRel < 0))
3651
- leftButtonStartDrag(cm, e, start, modifier);
3652
- else
3653
- leftButtonSelect(cm, e, start, type, modifier);
3654
- }
3655
-
3656
- // Start a text drag. When it ends, see if any dragging actually
3657
- // happen, and treat as a click if it didn't.
3658
- function leftButtonStartDrag(cm, e, start, modifier) {
3659
- var display = cm.display, startTime = +new Date;
3660
- var dragEnd = operation(cm, function(e2) {
3661
- if (webkit) display.scroller.draggable = false;
3662
- cm.state.draggingText = false;
3663
- off(document, "mouseup", dragEnd);
3664
- off(display.scroller, "drop", dragEnd);
3665
- if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {
3666
- e_preventDefault(e2);
3667
- if (!modifier && +new Date - 200 < startTime)
3668
- extendSelection(cm.doc, start);
3669
- // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
3670
- if (webkit || ie && ie_version == 9)
3671
- setTimeout(function() {document.body.focus(); display.input.focus();}, 20);
3672
- else
3673
- display.input.focus();
3674
- }
3675
- });
3676
- // Let the drag handler handle this.
3677
- if (webkit) display.scroller.draggable = true;
3678
- cm.state.draggingText = dragEnd;
3679
- dragEnd.copy = mac ? e.altKey : e.ctrlKey
3680
- // IE's approach to draggable
3681
- if (display.scroller.dragDrop) display.scroller.dragDrop();
3682
- on(document, "mouseup", dragEnd);
3683
- on(display.scroller, "drop", dragEnd);
3684
- }
3685
-
3686
- // Normal selection, as opposed to text dragging.
3687
- function leftButtonSelect(cm, e, start, type, addNew) {
3688
- var display = cm.display, doc = cm.doc;
3689
- e_preventDefault(e);
3690
-
3691
- var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges;
3692
- if (addNew && !e.shiftKey) {
3693
- ourIndex = doc.sel.contains(start);
3694
- if (ourIndex > -1)
3695
- ourRange = ranges[ourIndex];
3696
- else
3697
- ourRange = new Range(start, start);
3698
- } else {
3699
- ourRange = doc.sel.primary();
3700
- ourIndex = doc.sel.primIndex;
3701
- }
3702
-
3703
- if (chromeOS ? e.shiftKey && e.metaKey : e.altKey) {
3704
- type = "rect";
3705
- if (!addNew) ourRange = new Range(start, start);
3706
- start = posFromMouse(cm, e, true, true);
3707
- ourIndex = -1;
3708
- } else if (type == "double") {
3709
- var word = cm.findWordAt(start);
3710
- if (cm.display.shift || doc.extend)
3711
- ourRange = extendRange(doc, ourRange, word.anchor, word.head);
3712
- else
3713
- ourRange = word;
3714
- } else if (type == "triple") {
3715
- var line = new Range(Pos(start.line, 0), clipPos(doc, Pos(start.line + 1, 0)));
3716
- if (cm.display.shift || doc.extend)
3717
- ourRange = extendRange(doc, ourRange, line.anchor, line.head);
3718
- else
3719
- ourRange = line;
3720
- } else {
3721
- ourRange = extendRange(doc, ourRange, start);
3722
- }
3723
-
3724
- if (!addNew) {
3725
- ourIndex = 0;
3726
- setSelection(doc, new Selection([ourRange], 0), sel_mouse);
3727
- startSel = doc.sel;
3728
- } else if (ourIndex == -1) {
3729
- ourIndex = ranges.length;
3730
- setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),
3731
- {scroll: false, origin: "*mouse"});
3732
- } else if (ranges.length > 1 && ranges[ourIndex].empty() && type == "single" && !e.shiftKey) {
3733
- setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),
3734
- {scroll: false, origin: "*mouse"});
3735
- startSel = doc.sel;
3736
- } else {
3737
- replaceOneSelection(doc, ourIndex, ourRange, sel_mouse);
3738
- }
3739
-
3740
- var lastPos = start;
3741
- function extendTo(pos) {
3742
- if (cmp(lastPos, pos) == 0) return;
3743
- lastPos = pos;
3744
-
3745
- if (type == "rect") {
3746
- var ranges = [], tabSize = cm.options.tabSize;
3747
- var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize);
3748
- var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize);
3749
- var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol);
3750
- for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
3751
- line <= end; line++) {
3752
- var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize);
3753
- if (left == right)
3754
- ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos)));
3755
- else if (text.length > leftPos)
3756
- ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize))));
3757
- }
3758
- if (!ranges.length) ranges.push(new Range(start, start));
3759
- setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
3760
- {origin: "*mouse", scroll: false});
3761
- cm.scrollIntoView(pos);
3762
- } else {
3763
- var oldRange = ourRange;
3764
- var anchor = oldRange.anchor, head = pos;
3765
- if (type != "single") {
3766
- if (type == "double")
3767
- var range = cm.findWordAt(pos);
3768
- else
3769
- var range = new Range(Pos(pos.line, 0), clipPos(doc, Pos(pos.line + 1, 0)));
3770
- if (cmp(range.anchor, anchor) > 0) {
3771
- head = range.head;
3772
- anchor = minPos(oldRange.from(), range.anchor);
3773
- } else {
3774
- head = range.anchor;
3775
- anchor = maxPos(oldRange.to(), range.head);
3776
- }
3777
- }
3778
- var ranges = startSel.ranges.slice(0);
3779
- ranges[ourIndex] = new Range(clipPos(doc, anchor), head);
3780
- setSelection(doc, normalizeSelection(ranges, ourIndex), sel_mouse);
3781
- }
3782
- }
3783
-
3784
- var editorSize = display.wrapper.getBoundingClientRect();
3785
- // Used to ensure timeout re-tries don't fire when another extend
3786
- // happened in the meantime (clearTimeout isn't reliable -- at
3787
- // least on Chrome, the timeouts still happen even when cleared,
3788
- // if the clear happens after their scheduled firing time).
3789
- var counter = 0;
3790
-
3791
- function extend(e) {
3792
- var curCount = ++counter;
3793
- var cur = posFromMouse(cm, e, true, type == "rect");
3794
- if (!cur) return;
3795
- if (cmp(cur, lastPos) != 0) {
3796
- cm.curOp.focus = activeElt();
3797
- extendTo(cur);
3798
- var visible = visibleLines(display, doc);
3799
- if (cur.line >= visible.to || cur.line < visible.from)
3800
- setTimeout(operation(cm, function(){if (counter == curCount) extend(e);}), 150);
3801
- } else {
3802
- var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0;
3803
- if (outside) setTimeout(operation(cm, function() {
3804
- if (counter != curCount) return;
3805
- display.scroller.scrollTop += outside;
3806
- extend(e);
3807
- }), 50);
3808
- }
3809
- }
3810
-
3811
- function done(e) {
3812
- cm.state.selectingText = false;
3813
- counter = Infinity;
3814
- e_preventDefault(e);
3815
- display.input.focus();
3816
- off(document, "mousemove", move);
3817
- off(document, "mouseup", up);
3818
- doc.history.lastSelOrigin = null;
3819
- }
3820
-
3821
- var move = operation(cm, function(e) {
3822
- if (!e_button(e)) done(e);
3823
- else extend(e);
3824
- });
3825
- var up = operation(cm, done);
3826
- cm.state.selectingText = up;
3827
- on(document, "mousemove", move);
3828
- on(document, "mouseup", up);
3829
- }
3830
-
3831
- // Determines whether an event happened in the gutter, and fires the
3832
- // handlers for the corresponding event.
3833
- function gutterEvent(cm, e, type, prevent) {
3834
- try { var mX = e.clientX, mY = e.clientY; }
3835
- catch(e) { return false; }
3836
- if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) return false;
3837
- if (prevent) e_preventDefault(e);
3838
-
3839
- var display = cm.display;
3840
- var lineBox = display.lineDiv.getBoundingClientRect();
3841
-
3842
- if (mY > lineBox.bottom || !hasHandler(cm, type)) return e_defaultPrevented(e);
3843
- mY -= lineBox.top - display.viewOffset;
3844
-
3845
- for (var i = 0; i < cm.options.gutters.length; ++i) {
3846
- var g = display.gutters.childNodes[i];
3847
- if (g && g.getBoundingClientRect().right >= mX) {
3848
- var line = lineAtHeight(cm.doc, mY);
3849
- var gutter = cm.options.gutters[i];
3850
- signal(cm, type, cm, line, gutter, e);
3851
- return e_defaultPrevented(e);
3852
- }
3853
- }
3854
- }
3855
-
3856
- function clickInGutter(cm, e) {
3857
- return gutterEvent(cm, e, "gutterClick", true);
3858
- }
3859
-
3860
- // Kludge to work around strange IE behavior where it'll sometimes
3861
- // re-fire a series of drag-related events right after the drop (#1551)
3862
- var lastDrop = 0;
3863
-
3864
- function onDrop(e) {
3865
- var cm = this;
3866
- clearDragCursor(cm);
3867
- if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
3868
- return;
3869
- e_preventDefault(e);
3870
- if (ie) lastDrop = +new Date;
3871
- var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files;
3872
- if (!pos || cm.isReadOnly()) return;
3873
- // Might be a file drop, in which case we simply extract the text
3874
- // and insert it.
3875
- if (files && files.length && window.FileReader && window.File) {
3876
- var n = files.length, text = Array(n), read = 0;
3877
- var loadFile = function(file, i) {
3878
- if (cm.options.allowDropFileTypes &&
3879
- indexOf(cm.options.allowDropFileTypes, file.type) == -1)
3880
- return;
3881
-
3882
- var reader = new FileReader;
3883
- reader.onload = operation(cm, function() {
3884
- var content = reader.result;
3885
- if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) content = "";
3886
- text[i] = content;
3887
- if (++read == n) {
3888
- pos = clipPos(cm.doc, pos);
3889
- var change = {from: pos, to: pos,
3890
- text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())),
3891
- origin: "paste"};
3892
- makeChange(cm.doc, change);
3893
- setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)));
3894
- }
3895
- });
3896
- reader.readAsText(file);
3897
- };
3898
- for (var i = 0; i < n; ++i) loadFile(files[i], i);
3899
- } else { // Normal drop
3900
- // Don't do a replace if the drop happened inside of the selected text.
3901
- if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
3902
- cm.state.draggingText(e);
3903
- // Ensure the editor is re-focused
3904
- setTimeout(function() {cm.display.input.focus();}, 20);
3905
- return;
3906
- }
3907
- try {
3908
- var text = e.dataTransfer.getData("Text");
3909
- if (text) {
3910
- if (cm.state.draggingText && !cm.state.draggingText.copy)
3911
- var selected = cm.listSelections();
3912
- setSelectionNoUndo(cm.doc, simpleSelection(pos, pos));
3913
- if (selected) for (var i = 0; i < selected.length; ++i)
3914
- replaceRange(cm.doc, "", selected[i].anchor, selected[i].head, "drag");
3915
- cm.replaceSelection(text, "around", "paste");
3916
- cm.display.input.focus();
3917
- }
3918
- }
3919
- catch(e){}
3920
- }
3921
- }
3922
-
3923
- function onDragStart(cm, e) {
3924
- if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return; }
3925
- if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) return;
3926
-
3927
- e.dataTransfer.setData("Text", cm.getSelection());
3928
- e.dataTransfer.effectAllowed = "copyMove"
3929
-
3930
- // Use dummy image instead of default browsers image.
3931
- // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
3932
- if (e.dataTransfer.setDragImage && !safari) {
3933
- var img = elt("img", null, null, "position: fixed; left: 0; top: 0;");
3934
- img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
3935
- if (presto) {
3936
- img.width = img.height = 1;
3937
- cm.display.wrapper.appendChild(img);
3938
- // Force a relayout, or Opera won't use our image for some obscure reason
3939
- img._top = img.offsetTop;
3940
- }
3941
- e.dataTransfer.setDragImage(img, 0, 0);
3942
- if (presto) img.parentNode.removeChild(img);
3943
- }
3944
- }
3945
-
3946
- function onDragOver(cm, e) {
3947
- var pos = posFromMouse(cm, e);
3948
- if (!pos) return;
3949
- var frag = document.createDocumentFragment();
3950
- drawSelectionCursor(cm, pos, frag);
3951
- if (!cm.display.dragCursor) {
3952
- cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors");
3953
- cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv);
3954
- }
3955
- removeChildrenAndAdd(cm.display.dragCursor, frag);
3956
- }
3957
-
3958
- function clearDragCursor(cm) {
3959
- if (cm.display.dragCursor) {
3960
- cm.display.lineSpace.removeChild(cm.display.dragCursor);
3961
- cm.display.dragCursor = null;
3962
- }
3963
- }
3964
-
3965
- // SCROLL EVENTS
3966
-
3967
- // Sync the scrollable area and scrollbars, ensure the viewport
3968
- // covers the visible area.
3969
- function setScrollTop(cm, val) {
3970
- if (Math.abs(cm.doc.scrollTop - val) < 2) return;
3971
- cm.doc.scrollTop = val;
3972
- if (!gecko) updateDisplaySimple(cm, {top: val});
3973
- if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val;
3974
- cm.display.scrollbars.setScrollTop(val);
3975
- if (gecko) updateDisplaySimple(cm);
3976
- startWorker(cm, 100);
3977
- }
3978
- // Sync scroller and scrollbar, ensure the gutter elements are
3979
- // aligned.
3980
- function setScrollLeft(cm, val, isScroller) {
3981
- if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) return;
3982
- val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth);
3983
- cm.doc.scrollLeft = val;
3984
- alignHorizontally(cm);
3985
- if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val;
3986
- cm.display.scrollbars.setScrollLeft(val);
3987
- }
3988
-
3989
- // Since the delta values reported on mouse wheel events are
3990
- // unstandardized between browsers and even browser versions, and
3991
- // generally horribly unpredictable, this code starts by measuring
3992
- // the scroll effect that the first few mouse wheel events have,
3993
- // and, from that, detects the way it can convert deltas to pixel
3994
- // offsets afterwards.
3995
- //
3996
- // The reason we want to know the amount a wheel event will scroll
3997
- // is that it gives us a chance to update the display before the
3998
- // actual scrolling happens, reducing flickering.
3999
-
4000
- var wheelSamples = 0, wheelPixelsPerUnit = null;
4001
- // Fill in a browser-detected starting value on browsers where we
4002
- // know one. These don't have to be accurate -- the result of them
4003
- // being wrong would just be a slight flicker on the first wheel
4004
- // scroll (if it is large enough).
4005
- if (ie) wheelPixelsPerUnit = -.53;
4006
- else if (gecko) wheelPixelsPerUnit = 15;
4007
- else if (chrome) wheelPixelsPerUnit = -.7;
4008
- else if (safari) wheelPixelsPerUnit = -1/3;
4009
-
4010
- var wheelEventDelta = function(e) {
4011
- var dx = e.wheelDeltaX, dy = e.wheelDeltaY;
4012
- if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail;
4013
- if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail;
4014
- else if (dy == null) dy = e.wheelDelta;
4015
- return {x: dx, y: dy};
4016
- };
4017
- CodeMirror.wheelEventPixels = function(e) {
4018
- var delta = wheelEventDelta(e);
4019
- delta.x *= wheelPixelsPerUnit;
4020
- delta.y *= wheelPixelsPerUnit;
4021
- return delta;
4022
- };
4023
-
4024
- function onScrollWheel(cm, e) {
4025
- var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y;
4026
-
4027
- var display = cm.display, scroll = display.scroller;
4028
- // Quit if there's nothing to scroll here
4029
- var canScrollX = scroll.scrollWidth > scroll.clientWidth;
4030
- var canScrollY = scroll.scrollHeight > scroll.clientHeight;
4031
- if (!(dx && canScrollX || dy && canScrollY)) return;
4032
-
4033
- // Webkit browsers on OS X abort momentum scrolls when the target
4034
- // of the scroll event is removed from the scrollable element.
4035
- // This hack (see related code in patchDisplay) makes sure the
4036
- // element is kept around.
4037
- if (dy && mac && webkit) {
4038
- outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
4039
- for (var i = 0; i < view.length; i++) {
4040
- if (view[i].node == cur) {
4041
- cm.display.currentWheelTarget = cur;
4042
- break outer;
4043
- }
4044
- }
4045
- }
4046
- }
4047
-
4048
- // On some browsers, horizontal scrolling will cause redraws to
4049
- // happen before the gutter has been realigned, causing it to
4050
- // wriggle around in a most unseemly way. When we have an
4051
- // estimated pixels/delta value, we just handle horizontal
4052
- // scrolling entirely here. It'll be slightly off from native, but
4053
- // better than glitching out.
4054
- if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {
4055
- if (dy && canScrollY)
4056
- setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight)));
4057
- setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)));
4058
- // Only prevent default scrolling if vertical scrolling is
4059
- // actually possible. Otherwise, it causes vertical scroll
4060
- // jitter on OSX trackpads when deltaX is small and deltaY
4061
- // is large (issue #3579)
4062
- if (!dy || (dy && canScrollY))
4063
- e_preventDefault(e);
4064
- display.wheelStartX = null; // Abort measurement, if in progress
4065
- return;
4066
- }
4067
-
4068
- // 'Project' the visible viewport to cover the area that is being
4069
- // scrolled into view (if we know enough to estimate it).
4070
- if (dy && wheelPixelsPerUnit != null) {
4071
- var pixels = dy * wheelPixelsPerUnit;
4072
- var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight;
4073
- if (pixels < 0) top = Math.max(0, top + pixels - 50);
4074
- else bot = Math.min(cm.doc.height, bot + pixels + 50);
4075
- updateDisplaySimple(cm, {top: top, bottom: bot});
4076
- }
4077
-
4078
- if (wheelSamples < 20) {
4079
- if (display.wheelStartX == null) {
4080
- display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop;
4081
- display.wheelDX = dx; display.wheelDY = dy;
4082
- setTimeout(function() {
4083
- if (display.wheelStartX == null) return;
4084
- var movedX = scroll.scrollLeft - display.wheelStartX;
4085
- var movedY = scroll.scrollTop - display.wheelStartY;
4086
- var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
4087
- (movedX && display.wheelDX && movedX / display.wheelDX);
4088
- display.wheelStartX = display.wheelStartY = null;
4089
- if (!sample) return;
4090
- wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);
4091
- ++wheelSamples;
4092
- }, 200);
4093
- } else {
4094
- display.wheelDX += dx; display.wheelDY += dy;
4095
- }
4096
- }
4097
- }
4098
-
4099
- // KEY EVENTS
4100
-
4101
- // Run a handler that was bound to a key.
4102
- function doHandleBinding(cm, bound, dropShift) {
4103
- if (typeof bound == "string") {
4104
- bound = commands[bound];
4105
- if (!bound) return false;
4106
- }
4107
- // Ensure previous input has been read, so that the handler sees a
4108
- // consistent view of the document
4109
- cm.display.input.ensurePolled();
4110
- var prevShift = cm.display.shift, done = false;
4111
- try {
4112
- if (cm.isReadOnly()) cm.state.suppressEdits = true;
4113
- if (dropShift) cm.display.shift = false;
4114
- done = bound(cm) != Pass;
4115
- } finally {
4116
- cm.display.shift = prevShift;
4117
- cm.state.suppressEdits = false;
4118
- }
4119
- return done;
4120
- }
4121
-
4122
- function lookupKeyForEditor(cm, name, handle) {
4123
- for (var i = 0; i < cm.state.keyMaps.length; i++) {
4124
- var result = lookupKey(name, cm.state.keyMaps[i], handle, cm);
4125
- if (result) return result;
4126
- }
4127
- return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))
4128
- || lookupKey(name, cm.options.keyMap, handle, cm);
4129
- }
4130
-
4131
- var stopSeq = new Delayed;
4132
- function dispatchKey(cm, name, e, handle) {
4133
- var seq = cm.state.keySeq;
4134
- if (seq) {
4135
- if (isModifierKey(name)) return "handled";
4136
- stopSeq.set(50, function() {
4137
- if (cm.state.keySeq == seq) {
4138
- cm.state.keySeq = null;
4139
- cm.display.input.reset();
4140
- }
4141
- });
4142
- name = seq + " " + name;
4143
- }
4144
- var result = lookupKeyForEditor(cm, name, handle);
4145
-
4146
- if (result == "multi")
4147
- cm.state.keySeq = name;
4148
- if (result == "handled")
4149
- signalLater(cm, "keyHandled", cm, name, e);
4150
-
4151
- if (result == "handled" || result == "multi") {
4152
- e_preventDefault(e);
4153
- restartBlink(cm);
4154
- }
4155
-
4156
- if (seq && !result && /\'$/.test(name)) {
4157
- e_preventDefault(e);
4158
- return true;
4159
- }
4160
- return !!result;
4161
- }
4162
-
4163
- // Handle a key from the keydown event.
4164
- function handleKeyBinding(cm, e) {
4165
- var name = keyName(e, true);
4166
- if (!name) return false;
4167
-
4168
- if (e.shiftKey && !cm.state.keySeq) {
4169
- // First try to resolve full name (including 'Shift-'). Failing
4170
- // that, see if there is a cursor-motion command (starting with
4171
- // 'go') bound to the keyname without 'Shift-'.
4172
- return dispatchKey(cm, "Shift-" + name, e, function(b) {return doHandleBinding(cm, b, true);})
4173
- || dispatchKey(cm, name, e, function(b) {
4174
- if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
4175
- return doHandleBinding(cm, b);
4176
- });
4177
- } else {
4178
- return dispatchKey(cm, name, e, function(b) { return doHandleBinding(cm, b); });
4179
- }
4180
- }
4181
-
4182
- // Handle a key from the keypress event
4183
- function handleCharBinding(cm, e, ch) {
4184
- return dispatchKey(cm, "'" + ch + "'", e,
4185
- function(b) { return doHandleBinding(cm, b, true); });
4186
- }
4187
-
4188
- var lastStoppedKey = null;
4189
- function onKeyDown(e) {
4190
- var cm = this;
4191
- cm.curOp.focus = activeElt();
4192
- if (signalDOMEvent(cm, e)) return;
4193
- // IE does strange things with escape.
4194
- if (ie && ie_version < 11 && e.keyCode == 27) e.returnValue = false;
4195
- var code = e.keyCode;
4196
- cm.display.shift = code == 16 || e.shiftKey;
4197
- var handled = handleKeyBinding(cm, e);
4198
- if (presto) {
4199
- lastStoppedKey = handled ? code : null;
4200
- // Opera has no cut event... we try to at least catch the key combo
4201
- if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
4202
- cm.replaceSelection("", null, "cut");
4203
- }
4204
-
4205
- // Turn mouse into crosshair when Alt is held on Mac.
4206
- if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
4207
- showCrossHair(cm);
4208
- }
4209
-
4210
- function showCrossHair(cm) {
4211
- var lineDiv = cm.display.lineDiv;
4212
- addClass(lineDiv, "CodeMirror-crosshair");
4213
-
4214
- function up(e) {
4215
- if (e.keyCode == 18 || !e.altKey) {
4216
- rmClass(lineDiv, "CodeMirror-crosshair");
4217
- off(document, "keyup", up);
4218
- off(document, "mouseover", up);
4219
- }
4220
- }
4221
- on(document, "keyup", up);
4222
- on(document, "mouseover", up);
4223
- }
4224
-
4225
- function onKeyUp(e) {
4226
- if (e.keyCode == 16) this.doc.sel.shift = false;
4227
- signalDOMEvent(this, e);
4228
- }
4229
-
4230
- function onKeyPress(e) {
4231
- var cm = this;
4232
- if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) return;
4233
- var keyCode = e.keyCode, charCode = e.charCode;
4234
- if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return;}
4235
- if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) return;
4236
- var ch = String.fromCharCode(charCode == null ? keyCode : charCode);
4237
- if (handleCharBinding(cm, e, ch)) return;
4238
- cm.display.input.onKeyPress(e);
4239
- }
4240
-
4241
- // FOCUS/BLUR EVENTS
4242
-
4243
- function delayBlurEvent(cm) {
4244
- cm.state.delayingBlurEvent = true;
4245
- setTimeout(function() {
4246
- if (cm.state.delayingBlurEvent) {
4247
- cm.state.delayingBlurEvent = false;
4248
- onBlur(cm);
4249
- }
4250
- }, 100);
4251
- }
4252
-
4253
- function onFocus(cm) {
4254
- if (cm.state.delayingBlurEvent) cm.state.delayingBlurEvent = false;
4255
-
4256
- if (cm.options.readOnly == "nocursor") return;
4257
- if (!cm.state.focused) {
4258
- signal(cm, "focus", cm);
4259
- cm.state.focused = true;
4260
- addClass(cm.display.wrapper, "CodeMirror-focused");
4261
- // This test prevents this from firing when a context
4262
- // menu is closed (since the input reset would kill the
4263
- // select-all detection hack)
4264
- if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
4265
- cm.display.input.reset();
4266
- if (webkit) setTimeout(function() { cm.display.input.reset(true); }, 20); // Issue #1730
4267
- }
4268
- cm.display.input.receivedFocus();
4269
- }
4270
- restartBlink(cm);
4271
- }
4272
- function onBlur(cm) {
4273
- if (cm.state.delayingBlurEvent) return;
4274
-
4275
- if (cm.state.focused) {
4276
- signal(cm, "blur", cm);
4277
- cm.state.focused = false;
4278
- rmClass(cm.display.wrapper, "CodeMirror-focused");
4279
- }
4280
- clearInterval(cm.display.blinker);
4281
- setTimeout(function() {if (!cm.state.focused) cm.display.shift = false;}, 150);
4282
- }
4283
-
4284
- // CONTEXT MENU HANDLING
4285
-
4286
- // To make the context menu work, we need to briefly unhide the
4287
- // textarea (making it as unobtrusive as possible) to let the
4288
- // right-click take effect on it.
4289
- function onContextMenu(cm, e) {
4290
- if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) return;
4291
- if (signalDOMEvent(cm, e, "contextmenu")) return;
4292
- cm.display.input.onContextMenu(e);
4293
- }
4294
-
4295
- function contextMenuInGutter(cm, e) {
4296
- if (!hasHandler(cm, "gutterContextMenu")) return false;
4297
- return gutterEvent(cm, e, "gutterContextMenu", false);
4298
- }
4299
-
4300
- // UPDATING
4301
-
4302
- // Compute the position of the end of a change (its 'to' property
4303
- // refers to the pre-change end).
4304
- var changeEnd = CodeMirror.changeEnd = function(change) {
4305
- if (!change.text) return change.to;
4306
- return Pos(change.from.line + change.text.length - 1,
4307
- lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0));
4308
- };
4309
-
4310
- // Adjust a position to refer to the post-change position of the
4311
- // same text, or the end of the change if the change covers it.
4312
- function adjustForChange(pos, change) {
4313
- if (cmp(pos, change.from) < 0) return pos;
4314
- if (cmp(pos, change.to) <= 0) return changeEnd(change);
4315
-
4316
- var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch;
4317
- if (pos.line == change.to.line) ch += changeEnd(change).ch - change.to.ch;
4318
- return Pos(line, ch);
4319
- }
4320
-
4321
- function computeSelAfterChange(doc, change) {
4322
- var out = [];
4323
- for (var i = 0; i < doc.sel.ranges.length; i++) {
4324
- var range = doc.sel.ranges[i];
4325
- out.push(new Range(adjustForChange(range.anchor, change),
4326
- adjustForChange(range.head, change)));
4327
- }
4328
- return normalizeSelection(out, doc.sel.primIndex);
4329
- }
4330
-
4331
- function offsetPos(pos, old, nw) {
4332
- if (pos.line == old.line)
4333
- return Pos(nw.line, pos.ch - old.ch + nw.ch);
4334
- else
4335
- return Pos(nw.line + (pos.line - old.line), pos.ch);
4336
- }
4337
-
4338
- // Used by replaceSelections to allow moving the selection to the
4339
- // start or around the replaced test. Hint may be "start" or "around".
4340
- function computeReplacedSel(doc, changes, hint) {
4341
- var out = [];
4342
- var oldPrev = Pos(doc.first, 0), newPrev = oldPrev;
4343
- for (var i = 0; i < changes.length; i++) {
4344
- var change = changes[i];
4345
- var from = offsetPos(change.from, oldPrev, newPrev);
4346
- var to = offsetPos(changeEnd(change), oldPrev, newPrev);
4347
- oldPrev = change.to;
4348
- newPrev = to;
4349
- if (hint == "around") {
4350
- var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0;
4351
- out[i] = new Range(inv ? to : from, inv ? from : to);
4352
- } else {
4353
- out[i] = new Range(from, from);
4354
- }
4355
- }
4356
- return new Selection(out, doc.sel.primIndex);
4357
- }
4358
-
4359
- // Allow "beforeChange" event handlers to influence a change
4360
- function filterChange(doc, change, update) {
4361
- var obj = {
4362
- canceled: false,
4363
- from: change.from,
4364
- to: change.to,
4365
- text: change.text,
4366
- origin: change.origin,
4367
- cancel: function() { this.canceled = true; }
4368
- };
4369
- if (update) obj.update = function(from, to, text, origin) {
4370
- if (from) this.from = clipPos(doc, from);
4371
- if (to) this.to = clipPos(doc, to);
4372
- if (text) this.text = text;
4373
- if (origin !== undefined) this.origin = origin;
4374
- };
4375
- signal(doc, "beforeChange", doc, obj);
4376
- if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj);
4377
-
4378
- if (obj.canceled) return null;
4379
- return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin};
4380
- }
4381
-
4382
- // Apply a change to a document, and add it to the document's
4383
- // history, and propagating it to all linked documents.
4384
- function makeChange(doc, change, ignoreReadOnly) {
4385
- if (doc.cm) {
4386
- if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly);
4387
- if (doc.cm.state.suppressEdits) return;
4388
- }
4389
-
4390
- if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
4391
- change = filterChange(doc, change, true);
4392
- if (!change) return;
4393
- }
4394
-
4395
- // Possibly split or suppress the update based on the presence
4396
- // of read-only spans in its range.
4397
- var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to);
4398
- if (split) {
4399
- for (var i = split.length - 1; i >= 0; --i)
4400
- makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text});
4401
- } else {
4402
- makeChangeInner(doc, change);
4403
- }
4404
- }
4405
-
4406
- function makeChangeInner(doc, change) {
4407
- if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) return;
4408
- var selAfter = computeSelAfterChange(doc, change);
4409
- addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN);
4410
-
4411
- makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change));
4412
- var rebased = [];
4413
-
4414
- linkedDocs(doc, function(doc, sharedHist) {
4415
- if (!sharedHist && indexOf(rebased, doc.history) == -1) {
4416
- rebaseHist(doc.history, change);
4417
- rebased.push(doc.history);
4418
- }
4419
- makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change));
4420
- });
4421
- }
4422
-
4423
- // Revert a change stored in a document's history.
4424
- function makeChangeFromHistory(doc, type, allowSelectionOnly) {
4425
- if (doc.cm && doc.cm.state.suppressEdits && !allowSelectionOnly) return;
4426
-
4427
- var hist = doc.history, event, selAfter = doc.sel;
4428
- var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done;
4429
-
4430
- // Verify that there is a useable event (so that ctrl-z won't
4431
- // needlessly clear selection events)
4432
- for (var i = 0; i < source.length; i++) {
4433
- event = source[i];
4434
- if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
4435
- break;
4436
- }
4437
- if (i == source.length) return;
4438
- hist.lastOrigin = hist.lastSelOrigin = null;
4439
-
4440
- for (;;) {
4441
- event = source.pop();
4442
- if (event.ranges) {
4443
- pushSelectionToHistory(event, dest);
4444
- if (allowSelectionOnly && !event.equals(doc.sel)) {
4445
- setSelection(doc, event, {clearRedo: false});
4446
- return;
4447
- }
4448
- selAfter = event;
4449
- }
4450
- else break;
4451
- }
4452
-
4453
- // Build up a reverse change object to add to the opposite history
4454
- // stack (redo when undoing, and vice versa).
4455
- var antiChanges = [];
4456
- pushSelectionToHistory(selAfter, dest);
4457
- dest.push({changes: antiChanges, generation: hist.generation});
4458
- hist.generation = event.generation || ++hist.maxGeneration;
4459
-
4460
- var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange");
4461
-
4462
- for (var i = event.changes.length - 1; i >= 0; --i) {
4463
- var change = event.changes[i];
4464
- change.origin = type;
4465
- if (filter && !filterChange(doc, change, false)) {
4466
- source.length = 0;
4467
- return;
4468
- }
4469
-
4470
- antiChanges.push(historyChangeFromChange(doc, change));
4471
-
4472
- var after = i ? computeSelAfterChange(doc, change) : lst(source);
4473
- makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change));
4474
- if (!i && doc.cm) doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)});
4475
- var rebased = [];
4476
-
4477
- // Propagate to the linked documents
4478
- linkedDocs(doc, function(doc, sharedHist) {
4479
- if (!sharedHist && indexOf(rebased, doc.history) == -1) {
4480
- rebaseHist(doc.history, change);
4481
- rebased.push(doc.history);
4482
- }
4483
- makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change));
4484
- });
4485
- }
4486
- }
4487
-
4488
- // Sub-views need their line numbers shifted when text is added
4489
- // above or below them in the parent document.
4490
- function shiftDoc(doc, distance) {
4491
- if (distance == 0) return;
4492
- doc.first += distance;
4493
- doc.sel = new Selection(map(doc.sel.ranges, function(range) {
4494
- return new Range(Pos(range.anchor.line + distance, range.anchor.ch),
4495
- Pos(range.head.line + distance, range.head.ch));
4496
- }), doc.sel.primIndex);
4497
- if (doc.cm) {
4498
- regChange(doc.cm, doc.first, doc.first - distance, distance);
4499
- for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
4500
- regLineChange(doc.cm, l, "gutter");
4501
- }
4502
- }
4503
-
4504
- // More lower-level change function, handling only a single document
4505
- // (not linked ones).
4506
- function makeChangeSingleDoc(doc, change, selAfter, spans) {
4507
- if (doc.cm && !doc.cm.curOp)
4508
- return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans);
4509
-
4510
- if (change.to.line < doc.first) {
4511
- shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line));
4512
- return;
4513
- }
4514
- if (change.from.line > doc.lastLine()) return;
4515
-
4516
- // Clip the change to the size of this doc
4517
- if (change.from.line < doc.first) {
4518
- var shift = change.text.length - 1 - (doc.first - change.from.line);
4519
- shiftDoc(doc, shift);
4520
- change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
4521
- text: [lst(change.text)], origin: change.origin};
4522
- }
4523
- var last = doc.lastLine();
4524
- if (change.to.line > last) {
4525
- change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
4526
- text: [change.text[0]], origin: change.origin};
4527
- }
4528
-
4529
- change.removed = getBetween(doc, change.from, change.to);
4530
-
4531
- if (!selAfter) selAfter = computeSelAfterChange(doc, change);
4532
- if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans);
4533
- else updateDoc(doc, change, spans);
4534
- setSelectionNoUndo(doc, selAfter, sel_dontScroll);
4535
- }
4536
-
4537
- // Handle the interaction of a change to a document with the editor
4538
- // that this document is part of.
4539
- function makeChangeSingleDocInEditor(cm, change, spans) {
4540
- var doc = cm.doc, display = cm.display, from = change.from, to = change.to;
4541
-
4542
- var recomputeMaxLength = false, checkWidthStart = from.line;
4543
- if (!cm.options.lineWrapping) {
4544
- checkWidthStart = lineNo(visualLine(getLine(doc, from.line)));
4545
- doc.iter(checkWidthStart, to.line + 1, function(line) {
4546
- if (line == display.maxLine) {
4547
- recomputeMaxLength = true;
4548
- return true;
4549
- }
4550
- });
4551
- }
4552
-
4553
- if (doc.sel.contains(change.from, change.to) > -1)
4554
- signalCursorActivity(cm);
4555
-
4556
- updateDoc(doc, change, spans, estimateHeight(cm));
4557
-
4558
- if (!cm.options.lineWrapping) {
4559
- doc.iter(checkWidthStart, from.line + change.text.length, function(line) {
4560
- var len = lineLength(line);
4561
- if (len > display.maxLineLength) {
4562
- display.maxLine = line;
4563
- display.maxLineLength = len;
4564
- display.maxLineChanged = true;
4565
- recomputeMaxLength = false;
4566
- }
4567
- });
4568
- if (recomputeMaxLength) cm.curOp.updateMaxLine = true;
4569
- }
4570
-
4571
- // Adjust frontier, schedule worker
4572
- doc.frontier = Math.min(doc.frontier, from.line);
4573
- startWorker(cm, 400);
4574
-
4575
- var lendiff = change.text.length - (to.line - from.line) - 1;
4576
- // Remember that these lines changed, for updating the display
4577
- if (change.full)
4578
- regChange(cm);
4579
- else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
4580
- regLineChange(cm, from.line, "text");
4581
- else
4582
- regChange(cm, from.line, to.line + 1, lendiff);
4583
-
4584
- var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change");
4585
- if (changeHandler || changesHandler) {
4586
- var obj = {
4587
- from: from, to: to,
4588
- text: change.text,
4589
- removed: change.removed,
4590
- origin: change.origin
4591
- };
4592
- if (changeHandler) signalLater(cm, "change", cm, obj);
4593
- if (changesHandler) (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj);
4594
- }
4595
- cm.display.selForContextMenu = null;
4596
- }
4597
-
4598
- function replaceRange(doc, code, from, to, origin) {
4599
- if (!to) to = from;
4600
- if (cmp(to, from) < 0) { var tmp = to; to = from; from = tmp; }
4601
- if (typeof code == "string") code = doc.splitLines(code);
4602
- makeChange(doc, {from: from, to: to, text: code, origin: origin});
4603
- }
4604
-
4605
- // SCROLLING THINGS INTO VIEW
4606
-
4607
- // If an editor sits on the top or bottom of the window, partially
4608
- // scrolled out of view, this ensures that the cursor is visible.
4609
- function maybeScrollWindow(cm, coords) {
4610
- if (signalDOMEvent(cm, "scrollCursorIntoView")) return;
4611
-
4612
- var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null;
4613
- if (coords.top + box.top < 0) doScroll = true;
4614
- else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) doScroll = false;
4615
- if (doScroll != null && !phantom) {
4616
- var scrollNode = elt("div", "\u200b", null, "position: absolute; top: " +
4617
- (coords.top - display.viewOffset - paddingTop(cm.display)) + "px; height: " +
4618
- (coords.bottom - coords.top + scrollGap(cm) + display.barHeight) + "px; left: " +
4619
- coords.left + "px; width: 2px;");
4620
- cm.display.lineSpace.appendChild(scrollNode);
4621
- scrollNode.scrollIntoView(doScroll);
4622
- cm.display.lineSpace.removeChild(scrollNode);
4623
- }
4624
- }
4625
-
4626
- // Scroll a given position into view (immediately), verifying that
4627
- // it actually became visible (as line heights are accurately
4628
- // measured, the position of something may 'drift' during drawing).
4629
- function scrollPosIntoView(cm, pos, end, margin) {
4630
- if (margin == null) margin = 0;
4631
- for (var limit = 0; limit < 5; limit++) {
4632
- var changed = false, coords = cursorCoords(cm, pos);
4633
- var endCoords = !end || end == pos ? coords : cursorCoords(cm, end);
4634
- var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left),
4635
- Math.min(coords.top, endCoords.top) - margin,
4636
- Math.max(coords.left, endCoords.left),
4637
- Math.max(coords.bottom, endCoords.bottom) + margin);
4638
- var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft;
4639
- if (scrollPos.scrollTop != null) {
4640
- setScrollTop(cm, scrollPos.scrollTop);
4641
- if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true;
4642
- }
4643
- if (scrollPos.scrollLeft != null) {
4644
- setScrollLeft(cm, scrollPos.scrollLeft);
4645
- if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true;
4646
- }
4647
- if (!changed) break;
4648
- }
4649
- return coords;
4650
- }
4651
-
4652
- // Scroll a given set of coordinates into view (immediately).
4653
- function scrollIntoView(cm, x1, y1, x2, y2) {
4654
- var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2);
4655
- if (scrollPos.scrollTop != null) setScrollTop(cm, scrollPos.scrollTop);
4656
- if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft);
4657
- }
4658
-
4659
- // Calculate a new scroll position needed to scroll the given
4660
- // rectangle into view. Returns an object with scrollTop and
4661
- // scrollLeft properties. When these are undefined, the
4662
- // vertical/horizontal position does not need to be adjusted.
4663
- function calculateScrollPos(cm, x1, y1, x2, y2) {
4664
- var display = cm.display, snapMargin = textHeight(cm.display);
4665
- if (y1 < 0) y1 = 0;
4666
- var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop;
4667
- var screen = displayHeight(cm), result = {};
4668
- if (y2 - y1 > screen) y2 = y1 + screen;
4669
- var docBottom = cm.doc.height + paddingVert(display);
4670
- var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin;
4671
- if (y1 < screentop) {
4672
- result.scrollTop = atTop ? 0 : y1;
4673
- } else if (y2 > screentop + screen) {
4674
- var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen);
4675
- if (newTop != screentop) result.scrollTop = newTop;
4676
- }
4677
-
4678
- var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft;
4679
- var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0);
4680
- var tooWide = x2 - x1 > screenw;
4681
- if (tooWide) x2 = x1 + screenw;
4682
- if (x1 < 10)
4683
- result.scrollLeft = 0;
4684
- else if (x1 < screenleft)
4685
- result.scrollLeft = Math.max(0, x1 - (tooWide ? 0 : 10));
4686
- else if (x2 > screenw + screenleft - 3)
4687
- result.scrollLeft = x2 + (tooWide ? 0 : 10) - screenw;
4688
- return result;
4689
- }
4690
-
4691
- // Store a relative adjustment to the scroll position in the current
4692
- // operation (to be applied when the operation finishes).
4693
- function addToScrollPos(cm, left, top) {
4694
- if (left != null || top != null) resolveScrollToPos(cm);
4695
- if (left != null)
4696
- cm.curOp.scrollLeft = (cm.curOp.scrollLeft == null ? cm.doc.scrollLeft : cm.curOp.scrollLeft) + left;
4697
- if (top != null)
4698
- cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top;
4699
- }
4700
-
4701
- // Make sure that at the end of the operation the current cursor is
4702
- // shown.
4703
- function ensureCursorVisible(cm) {
4704
- resolveScrollToPos(cm);
4705
- var cur = cm.getCursor(), from = cur, to = cur;
4706
- if (!cm.options.lineWrapping) {
4707
- from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur;
4708
- to = Pos(cur.line, cur.ch + 1);
4709
- }
4710
- cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true};
4711
- }
4712
-
4713
- // When an operation has its scrollToPos property set, and another
4714
- // scroll action is applied before the end of the operation, this
4715
- // 'simulates' scrolling that position into view in a cheap way, so
4716
- // that the effect of intermediate scroll commands is not ignored.
4717
- function resolveScrollToPos(cm) {
4718
- var range = cm.curOp.scrollToPos;
4719
- if (range) {
4720
- cm.curOp.scrollToPos = null;
4721
- var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to);
4722
- var sPos = calculateScrollPos(cm, Math.min(from.left, to.left),
4723
- Math.min(from.top, to.top) - range.margin,
4724
- Math.max(from.right, to.right),
4725
- Math.max(from.bottom, to.bottom) + range.margin);
4726
- cm.scrollTo(sPos.scrollLeft, sPos.scrollTop);
4727
- }
4728
- }
4729
-
4730
- // API UTILITIES
4731
-
4732
- // Indent the given line. The how parameter can be "smart",
4733
- // "add"/null, "subtract", or "prev". When aggressive is false
4734
- // (typically set to true for forced single-line indents), empty
4735
- // lines are not indented, and places where the mode returns Pass
4736
- // are left alone.
4737
- function indentLine(cm, n, how, aggressive) {
4738
- var doc = cm.doc, state;
4739
- if (how == null) how = "add";
4740
- if (how == "smart") {
4741
- // Fall back to "prev" when the mode doesn't have an indentation
4742
- // method.
4743
- if (!doc.mode.indent) how = "prev";
4744
- else state = getStateBefore(cm, n);
4745
- }
4746
-
4747
- var tabSize = cm.options.tabSize;
4748
- var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize);
4749
- if (line.stateAfter) line.stateAfter = null;
4750
- var curSpaceString = line.text.match(/^\s*/)[0], indentation;
4751
- if (!aggressive && !/\S/.test(line.text)) {
4752
- indentation = 0;
4753
- how = "not";
4754
- } else if (how == "smart") {
4755
- indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text);
4756
- if (indentation == Pass || indentation > 150) {
4757
- if (!aggressive) return;
4758
- how = "prev";
4759
- }
4760
- }
4761
- if (how == "prev") {
4762
- if (n > doc.first) indentation = countColumn(getLine(doc, n-1).text, null, tabSize);
4763
- else indentation = 0;
4764
- } else if (how == "add") {
4765
- indentation = curSpace + cm.options.indentUnit;
4766
- } else if (how == "subtract") {
4767
- indentation = curSpace - cm.options.indentUnit;
4768
- } else if (typeof how == "number") {
4769
- indentation = curSpace + how;
4770
- }
4771
- indentation = Math.max(0, indentation);
4772
-
4773
- var indentString = "", pos = 0;
4774
- if (cm.options.indentWithTabs)
4775
- for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";}
4776
- if (pos < indentation) indentString += spaceStr(indentation - pos);
4777
-
4778
- if (indentString != curSpaceString) {
4779
- replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input");
4780
- line.stateAfter = null;
4781
- return true;
4782
- } else {
4783
- // Ensure that, if the cursor was in the whitespace at the start
4784
- // of the line, it is moved to the end of that space.
4785
- for (var i = 0; i < doc.sel.ranges.length; i++) {
4786
- var range = doc.sel.ranges[i];
4787
- if (range.head.line == n && range.head.ch < curSpaceString.length) {
4788
- var pos = Pos(n, curSpaceString.length);
4789
- replaceOneSelection(doc, i, new Range(pos, pos));
4790
- break;
4791
- }
4792
- }
4793
- }
4794
- }
4795
-
4796
- // Utility for applying a change to a line by handle or number,
4797
- // returning the number and optionally registering the line as
4798
- // changed.
4799
- function changeLine(doc, handle, changeType, op) {
4800
- var no = handle, line = handle;
4801
- if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle));
4802
- else no = lineNo(handle);
4803
- if (no == null) return null;
4804
- if (op(line, no) && doc.cm) regLineChange(doc.cm, no, changeType);
4805
- return line;
4806
- }
4807
-
4808
- // Helper for deleting text near the selection(s), used to implement
4809
- // backspace, delete, and similar functionality.
4810
- function deleteNearSelection(cm, compute) {
4811
- var ranges = cm.doc.sel.ranges, kill = [];
4812
- // Build up a set of ranges to kill first, merging overlapping
4813
- // ranges.
4814
- for (var i = 0; i < ranges.length; i++) {
4815
- var toKill = compute(ranges[i]);
4816
- while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
4817
- var replaced = kill.pop();
4818
- if (cmp(replaced.from, toKill.from) < 0) {
4819
- toKill.from = replaced.from;
4820
- break;
4821
- }
4822
- }
4823
- kill.push(toKill);
4824
- }
4825
- // Next, remove those actual ranges.
4826
- runInOp(cm, function() {
4827
- for (var i = kill.length - 1; i >= 0; i--)
4828
- replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete");
4829
- ensureCursorVisible(cm);
4830
- });
4831
- }
4832
-
4833
- // Used for horizontal relative motion. Dir is -1 or 1 (left or
4834
- // right), unit can be "char", "column" (like char, but doesn't
4835
- // cross line boundaries), "word" (across next word), or "group" (to
4836
- // the start of next group of word or non-word-non-whitespace
4837
- // chars). The visually param controls whether, in right-to-left
4838
- // text, direction 1 means to move towards the next index in the
4839
- // string, or towards the character to the right of the current
4840
- // position. The resulting position will have a hitSide=true
4841
- // property if it reached the end of the document.
4842
- function findPosH(doc, pos, dir, unit, visually) {
4843
- var line = pos.line, ch = pos.ch, origDir = dir;
4844
- var lineObj = getLine(doc, line);
4845
- function findNextLine() {
4846
- var l = line + dir;
4847
- if (l < doc.first || l >= doc.first + doc.size) return false
4848
- line = l;
4849
- return lineObj = getLine(doc, l);
4850
- }
4851
- function moveOnce(boundToLine) {
4852
- var next = (visually ? moveVisually : moveLogically)(lineObj, ch, dir, true);
4853
- if (next == null) {
4854
- if (!boundToLine && findNextLine()) {
4855
- if (visually) ch = (dir < 0 ? lineRight : lineLeft)(lineObj);
4856
- else ch = dir < 0 ? lineObj.text.length : 0;
4857
- } else return false
4858
- } else ch = next;
4859
- return true;
4860
- }
4861
-
4862
- if (unit == "char") {
4863
- moveOnce()
4864
- } else if (unit == "column") {
4865
- moveOnce(true)
4866
- } else if (unit == "word" || unit == "group") {
4867
- var sawType = null, group = unit == "group";
4868
- var helper = doc.cm && doc.cm.getHelper(pos, "wordChars");
4869
- for (var first = true;; first = false) {
4870
- if (dir < 0 && !moveOnce(!first)) break;
4871
- var cur = lineObj.text.charAt(ch) || "\n";
4872
- var type = isWordChar(cur, helper) ? "w"
4873
- : group && cur == "\n" ? "n"
4874
- : !group || /\s/.test(cur) ? null
4875
- : "p";
4876
- if (group && !first && !type) type = "s";
4877
- if (sawType && sawType != type) {
4878
- if (dir < 0) {dir = 1; moveOnce();}
4879
- break;
4880
- }
4881
-
4882
- if (type) sawType = type;
4883
- if (dir > 0 && !moveOnce(!first)) break;
4884
- }
4885
- }
4886
- var result = skipAtomic(doc, Pos(line, ch), pos, origDir, true);
4887
- if (!cmp(pos, result)) result.hitSide = true;
4888
- return result;
4889
- }
4890
-
4891
- // For relative vertical movement. Dir may be -1 or 1. Unit can be
4892
- // "page" or "line". The resulting position will have a hitSide=true
4893
- // property if it reached the end of the document.
4894
- function findPosV(cm, pos, dir, unit) {
4895
- var doc = cm.doc, x = pos.left, y;
4896
- if (unit == "page") {
4897
- var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight);
4898
- y = pos.top + dir * (pageSize - (dir < 0 ? 1.5 : .5) * textHeight(cm.display));
4899
- } else if (unit == "line") {
4900
- y = dir > 0 ? pos.bottom + 3 : pos.top - 3;
4901
- }
4902
- for (;;) {
4903
- var target = coordsChar(cm, x, y);
4904
- if (!target.outside) break;
4905
- if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break; }
4906
- y += dir * 5;
4907
- }
4908
- return target;
4909
- }
4910
-
4911
- // EDITOR METHODS
4912
-
4913
- // The publicly visible API. Note that methodOp(f) means
4914
- // 'wrap f in an operation, performed on its `this` parameter'.
4915
-
4916
- // This is not the complete set of editor methods. Most of the
4917
- // methods defined on the Doc type are also injected into
4918
- // CodeMirror.prototype, for backwards compatibility and
4919
- // convenience.
4920
-
4921
- CodeMirror.prototype = {
4922
- constructor: CodeMirror,
4923
- focus: function(){window.focus(); this.display.input.focus();},
4924
-
4925
- setOption: function(option, value) {
4926
- var options = this.options, old = options[option];
4927
- if (options[option] == value && option != "mode") return;
4928
- options[option] = value;
4929
- if (optionHandlers.hasOwnProperty(option))
4930
- operation(this, optionHandlers[option])(this, value, old);
4931
- },
4932
-
4933
- getOption: function(option) {return this.options[option];},
4934
- getDoc: function() {return this.doc;},
4935
-
4936
- addKeyMap: function(map, bottom) {
4937
- this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map));
4938
- },
4939
- removeKeyMap: function(map) {
4940
- var maps = this.state.keyMaps;
4941
- for (var i = 0; i < maps.length; ++i)
4942
- if (maps[i] == map || maps[i].name == map) {
4943
- maps.splice(i, 1);
4944
- return true;
4945
- }
4946
- },
4947
-
4948
- addOverlay: methodOp(function(spec, options) {
4949
- var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec);
4950
- if (mode.startState) throw new Error("Overlays may not be stateful.");
4951
- this.state.overlays.push({mode: mode, modeSpec: spec, opaque: options && options.opaque});
4952
- this.state.modeGen++;
4953
- regChange(this);
4954
- }),
4955
- removeOverlay: methodOp(function(spec) {
4956
- var overlays = this.state.overlays;
4957
- for (var i = 0; i < overlays.length; ++i) {
4958
- var cur = overlays[i].modeSpec;
4959
- if (cur == spec || typeof spec == "string" && cur.name == spec) {
4960
- overlays.splice(i, 1);
4961
- this.state.modeGen++;
4962
- regChange(this);
4963
- return;
4964
- }
4965
- }
4966
- }),
4967
-
4968
- indentLine: methodOp(function(n, dir, aggressive) {
4969
- if (typeof dir != "string" && typeof dir != "number") {
4970
- if (dir == null) dir = this.options.smartIndent ? "smart" : "prev";
4971
- else dir = dir ? "add" : "subtract";
4972
- }
4973
- if (isLine(this.doc, n)) indentLine(this, n, dir, aggressive);
4974
- }),
4975
- indentSelection: methodOp(function(how) {
4976
- var ranges = this.doc.sel.ranges, end = -1;
4977
- for (var i = 0; i < ranges.length; i++) {
4978
- var range = ranges[i];
4979
- if (!range.empty()) {
4980
- var from = range.from(), to = range.to();
4981
- var start = Math.max(end, from.line);
4982
- end = Math.min(this.lastLine(), to.line - (to.ch ? 0 : 1)) + 1;
4983
- for (var j = start; j < end; ++j)
4984
- indentLine(this, j, how);
4985
- var newRanges = this.doc.sel.ranges;
4986
- if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)
4987
- replaceOneSelection(this.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll);
4988
- } else if (range.head.line > end) {
4989
- indentLine(this, range.head.line, how, true);
4990
- end = range.head.line;
4991
- if (i == this.doc.sel.primIndex) ensureCursorVisible(this);
4992
- }
4993
- }
4994
- }),
4995
-
4996
- // Fetch the parser token for a given character. Useful for hacks
4997
- // that want to inspect the mode state (say, for completion).
4998
- getTokenAt: function(pos, precise) {
4999
- return takeToken(this, pos, precise);
5000
- },
5001
-
5002
- getLineTokens: function(line, precise) {
5003
- return takeToken(this, Pos(line), precise, true);
5004
- },
5005
-
5006
- getTokenTypeAt: function(pos) {
5007
- pos = clipPos(this.doc, pos);
5008
- var styles = getLineStyles(this, getLine(this.doc, pos.line));
5009
- var before = 0, after = (styles.length - 1) / 2, ch = pos.ch;
5010
- var type;
5011
- if (ch == 0) type = styles[2];
5012
- else for (;;) {
5013
- var mid = (before + after) >> 1;
5014
- if ((mid ? styles[mid * 2 - 1] : 0) >= ch) after = mid;
5015
- else if (styles[mid * 2 + 1] < ch) before = mid + 1;
5016
- else { type = styles[mid * 2 + 2]; break; }
5017
- }
5018
- var cut = type ? type.indexOf("cm-overlay ") : -1;
5019
- return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1);
5020
- },
5021
-
5022
- getModeAt: function(pos) {
5023
- var mode = this.doc.mode;
5024
- if (!mode.innerMode) return mode;
5025
- return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode;
5026
- },
5027
-
5028
- getHelper: function(pos, type) {
5029
- return this.getHelpers(pos, type)[0];
5030
- },
5031
-
5032
- getHelpers: function(pos, type) {
5033
- var found = [];
5034
- if (!helpers.hasOwnProperty(type)) return found;
5035
- var help = helpers[type], mode = this.getModeAt(pos);
5036
- if (typeof mode[type] == "string") {
5037
- if (help[mode[type]]) found.push(help[mode[type]]);
5038
- } else if (mode[type]) {
5039
- for (var i = 0; i < mode[type].length; i++) {
5040
- var val = help[mode[type][i]];
5041
- if (val) found.push(val);
5042
- }
5043
- } else if (mode.helperType && help[mode.helperType]) {
5044
- found.push(help[mode.helperType]);
5045
- } else if (help[mode.name]) {
5046
- found.push(help[mode.name]);
5047
- }
5048
- for (var i = 0; i < help._global.length; i++) {
5049
- var cur = help._global[i];
5050
- if (cur.pred(mode, this) && indexOf(found, cur.val) == -1)
5051
- found.push(cur.val);
5052
- }
5053
- return found;
5054
- },
5055
-
5056
- getStateAfter: function(line, precise) {
5057
- var doc = this.doc;
5058
- line = clipLine(doc, line == null ? doc.first + doc.size - 1: line);
5059
- return getStateBefore(this, line + 1, precise);
5060
- },
5061
-
5062
- cursorCoords: function(start, mode) {
5063
- var pos, range = this.doc.sel.primary();
5064
- if (start == null) pos = range.head;
5065
- else if (typeof start == "object") pos = clipPos(this.doc, start);
5066
- else pos = start ? range.from() : range.to();
5067
- return cursorCoords(this, pos, mode || "page");
5068
- },
5069
-
5070
- charCoords: function(pos, mode) {
5071
- return charCoords(this, clipPos(this.doc, pos), mode || "page");
5072
- },
5073
-
5074
- coordsChar: function(coords, mode) {
5075
- coords = fromCoordSystem(this, coords, mode || "page");
5076
- return coordsChar(this, coords.left, coords.top);
5077
- },
5078
-
5079
- lineAtHeight: function(height, mode) {
5080
- height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top;
5081
- return lineAtHeight(this.doc, height + this.display.viewOffset);
5082
- },
5083
- heightAtLine: function(line, mode) {
5084
- var end = false, lineObj;
5085
- if (typeof line == "number") {
5086
- var last = this.doc.first + this.doc.size - 1;
5087
- if (line < this.doc.first) line = this.doc.first;
5088
- else if (line > last) { line = last; end = true; }
5089
- lineObj = getLine(this.doc, line);
5090
- } else {
5091
- lineObj = line;
5092
- }
5093
- return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page").top +
5094
- (end ? this.doc.height - heightAtLine(lineObj) : 0);
5095
- },
5096
-
5097
- defaultTextHeight: function() { return textHeight(this.display); },
5098
- defaultCharWidth: function() { return charWidth(this.display); },
5099
-
5100
- setGutterMarker: methodOp(function(line, gutterID, value) {
5101
- return changeLine(this.doc, line, "gutter", function(line) {
5102
- var markers = line.gutterMarkers || (line.gutterMarkers = {});
5103
- markers[gutterID] = value;
5104
- if (!value && isEmpty(markers)) line.gutterMarkers = null;
5105
- return true;
5106
- });
5107
- }),
5108
-
5109
- clearGutter: methodOp(function(gutterID) {
5110
- var cm = this, doc = cm.doc, i = doc.first;
5111
- doc.iter(function(line) {
5112
- if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
5113
- line.gutterMarkers[gutterID] = null;
5114
- regLineChange(cm, i, "gutter");
5115
- if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null;
5116
- }
5117
- ++i;
5118
- });
5119
- }),
5120
-
5121
- lineInfo: function(line) {
5122
- if (typeof line == "number") {
5123
- if (!isLine(this.doc, line)) return null;
5124
- var n = line;
5125
- line = getLine(this.doc, line);
5126
- if (!line) return null;
5127
- } else {
5128
- var n = lineNo(line);
5129
- if (n == null) return null;
5130
- }
5131
- return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
5132
- textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
5133
- widgets: line.widgets};
5134
- },
5135
-
5136
- getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo};},
5137
-
5138
- addWidget: function(pos, node, scroll, vert, horiz) {
5139
- var display = this.display;
5140
- pos = cursorCoords(this, clipPos(this.doc, pos));
5141
- var top = pos.bottom, left = pos.left;
5142
- node.style.position = "absolute";
5143
- node.setAttribute("cm-ignore-events", "true");
5144
- this.display.input.setUneditable(node);
5145
- display.sizer.appendChild(node);
5146
- if (vert == "over") {
5147
- top = pos.top;
5148
- } else if (vert == "above" || vert == "near") {
5149
- var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
5150
- hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth);
5151
- // Default to positioning above (if specified and possible); otherwise default to positioning below
5152
- if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
5153
- top = pos.top - node.offsetHeight;
5154
- else if (pos.bottom + node.offsetHeight <= vspace)
5155
- top = pos.bottom;
5156
- if (left + node.offsetWidth > hspace)
5157
- left = hspace - node.offsetWidth;
5158
- }
5159
- node.style.top = top + "px";
5160
- node.style.left = node.style.right = "";
5161
- if (horiz == "right") {
5162
- left = display.sizer.clientWidth - node.offsetWidth;
5163
- node.style.right = "0px";
5164
- } else {
5165
- if (horiz == "left") left = 0;
5166
- else if (horiz == "middle") left = (display.sizer.clientWidth - node.offsetWidth) / 2;
5167
- node.style.left = left + "px";
5168
- }
5169
- if (scroll)
5170
- scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight);
5171
- },
5172
-
5173
- triggerOnKeyDown: methodOp(onKeyDown),
5174
- triggerOnKeyPress: methodOp(onKeyPress),
5175
- triggerOnKeyUp: onKeyUp,
5176
-
5177
- execCommand: function(cmd) {
5178
- if (commands.hasOwnProperty(cmd))
5179
- return commands[cmd].call(null, this);
5180
- },
5181
-
5182
- triggerElectric: methodOp(function(text) { triggerElectric(this, text); }),
5183
-
5184
- findPosH: function(from, amount, unit, visually) {
5185
- var dir = 1;
5186
- if (amount < 0) { dir = -1; amount = -amount; }
5187
- for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
5188
- cur = findPosH(this.doc, cur, dir, unit, visually);
5189
- if (cur.hitSide) break;
5190
- }
5191
- return cur;
5192
- },
5193
-
5194
- moveH: methodOp(function(dir, unit) {
5195
- var cm = this;
5196
- cm.extendSelectionsBy(function(range) {
5197
- if (cm.display.shift || cm.doc.extend || range.empty())
5198
- return findPosH(cm.doc, range.head, dir, unit, cm.options.rtlMoveVisually);
5199
- else
5200
- return dir < 0 ? range.from() : range.to();
5201
- }, sel_move);
5202
- }),
5203
-
5204
- deleteH: methodOp(function(dir, unit) {
5205
- var sel = this.doc.sel, doc = this.doc;
5206
- if (sel.somethingSelected())
5207
- doc.replaceSelection("", null, "+delete");
5208
- else
5209
- deleteNearSelection(this, function(range) {
5210
- var other = findPosH(doc, range.head, dir, unit, false);
5211
- return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other};
5212
- });
5213
- }),
5214
-
5215
- findPosV: function(from, amount, unit, goalColumn) {
5216
- var dir = 1, x = goalColumn;
5217
- if (amount < 0) { dir = -1; amount = -amount; }
5218
- for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
5219
- var coords = cursorCoords(this, cur, "div");
5220
- if (x == null) x = coords.left;
5221
- else coords.left = x;
5222
- cur = findPosV(this, coords, dir, unit);
5223
- if (cur.hitSide) break;
5224
- }
5225
- return cur;
5226
- },
5227
-
5228
- moveV: methodOp(function(dir, unit) {
5229
- var cm = this, doc = this.doc, goals = [];
5230
- var collapse = !cm.display.shift && !doc.extend && doc.sel.somethingSelected();
5231
- doc.extendSelectionsBy(function(range) {
5232
- if (collapse)
5233
- return dir < 0 ? range.from() : range.to();
5234
- var headPos = cursorCoords(cm, range.head, "div");
5235
- if (range.goalColumn != null) headPos.left = range.goalColumn;
5236
- goals.push(headPos.left);
5237
- var pos = findPosV(cm, headPos, dir, unit);
5238
- if (unit == "page" && range == doc.sel.primary())
5239
- addToScrollPos(cm, null, charCoords(cm, pos, "div").top - headPos.top);
5240
- return pos;
5241
- }, sel_move);
5242
- if (goals.length) for (var i = 0; i < doc.sel.ranges.length; i++)
5243
- doc.sel.ranges[i].goalColumn = goals[i];
5244
- }),
5245
-
5246
- // Find the word at the given position (as returned by coordsChar).
5247
- findWordAt: function(pos) {
5248
- var doc = this.doc, line = getLine(doc, pos.line).text;
5249
- var start = pos.ch, end = pos.ch;
5250
- if (line) {
5251
- var helper = this.getHelper(pos, "wordChars");
5252
- if ((pos.xRel < 0 || end == line.length) && start) --start; else ++end;
5253
- var startChar = line.charAt(start);
5254
- var check = isWordChar(startChar, helper)
5255
- ? function(ch) { return isWordChar(ch, helper); }
5256
- : /\s/.test(startChar) ? function(ch) {return /\s/.test(ch);}
5257
- : function(ch) {return !/\s/.test(ch) && !isWordChar(ch);};
5258
- while (start > 0 && check(line.charAt(start - 1))) --start;
5259
- while (end < line.length && check(line.charAt(end))) ++end;
5260
- }
5261
- return new Range(Pos(pos.line, start), Pos(pos.line, end));
5262
- },
5263
-
5264
- toggleOverwrite: function(value) {
5265
- if (value != null && value == this.state.overwrite) return;
5266
- if (this.state.overwrite = !this.state.overwrite)
5267
- addClass(this.display.cursorDiv, "CodeMirror-overwrite");
5268
- else
5269
- rmClass(this.display.cursorDiv, "CodeMirror-overwrite");
5270
-
5271
- signal(this, "overwriteToggle", this, this.state.overwrite);
5272
- },
5273
- hasFocus: function() { return this.display.input.getField() == activeElt(); },
5274
- isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit); },
5275
-
5276
- scrollTo: methodOp(function(x, y) {
5277
- if (x != null || y != null) resolveScrollToPos(this);
5278
- if (x != null) this.curOp.scrollLeft = x;
5279
- if (y != null) this.curOp.scrollTop = y;
5280
- }),
5281
- getScrollInfo: function() {
5282
- var scroller = this.display.scroller;
5283
- return {left: scroller.scrollLeft, top: scroller.scrollTop,
5284
- height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,
5285
- width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,
5286
- clientHeight: displayHeight(this), clientWidth: displayWidth(this)};
5287
- },
5288
-
5289
- scrollIntoView: methodOp(function(range, margin) {
5290
- if (range == null) {
5291
- range = {from: this.doc.sel.primary().head, to: null};
5292
- if (margin == null) margin = this.options.cursorScrollMargin;
5293
- } else if (typeof range == "number") {
5294
- range = {from: Pos(range, 0), to: null};
5295
- } else if (range.from == null) {
5296
- range = {from: range, to: null};
5297
- }
5298
- if (!range.to) range.to = range.from;
5299
- range.margin = margin || 0;
5300
-
5301
- if (range.from.line != null) {
5302
- resolveScrollToPos(this);
5303
- this.curOp.scrollToPos = range;
5304
- } else {
5305
- var sPos = calculateScrollPos(this, Math.min(range.from.left, range.to.left),
5306
- Math.min(range.from.top, range.to.top) - range.margin,
5307
- Math.max(range.from.right, range.to.right),
5308
- Math.max(range.from.bottom, range.to.bottom) + range.margin);
5309
- this.scrollTo(sPos.scrollLeft, sPos.scrollTop);
5310
- }
5311
- }),
5312
-
5313
- setSize: methodOp(function(width, height) {
5314
- var cm = this;
5315
- function interpret(val) {
5316
- return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val;
5317
- }
5318
- if (width != null) cm.display.wrapper.style.width = interpret(width);
5319
- if (height != null) cm.display.wrapper.style.height = interpret(height);
5320
- if (cm.options.lineWrapping) clearLineMeasurementCache(this);
5321
- var lineNo = cm.display.viewFrom;
5322
- cm.doc.iter(lineNo, cm.display.viewTo, function(line) {
5323
- if (line.widgets) for (var i = 0; i < line.widgets.length; i++)
5324
- if (line.widgets[i].noHScroll) { regLineChange(cm, lineNo, "widget"); break; }
5325
- ++lineNo;
5326
- });
5327
- cm.curOp.forceUpdate = true;
5328
- signal(cm, "refresh", this);
5329
- }),
5330
-
5331
- operation: function(f){return runInOp(this, f);},
5332
-
5333
- refresh: methodOp(function() {
5334
- var oldHeight = this.display.cachedTextHeight;
5335
- regChange(this);
5336
- this.curOp.forceUpdate = true;
5337
- clearCaches(this);
5338
- this.scrollTo(this.doc.scrollLeft, this.doc.scrollTop);
5339
- updateGutterSpace(this);
5340
- if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)
5341
- estimateLineHeights(this);
5342
- signal(this, "refresh", this);
5343
- }),
5344
-
5345
- swapDoc: methodOp(function(doc) {
5346
- var old = this.doc;
5347
- old.cm = null;
5348
- attachDoc(this, doc);
5349
- clearCaches(this);
5350
- this.display.input.reset();
5351
- this.scrollTo(doc.scrollLeft, doc.scrollTop);
5352
- this.curOp.forceScroll = true;
5353
- signalLater(this, "swapDoc", this, old);
5354
- return old;
5355
- }),
5356
-
5357
- getInputField: function(){return this.display.input.getField();},
5358
- getWrapperElement: function(){return this.display.wrapper;},
5359
- getScrollerElement: function(){return this.display.scroller;},
5360
- getGutterElement: function(){return this.display.gutters;}
5361
- };
5362
- eventMixin(CodeMirror);
5363
-
5364
- // OPTION DEFAULTS
5365
-
5366
- // The default configuration options.
5367
- var defaults = CodeMirror.defaults = {};
5368
- // Functions to run when options are changed.
5369
- var optionHandlers = CodeMirror.optionHandlers = {};
5370
-
5371
- function option(name, deflt, handle, notOnInit) {
5372
- CodeMirror.defaults[name] = deflt;
5373
- if (handle) optionHandlers[name] =
5374
- notOnInit ? function(cm, val, old) {if (old != Init) handle(cm, val, old);} : handle;
5375
- }
5376
-
5377
- // Passed to option handlers when there is no old value.
5378
- var Init = CodeMirror.Init = {toString: function(){return "CodeMirror.Init";}};
5379
-
5380
- // These two are, on init, called from the constructor because they
5381
- // have to be initialized before the editor can start at all.
5382
- option("value", "", function(cm, val) {
5383
- cm.setValue(val);
5384
- }, true);
5385
- option("mode", null, function(cm, val) {
5386
- cm.doc.modeOption = val;
5387
- loadMode(cm);
5388
- }, true);
5389
-
5390
- option("indentUnit", 2, loadMode, true);
5391
- option("indentWithTabs", false);
5392
- option("smartIndent", true);
5393
- option("tabSize", 4, function(cm) {
5394
- resetModeState(cm);
5395
- clearCaches(cm);
5396
- regChange(cm);
5397
- }, true);
5398
- option("lineSeparator", null, function(cm, val) {
5399
- cm.doc.lineSep = val;
5400
- if (!val) return;
5401
- var newBreaks = [], lineNo = cm.doc.first;
5402
- cm.doc.iter(function(line) {
5403
- for (var pos = 0;;) {
5404
- var found = line.text.indexOf(val, pos);
5405
- if (found == -1) break;
5406
- pos = found + val.length;
5407
- newBreaks.push(Pos(lineNo, found));
5408
- }
5409
- lineNo++;
5410
- });
5411
- for (var i = newBreaks.length - 1; i >= 0; i--)
5412
- replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length))
5413
- });
5414
- option("specialChars", /[\u0000-\u001f\u007f\u00ad\u200b-\u200f\u2028\u2029\ufeff]/g, function(cm, val, old) {
5415
- cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g");
5416
- if (old != CodeMirror.Init) cm.refresh();
5417
- });
5418
- option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function(cm) {cm.refresh();}, true);
5419
- option("electricChars", true);
5420
- option("inputStyle", mobile ? "contenteditable" : "textarea", function() {
5421
- throw new Error("inputStyle can not (yet) be changed in a running editor"); // FIXME
5422
- }, true);
5423
- option("rtlMoveVisually", !windows);
5424
- option("wholeLineUpdateBefore", true);
5425
-
5426
- option("theme", "default", function(cm) {
5427
- themeChanged(cm);
5428
- guttersChanged(cm);
5429
- }, true);
5430
- option("keyMap", "default", function(cm, val, old) {
5431
- var next = getKeyMap(val);
5432
- var prev = old != CodeMirror.Init && getKeyMap(old);
5433
- if (prev && prev.detach) prev.detach(cm, next);
5434
- if (next.attach) next.attach(cm, prev || null);
5435
- });
5436
- option("extraKeys", null);
5437
-
5438
- option("lineWrapping", false, wrappingChanged, true);
5439
- option("gutters", [], function(cm) {
5440
- setGuttersForLineNumbers(cm.options);
5441
- guttersChanged(cm);
5442
- }, true);
5443
- option("fixedGutter", true, function(cm, val) {
5444
- cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0";
5445
- cm.refresh();
5446
- }, true);
5447
- option("coverGutterNextToScrollbar", false, function(cm) {updateScrollbars(cm);}, true);
5448
- option("scrollbarStyle", "native", function(cm) {
5449
- initScrollbars(cm);
5450
- updateScrollbars(cm);
5451
- cm.display.scrollbars.setScrollTop(cm.doc.scrollTop);
5452
- cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft);
5453
- }, true);
5454
- option("lineNumbers", false, function(cm) {
5455
- setGuttersForLineNumbers(cm.options);
5456
- guttersChanged(cm);
5457
- }, true);
5458
- option("firstLineNumber", 1, guttersChanged, true);
5459
- option("lineNumberFormatter", function(integer) {return integer;}, guttersChanged, true);
5460
- option("showCursorWhenSelecting", false, updateSelection, true);
5461
-
5462
- option("resetSelectionOnContextMenu", true);
5463
- option("lineWiseCopyCut", true);
5464
-
5465
- option("readOnly", false, function(cm, val) {
5466
- if (val == "nocursor") {
5467
- onBlur(cm);
5468
- cm.display.input.blur();
5469
- cm.display.disabled = true;
5470
- } else {
5471
- cm.display.disabled = false;
5472
- }
5473
- cm.display.input.readOnlyChanged(val)
5474
- });
5475
- option("disableInput", false, function(cm, val) {if (!val) cm.display.input.reset();}, true);
5476
- option("dragDrop", true, dragDropChanged);
5477
- option("allowDropFileTypes", null);
5478
-
5479
- option("cursorBlinkRate", 530);
5480
- option("cursorScrollMargin", 0);
5481
- option("cursorHeight", 1, updateSelection, true);
5482
- option("singleCursorHeightPerLine", true, updateSelection, true);
5483
- option("workTime", 100);
5484
- option("workDelay", 100);
5485
- option("flattenSpans", true, resetModeState, true);
5486
- option("addModeClass", false, resetModeState, true);
5487
- option("pollInterval", 100);
5488
- option("undoDepth", 200, function(cm, val){cm.doc.history.undoDepth = val;});
5489
- option("historyEventDelay", 1250);
5490
- option("viewportMargin", 10, function(cm){cm.refresh();}, true);
5491
- option("maxHighlightLength", 10000, resetModeState, true);
5492
- option("moveInputWithCursor", true, function(cm, val) {
5493
- if (!val) cm.display.input.resetPosition();
5494
- });
5495
-
5496
- option("tabindex", null, function(cm, val) {
5497
- cm.display.input.getField().tabIndex = val || "";
5498
- });
5499
- option("autofocus", null);
5500
-
5501
- // MODE DEFINITION AND QUERYING
5502
-
5503
- // Known modes, by name and by MIME
5504
- var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {};
5505
-
5506
- // Extra arguments are stored as the mode's dependencies, which is
5507
- // used by (legacy) mechanisms like loadmode.js to automatically
5508
- // load a mode. (Preferred mechanism is the require/define calls.)
5509
- CodeMirror.defineMode = function(name, mode) {
5510
- if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name;
5511
- if (arguments.length > 2)
5512
- mode.dependencies = Array.prototype.slice.call(arguments, 2);
5513
- modes[name] = mode;
5514
- };
5515
-
5516
- CodeMirror.defineMIME = function(mime, spec) {
5517
- mimeModes[mime] = spec;
5518
- };
5519
-
5520
- // Given a MIME type, a {name, ...options} config object, or a name
5521
- // string, return a mode config object.
5522
- CodeMirror.resolveMode = function(spec) {
5523
- if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
5524
- spec = mimeModes[spec];
5525
- } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
5526
- var found = mimeModes[spec.name];
5527
- if (typeof found == "string") found = {name: found};
5528
- spec = createObj(found, spec);
5529
- spec.name = found.name;
5530
- } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
5531
- return CodeMirror.resolveMode("application/xml");
5532
- }
5533
- if (typeof spec == "string") return {name: spec};
5534
- else return spec || {name: "null"};
5535
- };
5536
-
5537
- // Given a mode spec (anything that resolveMode accepts), find and
5538
- // initialize an actual mode object.
5539
- CodeMirror.getMode = function(options, spec) {
5540
- var spec = CodeMirror.resolveMode(spec);
5541
- var mfactory = modes[spec.name];
5542
- if (!mfactory) return CodeMirror.getMode(options, "text/plain");
5543
- var modeObj = mfactory(options, spec);
5544
- if (modeExtensions.hasOwnProperty(spec.name)) {
5545
- var exts = modeExtensions[spec.name];
5546
- for (var prop in exts) {
5547
- if (!exts.hasOwnProperty(prop)) continue;
5548
- if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop];
5549
- modeObj[prop] = exts[prop];
5550
- }
5551
- }
5552
- modeObj.name = spec.name;
5553
- if (spec.helperType) modeObj.helperType = spec.helperType;
5554
- if (spec.modeProps) for (var prop in spec.modeProps)
5555
- modeObj[prop] = spec.modeProps[prop];
5556
-
5557
- return modeObj;
5558
- };
5559
-
5560
- // Minimal default mode.
5561
- CodeMirror.defineMode("null", function() {
5562
- return {token: function(stream) {stream.skipToEnd();}};
5563
- });
5564
- CodeMirror.defineMIME("text/plain", "null");
5565
-
5566
- // This can be used to attach properties to mode objects from
5567
- // outside the actual mode definition.
5568
- var modeExtensions = CodeMirror.modeExtensions = {};
5569
- CodeMirror.extendMode = function(mode, properties) {
5570
- var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});
5571
- copyObj(properties, exts);
5572
- };
5573
-
5574
- // EXTENSIONS
5575
-
5576
- CodeMirror.defineExtension = function(name, func) {
5577
- CodeMirror.prototype[name] = func;
5578
- };
5579
- CodeMirror.defineDocExtension = function(name, func) {
5580
- Doc.prototype[name] = func;
5581
- };
5582
- CodeMirror.defineOption = option;
5583
-
5584
- var initHooks = [];
5585
- CodeMirror.defineInitHook = function(f) {initHooks.push(f);};
5586
-
5587
- var helpers = CodeMirror.helpers = {};
5588
- CodeMirror.registerHelper = function(type, name, value) {
5589
- if (!helpers.hasOwnProperty(type)) helpers[type] = CodeMirror[type] = {_global: []};
5590
- helpers[type][name] = value;
5591
- };
5592
- CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {
5593
- CodeMirror.registerHelper(type, name, value);
5594
- helpers[type]._global.push({pred: predicate, val: value});
5595
- };
5596
-
5597
- // MODE STATE HANDLING
5598
-
5599
- // Utility functions for working with state. Exported because nested
5600
- // modes need to do this for their inner modes.
5601
-
5602
- var copyState = CodeMirror.copyState = function(mode, state) {
5603
- if (state === true) return state;
5604
- if (mode.copyState) return mode.copyState(state);
5605
- var nstate = {};
5606
- for (var n in state) {
5607
- var val = state[n];
5608
- if (val instanceof Array) val = val.concat([]);
5609
- nstate[n] = val;
5610
- }
5611
- return nstate;
5612
- };
5613
-
5614
- var startState = CodeMirror.startState = function(mode, a1, a2) {
5615
- return mode.startState ? mode.startState(a1, a2) : true;
5616
- };
5617
-
5618
- // Given a mode and a state (for that mode), find the inner mode and
5619
- // state at the position that the state refers to.
5620
- CodeMirror.innerMode = function(mode, state) {
5621
- while (mode.innerMode) {
5622
- var info = mode.innerMode(state);
5623
- if (!info || info.mode == mode) break;
5624
- state = info.state;
5625
- mode = info.mode;
5626
- }
5627
- return info || {mode: mode, state: state};
5628
- };
5629
-
5630
- // STANDARD COMMANDS
5631
-
5632
- // Commands are parameter-less actions that can be performed on an
5633
- // editor, mostly used for keybindings.
5634
- var commands = CodeMirror.commands = {
5635
- selectAll: function(cm) {cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll);},
5636
- singleSelection: function(cm) {
5637
- cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll);
5638
- },
5639
- killLine: function(cm) {
5640
- deleteNearSelection(cm, function(range) {
5641
- if (range.empty()) {
5642
- var len = getLine(cm.doc, range.head.line).text.length;
5643
- if (range.head.ch == len && range.head.line < cm.lastLine())
5644
- return {from: range.head, to: Pos(range.head.line + 1, 0)};
5645
- else
5646
- return {from: range.head, to: Pos(range.head.line, len)};
5647
- } else {
5648
- return {from: range.from(), to: range.to()};
5649
- }
5650
- });
5651
- },
5652
- deleteLine: function(cm) {
5653
- deleteNearSelection(cm, function(range) {
5654
- return {from: Pos(range.from().line, 0),
5655
- to: clipPos(cm.doc, Pos(range.to().line + 1, 0))};
5656
- });
5657
- },
5658
- delLineLeft: function(cm) {
5659
- deleteNearSelection(cm, function(range) {
5660
- return {from: Pos(range.from().line, 0), to: range.from()};
5661
- });
5662
- },
5663
- delWrappedLineLeft: function(cm) {
5664
- deleteNearSelection(cm, function(range) {
5665
- var top = cm.charCoords(range.head, "div").top + 5;
5666
- var leftPos = cm.coordsChar({left: 0, top: top}, "div");
5667
- return {from: leftPos, to: range.from()};
5668
- });
5669
- },
5670
- delWrappedLineRight: function(cm) {
5671
- deleteNearSelection(cm, function(range) {
5672
- var top = cm.charCoords(range.head, "div").top + 5;
5673
- var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div");
5674
- return {from: range.from(), to: rightPos };
5675
- });
5676
- },
5677
- undo: function(cm) {cm.undo();},
5678
- redo: function(cm) {cm.redo();},
5679
- undoSelection: function(cm) {cm.undoSelection();},
5680
- redoSelection: function(cm) {cm.redoSelection();},
5681
- goDocStart: function(cm) {cm.extendSelection(Pos(cm.firstLine(), 0));},
5682
- goDocEnd: function(cm) {cm.extendSelection(Pos(cm.lastLine()));},
5683
- goLineStart: function(cm) {
5684
- cm.extendSelectionsBy(function(range) { return lineStart(cm, range.head.line); },
5685
- {origin: "+move", bias: 1});
5686
- },
5687
- goLineStartSmart: function(cm) {
5688
- cm.extendSelectionsBy(function(range) {
5689
- return lineStartSmart(cm, range.head);
5690
- }, {origin: "+move", bias: 1});
5691
- },
5692
- goLineEnd: function(cm) {
5693
- cm.extendSelectionsBy(function(range) { return lineEnd(cm, range.head.line); },
5694
- {origin: "+move", bias: -1});
5695
- },
5696
- goLineRight: function(cm) {
5697
- cm.extendSelectionsBy(function(range) {
5698
- var top = cm.charCoords(range.head, "div").top + 5;
5699
- return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div");
5700
- }, sel_move);
5701
- },
5702
- goLineLeft: function(cm) {
5703
- cm.extendSelectionsBy(function(range) {
5704
- var top = cm.charCoords(range.head, "div").top + 5;
5705
- return cm.coordsChar({left: 0, top: top}, "div");
5706
- }, sel_move);
5707
- },
5708
- goLineLeftSmart: function(cm) {
5709
- cm.extendSelectionsBy(function(range) {
5710
- var top = cm.charCoords(range.head, "div").top + 5;
5711
- var pos = cm.coordsChar({left: 0, top: top}, "div");
5712
- if (pos.ch < cm.getLine(pos.line).search(/\S/)) return lineStartSmart(cm, range.head);
5713
- return pos;
5714
- }, sel_move);
5715
- },
5716
- goLineUp: function(cm) {cm.moveV(-1, "line");},
5717
- goLineDown: function(cm) {cm.moveV(1, "line");},
5718
- goPageUp: function(cm) {cm.moveV(-1, "page");},
5719
- goPageDown: function(cm) {cm.moveV(1, "page");},
5720
- goCharLeft: function(cm) {cm.moveH(-1, "char");},
5721
- goCharRight: function(cm) {cm.moveH(1, "char");},
5722
- goColumnLeft: function(cm) {cm.moveH(-1, "column");},
5723
- goColumnRight: function(cm) {cm.moveH(1, "column");},
5724
- goWordLeft: function(cm) {cm.moveH(-1, "word");},
5725
- goGroupRight: function(cm) {cm.moveH(1, "group");},
5726
- goGroupLeft: function(cm) {cm.moveH(-1, "group");},
5727
- goWordRight: function(cm) {cm.moveH(1, "word");},
5728
- delCharBefore: function(cm) {cm.deleteH(-1, "char");},
5729
- delCharAfter: function(cm) {cm.deleteH(1, "char");},
5730
- delWordBefore: function(cm) {cm.deleteH(-1, "word");},
5731
- delWordAfter: function(cm) {cm.deleteH(1, "word");},
5732
- delGroupBefore: function(cm) {cm.deleteH(-1, "group");},
5733
- delGroupAfter: function(cm) {cm.deleteH(1, "group");},
5734
- indentAuto: function(cm) {cm.indentSelection("smart");},
5735
- indentMore: function(cm) {cm.indentSelection("add");},
5736
- indentLess: function(cm) {cm.indentSelection("subtract");},
5737
- insertTab: function(cm) {cm.replaceSelection("\t");},
5738
- insertSoftTab: function(cm) {
5739
- var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize;
5740
- for (var i = 0; i < ranges.length; i++) {
5741
- var pos = ranges[i].from();
5742
- var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize);
5743
- spaces.push(spaceStr(tabSize - col % tabSize));
5744
- }
5745
- cm.replaceSelections(spaces);
5746
- },
5747
- defaultTab: function(cm) {
5748
- if (cm.somethingSelected()) cm.indentSelection("add");
5749
- else cm.execCommand("insertTab");
5750
- },
5751
- transposeChars: function(cm) {
5752
- runInOp(cm, function() {
5753
- var ranges = cm.listSelections(), newSel = [];
5754
- for (var i = 0; i < ranges.length; i++) {
5755
- var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text;
5756
- if (line) {
5757
- if (cur.ch == line.length) cur = new Pos(cur.line, cur.ch - 1);
5758
- if (cur.ch > 0) {
5759
- cur = new Pos(cur.line, cur.ch + 1);
5760
- cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
5761
- Pos(cur.line, cur.ch - 2), cur, "+transpose");
5762
- } else if (cur.line > cm.doc.first) {
5763
- var prev = getLine(cm.doc, cur.line - 1).text;
5764
- if (prev)
5765
- cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
5766
- prev.charAt(prev.length - 1),
5767
- Pos(cur.line - 1, prev.length - 1), Pos(cur.line, 1), "+transpose");
5768
- }
5769
- }
5770
- newSel.push(new Range(cur, cur));
5771
- }
5772
- cm.setSelections(newSel);
5773
- });
5774
- },
5775
- newlineAndIndent: function(cm) {
5776
- runInOp(cm, function() {
5777
- var len = cm.listSelections().length;
5778
- for (var i = 0; i < len; i++) {
5779
- var range = cm.listSelections()[i];
5780
- cm.replaceRange(cm.doc.lineSeparator(), range.anchor, range.head, "+input");
5781
- cm.indentLine(range.from().line + 1, null, true);
5782
- }
5783
- ensureCursorVisible(cm);
5784
- });
5785
- },
5786
- openLine: function(cm) {cm.replaceSelection("\n", "start")},
5787
- toggleOverwrite: function(cm) {cm.toggleOverwrite();}
5788
- };
5789
-
5790
-
5791
- // STANDARD KEYMAPS
5792
-
5793
- var keyMap = CodeMirror.keyMap = {};
5794
-
5795
- keyMap.basic = {
5796
- "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
5797
- "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
5798
- "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
5799
- "Tab": "defaultTab", "Shift-Tab": "indentAuto",
5800
- "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
5801
- "Esc": "singleSelection"
5802
- };
5803
- // Note that the save and find-related commands aren't defined by
5804
- // default. User code or addons can define them. Unknown commands
5805
- // are simply ignored.
5806
- keyMap.pcDefault = {
5807
- "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
5808
- "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
5809
- "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
5810
- "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
5811
- "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
5812
- "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
5813
- "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
5814
- fallthrough: "basic"
5815
- };
5816
- // Very basic readline/emacs-style bindings, which are standard on Mac.
5817
- keyMap.emacsy = {
5818
- "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
5819
- "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
5820
- "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
5821
- "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars",
5822
- "Ctrl-O": "openLine"
5823
- };
5824
- keyMap.macDefault = {
5825
- "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
5826
- "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
5827
- "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
5828
- "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
5829
- "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
5830
- "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
5831
- "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
5832
- fallthrough: ["basic", "emacsy"]
5833
- };
5834
- keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault;
5835
-
5836
- // KEYMAP DISPATCH
5837
-
5838
- function normalizeKeyName(name) {
5839
- var parts = name.split(/-(?!$)/), name = parts[parts.length - 1];
5840
- var alt, ctrl, shift, cmd;
5841
- for (var i = 0; i < parts.length - 1; i++) {
5842
- var mod = parts[i];
5843
- if (/^(cmd|meta|m)$/i.test(mod)) cmd = true;
5844
- else if (/^a(lt)?$/i.test(mod)) alt = true;
5845
- else if (/^(c|ctrl|control)$/i.test(mod)) ctrl = true;
5846
- else if (/^s(hift)$/i.test(mod)) shift = true;
5847
- else throw new Error("Unrecognized modifier name: " + mod);
5848
- }
5849
- if (alt) name = "Alt-" + name;
5850
- if (ctrl) name = "Ctrl-" + name;
5851
- if (cmd) name = "Cmd-" + name;
5852
- if (shift) name = "Shift-" + name;
5853
- return name;
5854
- }
5855
-
5856
- // This is a kludge to keep keymaps mostly working as raw objects
5857
- // (backwards compatibility) while at the same time support features
5858
- // like normalization and multi-stroke key bindings. It compiles a
5859
- // new normalized keymap, and then updates the old object to reflect
5860
- // this.
5861
- CodeMirror.normalizeKeyMap = function(keymap) {
5862
- var copy = {};
5863
- for (var keyname in keymap) if (keymap.hasOwnProperty(keyname)) {
5864
- var value = keymap[keyname];
5865
- if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) continue;
5866
- if (value == "...") { delete keymap[keyname]; continue; }
5867
-
5868
- var keys = map(keyname.split(" "), normalizeKeyName);
5869
- for (var i = 0; i < keys.length; i++) {
5870
- var val, name;
5871
- if (i == keys.length - 1) {
5872
- name = keys.join(" ");
5873
- val = value;
5874
- } else {
5875
- name = keys.slice(0, i + 1).join(" ");
5876
- val = "...";
5877
- }
5878
- var prev = copy[name];
5879
- if (!prev) copy[name] = val;
5880
- else if (prev != val) throw new Error("Inconsistent bindings for " + name);
5881
- }
5882
- delete keymap[keyname];
5883
- }
5884
- for (var prop in copy) keymap[prop] = copy[prop];
5885
- return keymap;
5886
- };
5887
-
5888
- var lookupKey = CodeMirror.lookupKey = function(key, map, handle, context) {
5889
- map = getKeyMap(map);
5890
- var found = map.call ? map.call(key, context) : map[key];
5891
- if (found === false) return "nothing";
5892
- if (found === "...") return "multi";
5893
- if (found != null && handle(found)) return "handled";
5894
-
5895
- if (map.fallthrough) {
5896
- if (Object.prototype.toString.call(map.fallthrough) != "[object Array]")
5897
- return lookupKey(key, map.fallthrough, handle, context);
5898
- for (var i = 0; i < map.fallthrough.length; i++) {
5899
- var result = lookupKey(key, map.fallthrough[i], handle, context);
5900
- if (result) return result;
5901
- }
5902
- }
5903
- };
5904
-
5905
- // Modifier key presses don't count as 'real' key presses for the
5906
- // purpose of keymap fallthrough.
5907
- var isModifierKey = CodeMirror.isModifierKey = function(value) {
5908
- var name = typeof value == "string" ? value : keyNames[value.keyCode];
5909
- return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod";
5910
- };
5911
-
5912
- // Look up the name of a key as indicated by an event object.
5913
- var keyName = CodeMirror.keyName = function(event, noShift) {
5914
- if (presto && event.keyCode == 34 && event["char"]) return false;
5915
- var base = keyNames[event.keyCode], name = base;
5916
- if (name == null || event.altGraphKey) return false;
5917
- if (event.altKey && base != "Alt") name = "Alt-" + name;
5918
- if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") name = "Ctrl-" + name;
5919
- if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") name = "Cmd-" + name;
5920
- if (!noShift && event.shiftKey && base != "Shift") name = "Shift-" + name;
5921
- return name;
5922
- };
5923
-
5924
- function getKeyMap(val) {
5925
- return typeof val == "string" ? keyMap[val] : val;
5926
- }
5927
-
5928
- // FROMTEXTAREA
5929
-
5930
- CodeMirror.fromTextArea = function(textarea, options) {
5931
- options = options ? copyObj(options) : {};
5932
- options.value = textarea.value;
5933
- if (!options.tabindex && textarea.tabIndex)
5934
- options.tabindex = textarea.tabIndex;
5935
- if (!options.placeholder && textarea.placeholder)
5936
- options.placeholder = textarea.placeholder;
5937
- // Set autofocus to true if this textarea is focused, or if it has
5938
- // autofocus and no other element is focused.
5939
- if (options.autofocus == null) {
5940
- var hasFocus = activeElt();
5941
- options.autofocus = hasFocus == textarea ||
5942
- textarea.getAttribute("autofocus") != null && hasFocus == document.body;
5943
- }
5944
-
5945
- function save() {textarea.value = cm.getValue();}
5946
- if (textarea.form) {
5947
- on(textarea.form, "submit", save);
5948
- // Deplorable hack to make the submit method do the right thing.
5949
- if (!options.leaveSubmitMethodAlone) {
5950
- var form = textarea.form, realSubmit = form.submit;
5951
- try {
5952
- var wrappedSubmit = form.submit = function() {
5953
- save();
5954
- form.submit = realSubmit;
5955
- form.submit();
5956
- form.submit = wrappedSubmit;
5957
- };
5958
- } catch(e) {}
5959
- }
5960
- }
5961
-
5962
- options.finishInit = function(cm) {
5963
- cm.save = save;
5964
- cm.getTextArea = function() { return textarea; };
5965
- cm.toTextArea = function() {
5966
- cm.toTextArea = isNaN; // Prevent this from being ran twice
5967
- save();
5968
- textarea.parentNode.removeChild(cm.getWrapperElement());
5969
- textarea.style.display = "";
5970
- if (textarea.form) {
5971
- off(textarea.form, "submit", save);
5972
- if (typeof textarea.form.submit == "function")
5973
- textarea.form.submit = realSubmit;
5974
- }
5975
- };
5976
- };
5977
-
5978
- textarea.style.display = "none";
5979
- var cm = CodeMirror(function(node) {
5980
- textarea.parentNode.insertBefore(node, textarea.nextSibling);
5981
- }, options);
5982
- return cm;
5983
- };
5984
-
5985
- // STRING STREAM
5986
-
5987
- // Fed to the mode parsers, provides helper functions to make
5988
- // parsers more succinct.
5989
-
5990
- var StringStream = CodeMirror.StringStream = function(string, tabSize) {
5991
- this.pos = this.start = 0;
5992
- this.string = string;
5993
- this.tabSize = tabSize || 8;
5994
- this.lastColumnPos = this.lastColumnValue = 0;
5995
- this.lineStart = 0;
5996
- };
5997
-
5998
- StringStream.prototype = {
5999
- eol: function() {return this.pos >= this.string.length;},
6000
- sol: function() {return this.pos == this.lineStart;},
6001
- peek: function() {return this.string.charAt(this.pos) || undefined;},
6002
- next: function() {
6003
- if (this.pos < this.string.length)
6004
- return this.string.charAt(this.pos++);
6005
- },
6006
- eat: function(match) {
6007
- var ch = this.string.charAt(this.pos);
6008
- if (typeof match == "string") var ok = ch == match;
6009
- else var ok = ch && (match.test ? match.test(ch) : match(ch));
6010
- if (ok) {++this.pos; return ch;}
6011
- },
6012
- eatWhile: function(match) {
6013
- var start = this.pos;
6014
- while (this.eat(match)){}
6015
- return this.pos > start;
6016
- },
6017
- eatSpace: function() {
6018
- var start = this.pos;
6019
- while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
6020
- return this.pos > start;
6021
- },
6022
- skipToEnd: function() {this.pos = this.string.length;},
6023
- skipTo: function(ch) {
6024
- var found = this.string.indexOf(ch, this.pos);
6025
- if (found > -1) {this.pos = found; return true;}
6026
- },
6027
- backUp: function(n) {this.pos -= n;},
6028
- column: function() {
6029
- if (this.lastColumnPos < this.start) {
6030
- this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);
6031
- this.lastColumnPos = this.start;
6032
- }
6033
- return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
6034
- },
6035
- indentation: function() {
6036
- return countColumn(this.string, null, this.tabSize) -
6037
- (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0);
6038
- },
6039
- match: function(pattern, consume, caseInsensitive) {
6040
- if (typeof pattern == "string") {
6041
- var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
6042
- var substr = this.string.substr(this.pos, pattern.length);
6043
- if (cased(substr) == cased(pattern)) {
6044
- if (consume !== false) this.pos += pattern.length;
6045
- return true;
6046
- }
6047
- } else {
6048
- var match = this.string.slice(this.pos).match(pattern);
6049
- if (match && match.index > 0) return null;
6050
- if (match && consume !== false) this.pos += match[0].length;
6051
- return match;
6052
- }
6053
- },
6054
- current: function(){return this.string.slice(this.start, this.pos);},
6055
- hideFirstChars: function(n, inner) {
6056
- this.lineStart += n;
6057
- try { return inner(); }
6058
- finally { this.lineStart -= n; }
6059
- }
6060
- };
6061
-
6062
- // TEXTMARKERS
6063
-
6064
- // Created with markText and setBookmark methods. A TextMarker is a
6065
- // handle that can be used to clear or find a marked position in the
6066
- // document. Line objects hold arrays (markedSpans) containing
6067
- // {from, to, marker} object pointing to such marker objects, and
6068
- // indicating that such a marker is present on that line. Multiple
6069
- // lines may point to the same marker when it spans across lines.
6070
- // The spans will have null for their from/to properties when the
6071
- // marker continues beyond the start/end of the line. Markers have
6072
- // links back to the lines they currently touch.
6073
-
6074
- var nextMarkerId = 0;
6075
-
6076
- var TextMarker = CodeMirror.TextMarker = function(doc, type) {
6077
- this.lines = [];
6078
- this.type = type;
6079
- this.doc = doc;
6080
- this.id = ++nextMarkerId;
6081
- };
6082
- eventMixin(TextMarker);
6083
-
6084
- // Clear the marker.
6085
- TextMarker.prototype.clear = function() {
6086
- if (this.explicitlyCleared) return;
6087
- var cm = this.doc.cm, withOp = cm && !cm.curOp;
6088
- if (withOp) startOperation(cm);
6089
- if (hasHandler(this, "clear")) {
6090
- var found = this.find();
6091
- if (found) signalLater(this, "clear", found.from, found.to);
6092
- }
6093
- var min = null, max = null;
6094
- for (var i = 0; i < this.lines.length; ++i) {
6095
- var line = this.lines[i];
6096
- var span = getMarkedSpanFor(line.markedSpans, this);
6097
- if (cm && !this.collapsed) regLineChange(cm, lineNo(line), "text");
6098
- else if (cm) {
6099
- if (span.to != null) max = lineNo(line);
6100
- if (span.from != null) min = lineNo(line);
6101
- }
6102
- line.markedSpans = removeMarkedSpan(line.markedSpans, span);
6103
- if (span.from == null && this.collapsed && !lineIsHidden(this.doc, line) && cm)
6104
- updateLineHeight(line, textHeight(cm.display));
6105
- }
6106
- if (cm && this.collapsed && !cm.options.lineWrapping) for (var i = 0; i < this.lines.length; ++i) {
6107
- var visual = visualLine(this.lines[i]), len = lineLength(visual);
6108
- if (len > cm.display.maxLineLength) {
6109
- cm.display.maxLine = visual;
6110
- cm.display.maxLineLength = len;
6111
- cm.display.maxLineChanged = true;
6112
- }
6113
- }
6114
-
6115
- if (min != null && cm && this.collapsed) regChange(cm, min, max + 1);
6116
- this.lines.length = 0;
6117
- this.explicitlyCleared = true;
6118
- if (this.atomic && this.doc.cantEdit) {
6119
- this.doc.cantEdit = false;
6120
- if (cm) reCheckSelection(cm.doc);
6121
- }
6122
- if (cm) signalLater(cm, "markerCleared", cm, this);
6123
- if (withOp) endOperation(cm);
6124
- if (this.parent) this.parent.clear();
6125
- };
6126
-
6127
- // Find the position of the marker in the document. Returns a {from,
6128
- // to} object by default. Side can be passed to get a specific side
6129
- // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
6130
- // Pos objects returned contain a line object, rather than a line
6131
- // number (used to prevent looking up the same line twice).
6132
- TextMarker.prototype.find = function(side, lineObj) {
6133
- if (side == null && this.type == "bookmark") side = 1;
6134
- var from, to;
6135
- for (var i = 0; i < this.lines.length; ++i) {
6136
- var line = this.lines[i];
6137
- var span = getMarkedSpanFor(line.markedSpans, this);
6138
- if (span.from != null) {
6139
- from = Pos(lineObj ? line : lineNo(line), span.from);
6140
- if (side == -1) return from;
6141
- }
6142
- if (span.to != null) {
6143
- to = Pos(lineObj ? line : lineNo(line), span.to);
6144
- if (side == 1) return to;
6145
- }
6146
- }
6147
- return from && {from: from, to: to};
6148
- };
6149
-
6150
- // Signals that the marker's widget changed, and surrounding layout
6151
- // should be recomputed.
6152
- TextMarker.prototype.changed = function() {
6153
- var pos = this.find(-1, true), widget = this, cm = this.doc.cm;
6154
- if (!pos || !cm) return;
6155
- runInOp(cm, function() {
6156
- var line = pos.line, lineN = lineNo(pos.line);
6157
- var view = findViewForLine(cm, lineN);
6158
- if (view) {
6159
- clearLineMeasurementCacheFor(view);
6160
- cm.curOp.selectionChanged = cm.curOp.forceUpdate = true;
6161
- }
6162
- cm.curOp.updateMaxLine = true;
6163
- if (!lineIsHidden(widget.doc, line) && widget.height != null) {
6164
- var oldHeight = widget.height;
6165
- widget.height = null;
6166
- var dHeight = widgetHeight(widget) - oldHeight;
6167
- if (dHeight)
6168
- updateLineHeight(line, line.height + dHeight);
6169
- }
6170
- });
6171
- };
6172
-
6173
- TextMarker.prototype.attachLine = function(line) {
6174
- if (!this.lines.length && this.doc.cm) {
6175
- var op = this.doc.cm.curOp;
6176
- if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
6177
- (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this);
6178
- }
6179
- this.lines.push(line);
6180
- };
6181
- TextMarker.prototype.detachLine = function(line) {
6182
- this.lines.splice(indexOf(this.lines, line), 1);
6183
- if (!this.lines.length && this.doc.cm) {
6184
- var op = this.doc.cm.curOp;
6185
- (op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this);
6186
- }
6187
- };
6188
-
6189
- // Collapsed markers have unique ids, in order to be able to order
6190
- // them, which is needed for uniquely determining an outer marker
6191
- // when they overlap (they may nest, but not partially overlap).
6192
- var nextMarkerId = 0;
6193
-
6194
- // Create a marker, wire it up to the right lines, and
6195
- function markText(doc, from, to, options, type) {
6196
- // Shared markers (across linked documents) are handled separately
6197
- // (markTextShared will call out to this again, once per
6198
- // document).
6199
- if (options && options.shared) return markTextShared(doc, from, to, options, type);
6200
- // Ensure we are in an operation.
6201
- if (doc.cm && !doc.cm.curOp) return operation(doc.cm, markText)(doc, from, to, options, type);
6202
-
6203
- var marker = new TextMarker(doc, type), diff = cmp(from, to);
6204
- if (options) copyObj(options, marker, false);
6205
- // Don't connect empty markers unless clearWhenEmpty is false
6206
- if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)
6207
- return marker;
6208
- if (marker.replacedWith) {
6209
- // Showing up as a widget implies collapsed (widget replaces text)
6210
- marker.collapsed = true;
6211
- marker.widgetNode = elt("span", [marker.replacedWith], "CodeMirror-widget");
6212
- if (!options.handleMouseEvents) marker.widgetNode.setAttribute("cm-ignore-events", "true");
6213
- if (options.insertLeft) marker.widgetNode.insertLeft = true;
6214
- }
6215
- if (marker.collapsed) {
6216
- if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||
6217
- from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))
6218
- throw new Error("Inserting collapsed marker partially overlapping an existing one");
6219
- sawCollapsedSpans = true;
6220
- }
6221
-
6222
- if (marker.addToHistory)
6223
- addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN);
6224
-
6225
- var curLine = from.line, cm = doc.cm, updateMaxLine;
6226
- doc.iter(curLine, to.line + 1, function(line) {
6227
- if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)
6228
- updateMaxLine = true;
6229
- if (marker.collapsed && curLine != from.line) updateLineHeight(line, 0);
6230
- addMarkedSpan(line, new MarkedSpan(marker,
6231
- curLine == from.line ? from.ch : null,
6232
- curLine == to.line ? to.ch : null));
6233
- ++curLine;
6234
- });
6235
- // lineIsHidden depends on the presence of the spans, so needs a second pass
6236
- if (marker.collapsed) doc.iter(from.line, to.line + 1, function(line) {
6237
- if (lineIsHidden(doc, line)) updateLineHeight(line, 0);
6238
- });
6239
-
6240
- if (marker.clearOnEnter) on(marker, "beforeCursorEnter", function() { marker.clear(); });
6241
-
6242
- if (marker.readOnly) {
6243
- sawReadOnlySpans = true;
6244
- if (doc.history.done.length || doc.history.undone.length)
6245
- doc.clearHistory();
6246
- }
6247
- if (marker.collapsed) {
6248
- marker.id = ++nextMarkerId;
6249
- marker.atomic = true;
6250
- }
6251
- if (cm) {
6252
- // Sync editor state
6253
- if (updateMaxLine) cm.curOp.updateMaxLine = true;
6254
- if (marker.collapsed)
6255
- regChange(cm, from.line, to.line + 1);
6256
- else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)
6257
- for (var i = from.line; i <= to.line; i++) regLineChange(cm, i, "text");
6258
- if (marker.atomic) reCheckSelection(cm.doc);
6259
- signalLater(cm, "markerAdded", cm, marker);
6260
- }
6261
- return marker;
6262
- }
6263
-
6264
- // SHARED TEXTMARKERS
6265
-
6266
- // A shared marker spans multiple linked documents. It is
6267
- // implemented as a meta-marker-object controlling multiple normal
6268
- // markers.
6269
- var SharedTextMarker = CodeMirror.SharedTextMarker = function(markers, primary) {
6270
- this.markers = markers;
6271
- this.primary = primary;
6272
- for (var i = 0; i < markers.length; ++i)
6273
- markers[i].parent = this;
6274
- };
6275
- eventMixin(SharedTextMarker);
6276
-
6277
- SharedTextMarker.prototype.clear = function() {
6278
- if (this.explicitlyCleared) return;
6279
- this.explicitlyCleared = true;
6280
- for (var i = 0; i < this.markers.length; ++i)
6281
- this.markers[i].clear();
6282
- signalLater(this, "clear");
6283
- };
6284
- SharedTextMarker.prototype.find = function(side, lineObj) {
6285
- return this.primary.find(side, lineObj);
6286
- };
6287
-
6288
- function markTextShared(doc, from, to, options, type) {
6289
- options = copyObj(options);
6290
- options.shared = false;
6291
- var markers = [markText(doc, from, to, options, type)], primary = markers[0];
6292
- var widget = options.widgetNode;
6293
- linkedDocs(doc, function(doc) {
6294
- if (widget) options.widgetNode = widget.cloneNode(true);
6295
- markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type));
6296
- for (var i = 0; i < doc.linked.length; ++i)
6297
- if (doc.linked[i].isParent) return;
6298
- primary = lst(markers);
6299
- });
6300
- return new SharedTextMarker(markers, primary);
6301
- }
6302
-
6303
- function findSharedMarkers(doc) {
6304
- return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())),
6305
- function(m) { return m.parent; });
6306
- }
6307
-
6308
- function copySharedMarkers(doc, markers) {
6309
- for (var i = 0; i < markers.length; i++) {
6310
- var marker = markers[i], pos = marker.find();
6311
- var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to);
6312
- if (cmp(mFrom, mTo)) {
6313
- var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type);
6314
- marker.markers.push(subMark);
6315
- subMark.parent = marker;
6316
- }
6317
- }
6318
- }
6319
-
6320
- function detachSharedMarkers(markers) {
6321
- for (var i = 0; i < markers.length; i++) {
6322
- var marker = markers[i], linked = [marker.primary.doc];;
6323
- linkedDocs(marker.primary.doc, function(d) { linked.push(d); });
6324
- for (var j = 0; j < marker.markers.length; j++) {
6325
- var subMarker = marker.markers[j];
6326
- if (indexOf(linked, subMarker.doc) == -1) {
6327
- subMarker.parent = null;
6328
- marker.markers.splice(j--, 1);
6329
- }
6330
- }
6331
- }
6332
- }
6333
-
6334
- // TEXTMARKER SPANS
6335
-
6336
- function MarkedSpan(marker, from, to) {
6337
- this.marker = marker;
6338
- this.from = from; this.to = to;
6339
- }
6340
-
6341
- // Search an array of spans for a span matching the given marker.
6342
- function getMarkedSpanFor(spans, marker) {
6343
- if (spans) for (var i = 0; i < spans.length; ++i) {
6344
- var span = spans[i];
6345
- if (span.marker == marker) return span;
6346
- }
6347
- }
6348
- // Remove a span from an array, returning undefined if no spans are
6349
- // left (we don't store arrays for lines without spans).
6350
- function removeMarkedSpan(spans, span) {
6351
- for (var r, i = 0; i < spans.length; ++i)
6352
- if (spans[i] != span) (r || (r = [])).push(spans[i]);
6353
- return r;
6354
- }
6355
- // Add a span to a line.
6356
- function addMarkedSpan(line, span) {
6357
- line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span];
6358
- span.marker.attachLine(line);
6359
- }
6360
-
6361
- // Used for the algorithm that adjusts markers for a change in the
6362
- // document. These functions cut an array of spans at a given
6363
- // character position, returning an array of remaining chunks (or
6364
- // undefined if nothing remains).
6365
- function markedSpansBefore(old, startCh, isInsert) {
6366
- if (old) for (var i = 0, nw; i < old.length; ++i) {
6367
- var span = old[i], marker = span.marker;
6368
- var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh);
6369
- if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
6370
- var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh);
6371
- (nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to));
6372
- }
6373
- }
6374
- return nw;
6375
- }
6376
- function markedSpansAfter(old, endCh, isInsert) {
6377
- if (old) for (var i = 0, nw; i < old.length; ++i) {
6378
- var span = old[i], marker = span.marker;
6379
- var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh);
6380
- if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
6381
- var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh);
6382
- (nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
6383
- span.to == null ? null : span.to - endCh));
6384
- }
6385
- }
6386
- return nw;
6387
- }
6388
-
6389
- // Given a change object, compute the new set of marker spans that
6390
- // cover the line in which the change took place. Removes spans
6391
- // entirely within the change, reconnects spans belonging to the
6392
- // same marker that appear on both sides of the change, and cuts off
6393
- // spans partially within the change. Returns an array of span
6394
- // arrays with one element for each line in (after) the change.
6395
- function stretchSpansOverChange(doc, change) {
6396
- if (change.full) return null;
6397
- var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans;
6398
- var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans;
6399
- if (!oldFirst && !oldLast) return null;
6400
-
6401
- var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0;
6402
- // Get the spans that 'stick out' on both sides
6403
- var first = markedSpansBefore(oldFirst, startCh, isInsert);
6404
- var last = markedSpansAfter(oldLast, endCh, isInsert);
6405
-
6406
- // Next, merge those two ends
6407
- var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0);
6408
- if (first) {
6409
- // Fix up .to properties of first
6410
- for (var i = 0; i < first.length; ++i) {
6411
- var span = first[i];
6412
- if (span.to == null) {
6413
- var found = getMarkedSpanFor(last, span.marker);
6414
- if (!found) span.to = startCh;
6415
- else if (sameLine) span.to = found.to == null ? null : found.to + offset;
6416
- }
6417
- }
6418
- }
6419
- if (last) {
6420
- // Fix up .from in last (or move them into first in case of sameLine)
6421
- for (var i = 0; i < last.length; ++i) {
6422
- var span = last[i];
6423
- if (span.to != null) span.to += offset;
6424
- if (span.from == null) {
6425
- var found = getMarkedSpanFor(first, span.marker);
6426
- if (!found) {
6427
- span.from = offset;
6428
- if (sameLine) (first || (first = [])).push(span);
6429
- }
6430
- } else {
6431
- span.from += offset;
6432
- if (sameLine) (first || (first = [])).push(span);
6433
- }
6434
- }
6435
- }
6436
- // Make sure we didn't create any zero-length spans
6437
- if (first) first = clearEmptySpans(first);
6438
- if (last && last != first) last = clearEmptySpans(last);
6439
-
6440
- var newMarkers = [first];
6441
- if (!sameLine) {
6442
- // Fill gap with whole-line-spans
6443
- var gap = change.text.length - 2, gapMarkers;
6444
- if (gap > 0 && first)
6445
- for (var i = 0; i < first.length; ++i)
6446
- if (first[i].to == null)
6447
- (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i].marker, null, null));
6448
- for (var i = 0; i < gap; ++i)
6449
- newMarkers.push(gapMarkers);
6450
- newMarkers.push(last);
6451
- }
6452
- return newMarkers;
6453
- }
6454
-
6455
- // Remove spans that are empty and don't have a clearWhenEmpty
6456
- // option of false.
6457
- function clearEmptySpans(spans) {
6458
- for (var i = 0; i < spans.length; ++i) {
6459
- var span = spans[i];
6460
- if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
6461
- spans.splice(i--, 1);
6462
- }
6463
- if (!spans.length) return null;
6464
- return spans;
6465
- }
6466
-
6467
- // Used for un/re-doing changes from the history. Combines the
6468
- // result of computing the existing spans with the set of spans that
6469
- // existed in the history (so that deleting around a span and then
6470
- // undoing brings back the span).
6471
- function mergeOldSpans(doc, change) {
6472
- var old = getOldSpans(doc, change);
6473
- var stretched = stretchSpansOverChange(doc, change);
6474
- if (!old) return stretched;
6475
- if (!stretched) return old;
6476
-
6477
- for (var i = 0; i < old.length; ++i) {
6478
- var oldCur = old[i], stretchCur = stretched[i];
6479
- if (oldCur && stretchCur) {
6480
- spans: for (var j = 0; j < stretchCur.length; ++j) {
6481
- var span = stretchCur[j];
6482
- for (var k = 0; k < oldCur.length; ++k)
6483
- if (oldCur[k].marker == span.marker) continue spans;
6484
- oldCur.push(span);
6485
- }
6486
- } else if (stretchCur) {
6487
- old[i] = stretchCur;
6488
- }
6489
- }
6490
- return old;
6491
- }
6492
-
6493
- // Used to 'clip' out readOnly ranges when making a change.
6494
- function removeReadOnlyRanges(doc, from, to) {
6495
- var markers = null;
6496
- doc.iter(from.line, to.line + 1, function(line) {
6497
- if (line.markedSpans) for (var i = 0; i < line.markedSpans.length; ++i) {
6498
- var mark = line.markedSpans[i].marker;
6499
- if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
6500
- (markers || (markers = [])).push(mark);
6501
- }
6502
- });
6503
- if (!markers) return null;
6504
- var parts = [{from: from, to: to}];
6505
- for (var i = 0; i < markers.length; ++i) {
6506
- var mk = markers[i], m = mk.find(0);
6507
- for (var j = 0; j < parts.length; ++j) {
6508
- var p = parts[j];
6509
- if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) continue;
6510
- var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to);
6511
- if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
6512
- newParts.push({from: p.from, to: m.from});
6513
- if (dto > 0 || !mk.inclusiveRight && !dto)
6514
- newParts.push({from: m.to, to: p.to});
6515
- parts.splice.apply(parts, newParts);
6516
- j += newParts.length - 1;
6517
- }
6518
- }
6519
- return parts;
6520
- }
6521
-
6522
- // Connect or disconnect spans from a line.
6523
- function detachMarkedSpans(line) {
6524
- var spans = line.markedSpans;
6525
- if (!spans) return;
6526
- for (var i = 0; i < spans.length; ++i)
6527
- spans[i].marker.detachLine(line);
6528
- line.markedSpans = null;
6529
- }
6530
- function attachMarkedSpans(line, spans) {
6531
- if (!spans) return;
6532
- for (var i = 0; i < spans.length; ++i)
6533
- spans[i].marker.attachLine(line);
6534
- line.markedSpans = spans;
6535
- }
6536
-
6537
- // Helpers used when computing which overlapping collapsed span
6538
- // counts as the larger one.
6539
- function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0; }
6540
- function extraRight(marker) { return marker.inclusiveRight ? 1 : 0; }
6541
-
6542
- // Returns a number indicating which of two overlapping collapsed
6543
- // spans is larger (and thus includes the other). Falls back to
6544
- // comparing ids when the spans cover exactly the same range.
6545
- function compareCollapsedMarkers(a, b) {
6546
- var lenDiff = a.lines.length - b.lines.length;
6547
- if (lenDiff != 0) return lenDiff;
6548
- var aPos = a.find(), bPos = b.find();
6549
- var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);
6550
- if (fromCmp) return -fromCmp;
6551
- var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);
6552
- if (toCmp) return toCmp;
6553
- return b.id - a.id;
6554
- }
6555
-
6556
- // Find out whether a line ends or starts in a collapsed span. If
6557
- // so, return the marker for that span.
6558
- function collapsedSpanAtSide(line, start) {
6559
- var sps = sawCollapsedSpans && line.markedSpans, found;
6560
- if (sps) for (var sp, i = 0; i < sps.length; ++i) {
6561
- sp = sps[i];
6562
- if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
6563
- (!found || compareCollapsedMarkers(found, sp.marker) < 0))
6564
- found = sp.marker;
6565
- }
6566
- return found;
6567
- }
6568
- function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true); }
6569
- function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false); }
6570
-
6571
- // Test whether there exists a collapsed span that partially
6572
- // overlaps (covers the start or end, but not both) of a new span.
6573
- // Such overlap is not allowed.
6574
- function conflictingCollapsedRange(doc, lineNo, from, to, marker) {
6575
- var line = getLine(doc, lineNo);
6576
- var sps = sawCollapsedSpans && line.markedSpans;
6577
- if (sps) for (var i = 0; i < sps.length; ++i) {
6578
- var sp = sps[i];
6579
- if (!sp.marker.collapsed) continue;
6580
- var found = sp.marker.find(0);
6581
- var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker);
6582
- var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker);
6583
- if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) continue;
6584
- if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||
6585
- fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))
6586
- return true;
6587
- }
6588
- }
6589
-
6590
- // A visual line is a line as drawn on the screen. Folding, for
6591
- // example, can cause multiple logical lines to appear on the same
6592
- // visual line. This finds the start of the visual line that the
6593
- // given line is part of (usually that is the line itself).
6594
- function visualLine(line) {
6595
- var merged;
6596
- while (merged = collapsedSpanAtStart(line))
6597
- line = merged.find(-1, true).line;
6598
- return line;
6599
- }
6600
-
6601
- // Returns an array of logical lines that continue the visual line
6602
- // started by the argument, or undefined if there are no such lines.
6603
- function visualLineContinued(line) {
6604
- var merged, lines;
6605
- while (merged = collapsedSpanAtEnd(line)) {
6606
- line = merged.find(1, true).line;
6607
- (lines || (lines = [])).push(line);
6608
- }
6609
- return lines;
6610
- }
6611
-
6612
- // Get the line number of the start of the visual line that the
6613
- // given line number is part of.
6614
- function visualLineNo(doc, lineN) {
6615
- var line = getLine(doc, lineN), vis = visualLine(line);
6616
- if (line == vis) return lineN;
6617
- return lineNo(vis);
6618
- }
6619
- // Get the line number of the start of the next visual line after
6620
- // the given line.
6621
- function visualLineEndNo(doc, lineN) {
6622
- if (lineN > doc.lastLine()) return lineN;
6623
- var line = getLine(doc, lineN), merged;
6624
- if (!lineIsHidden(doc, line)) return lineN;
6625
- while (merged = collapsedSpanAtEnd(line))
6626
- line = merged.find(1, true).line;
6627
- return lineNo(line) + 1;
6628
- }
6629
-
6630
- // Compute whether a line is hidden. Lines count as hidden when they
6631
- // are part of a visual line that starts with another line, or when
6632
- // they are entirely covered by collapsed, non-widget span.
6633
- function lineIsHidden(doc, line) {
6634
- var sps = sawCollapsedSpans && line.markedSpans;
6635
- if (sps) for (var sp, i = 0; i < sps.length; ++i) {
6636
- sp = sps[i];
6637
- if (!sp.marker.collapsed) continue;
6638
- if (sp.from == null) return true;
6639
- if (sp.marker.widgetNode) continue;
6640
- if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
6641
- return true;
6642
- }
6643
- }
6644
- function lineIsHiddenInner(doc, line, span) {
6645
- if (span.to == null) {
6646
- var end = span.marker.find(1, true);
6647
- return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker));
6648
- }
6649
- if (span.marker.inclusiveRight && span.to == line.text.length)
6650
- return true;
6651
- for (var sp, i = 0; i < line.markedSpans.length; ++i) {
6652
- sp = line.markedSpans[i];
6653
- if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
6654
- (sp.to == null || sp.to != span.from) &&
6655
- (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
6656
- lineIsHiddenInner(doc, line, sp)) return true;
6657
- }
6658
- }
6659
-
6660
- // LINE WIDGETS
6661
-
6662
- // Line widgets are block elements displayed above or below a line.
6663
-
6664
- var LineWidget = CodeMirror.LineWidget = function(doc, node, options) {
6665
- if (options) for (var opt in options) if (options.hasOwnProperty(opt))
6666
- this[opt] = options[opt];
6667
- this.doc = doc;
6668
- this.node = node;
6669
- };
6670
- eventMixin(LineWidget);
6671
-
6672
- function adjustScrollWhenAboveVisible(cm, line, diff) {
6673
- if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
6674
- addToScrollPos(cm, null, diff);
6675
- }
6676
-
6677
- LineWidget.prototype.clear = function() {
6678
- var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line);
6679
- if (no == null || !ws) return;
6680
- for (var i = 0; i < ws.length; ++i) if (ws[i] == this) ws.splice(i--, 1);
6681
- if (!ws.length) line.widgets = null;
6682
- var height = widgetHeight(this);
6683
- updateLineHeight(line, Math.max(0, line.height - height));
6684
- if (cm) runInOp(cm, function() {
6685
- adjustScrollWhenAboveVisible(cm, line, -height);
6686
- regLineChange(cm, no, "widget");
6687
- });
6688
- };
6689
- LineWidget.prototype.changed = function() {
6690
- var oldH = this.height, cm = this.doc.cm, line = this.line;
6691
- this.height = null;
6692
- var diff = widgetHeight(this) - oldH;
6693
- if (!diff) return;
6694
- updateLineHeight(line, line.height + diff);
6695
- if (cm) runInOp(cm, function() {
6696
- cm.curOp.forceUpdate = true;
6697
- adjustScrollWhenAboveVisible(cm, line, diff);
6698
- });
6699
- };
6700
-
6701
- function widgetHeight(widget) {
6702
- if (widget.height != null) return widget.height;
6703
- var cm = widget.doc.cm;
6704
- if (!cm) return 0;
6705
- if (!contains(document.body, widget.node)) {
6706
- var parentStyle = "position: relative;";
6707
- if (widget.coverGutter)
6708
- parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;";
6709
- if (widget.noHScroll)
6710
- parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;";
6711
- removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle));
6712
- }
6713
- return widget.height = widget.node.parentNode.offsetHeight;
6714
- }
6715
-
6716
- function addLineWidget(doc, handle, node, options) {
6717
- var widget = new LineWidget(doc, node, options);
6718
- var cm = doc.cm;
6719
- if (cm && widget.noHScroll) cm.display.alignWidgets = true;
6720
- changeLine(doc, handle, "widget", function(line) {
6721
- var widgets = line.widgets || (line.widgets = []);
6722
- if (widget.insertAt == null) widgets.push(widget);
6723
- else widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget);
6724
- widget.line = line;
6725
- if (cm && !lineIsHidden(doc, line)) {
6726
- var aboveVisible = heightAtLine(line) < doc.scrollTop;
6727
- updateLineHeight(line, line.height + widgetHeight(widget));
6728
- if (aboveVisible) addToScrollPos(cm, null, widget.height);
6729
- cm.curOp.forceUpdate = true;
6730
- }
6731
- return true;
6732
- });
6733
- return widget;
6734
- }
6735
-
6736
- // LINE DATA STRUCTURE
6737
-
6738
- // Line objects. These hold state related to a line, including
6739
- // highlighting info (the styles array).
6740
- var Line = CodeMirror.Line = function(text, markedSpans, estimateHeight) {
6741
- this.text = text;
6742
- attachMarkedSpans(this, markedSpans);
6743
- this.height = estimateHeight ? estimateHeight(this) : 1;
6744
- };
6745
- eventMixin(Line);
6746
- Line.prototype.lineNo = function() { return lineNo(this); };
6747
-
6748
- // Change the content (text, markers) of a line. Automatically
6749
- // invalidates cached information and tries to re-estimate the
6750
- // line's height.
6751
- function updateLine(line, text, markedSpans, estimateHeight) {
6752
- line.text = text;
6753
- if (line.stateAfter) line.stateAfter = null;
6754
- if (line.styles) line.styles = null;
6755
- if (line.order != null) line.order = null;
6756
- detachMarkedSpans(line);
6757
- attachMarkedSpans(line, markedSpans);
6758
- var estHeight = estimateHeight ? estimateHeight(line) : 1;
6759
- if (estHeight != line.height) updateLineHeight(line, estHeight);
6760
- }
6761
-
6762
- // Detach a line from the document tree and its markers.
6763
- function cleanUpLine(line) {
6764
- line.parent = null;
6765
- detachMarkedSpans(line);
6766
- }
6767
-
6768
- function extractLineClasses(type, output) {
6769
- if (type) for (;;) {
6770
- var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/);
6771
- if (!lineClass) break;
6772
- type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length);
6773
- var prop = lineClass[1] ? "bgClass" : "textClass";
6774
- if (output[prop] == null)
6775
- output[prop] = lineClass[2];
6776
- else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
6777
- output[prop] += " " + lineClass[2];
6778
- }
6779
- return type;
6780
- }
6781
-
6782
- function callBlankLine(mode, state) {
6783
- if (mode.blankLine) return mode.blankLine(state);
6784
- if (!mode.innerMode) return;
6785
- var inner = CodeMirror.innerMode(mode, state);
6786
- if (inner.mode.blankLine) return inner.mode.blankLine(inner.state);
6787
- }
6788
-
6789
- function readToken(mode, stream, state, inner) {
6790
- for (var i = 0; i < 10; i++) {
6791
- if (inner) inner[0] = CodeMirror.innerMode(mode, state).mode;
6792
- var style = mode.token(stream, state);
6793
- if (stream.pos > stream.start) return style;
6794
- }
6795
- throw new Error("Mode " + mode.name + " failed to advance stream.");
6796
- }
6797
-
6798
- // Utility for getTokenAt and getLineTokens
6799
- function takeToken(cm, pos, precise, asArray) {
6800
- function getObj(copy) {
6801
- return {start: stream.start, end: stream.pos,
6802
- string: stream.current(),
6803
- type: style || null,
6804
- state: copy ? copyState(doc.mode, state) : state};
6805
- }
6806
-
6807
- var doc = cm.doc, mode = doc.mode, style;
6808
- pos = clipPos(doc, pos);
6809
- var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise);
6810
- var stream = new StringStream(line.text, cm.options.tabSize), tokens;
6811
- if (asArray) tokens = [];
6812
- while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
6813
- stream.start = stream.pos;
6814
- style = readToken(mode, stream, state);
6815
- if (asArray) tokens.push(getObj(true));
6816
- }
6817
- return asArray ? tokens : getObj();
6818
- }
6819
-
6820
- // Run the given mode's parser over a line, calling f for each token.
6821
- function runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {
6822
- var flattenSpans = mode.flattenSpans;
6823
- if (flattenSpans == null) flattenSpans = cm.options.flattenSpans;
6824
- var curStart = 0, curStyle = null;
6825
- var stream = new StringStream(text, cm.options.tabSize), style;
6826
- var inner = cm.options.addModeClass && [null];
6827
- if (text == "") extractLineClasses(callBlankLine(mode, state), lineClasses);
6828
- while (!stream.eol()) {
6829
- if (stream.pos > cm.options.maxHighlightLength) {
6830
- flattenSpans = false;
6831
- if (forceToEnd) processLine(cm, text, state, stream.pos);
6832
- stream.pos = text.length;
6833
- style = null;
6834
- } else {
6835
- style = extractLineClasses(readToken(mode, stream, state, inner), lineClasses);
6836
- }
6837
- if (inner) {
6838
- var mName = inner[0].name;
6839
- if (mName) style = "m-" + (style ? mName + " " + style : mName);
6840
- }
6841
- if (!flattenSpans || curStyle != style) {
6842
- while (curStart < stream.start) {
6843
- curStart = Math.min(stream.start, curStart + 50000);
6844
- f(curStart, curStyle);
6845
- }
6846
- curStyle = style;
6847
- }
6848
- stream.start = stream.pos;
6849
- }
6850
- while (curStart < stream.pos) {
6851
- // Webkit seems to refuse to render text nodes longer than 57444 characters
6852
- var pos = Math.min(stream.pos, curStart + 50000);
6853
- f(pos, curStyle);
6854
- curStart = pos;
6855
- }
6856
- }
6857
-
6858
- // Compute a style array (an array starting with a mode generation
6859
- // -- for invalidation -- followed by pairs of end positions and
6860
- // style strings), which is used to highlight the tokens on the
6861
- // line.
6862
- function highlightLine(cm, line, state, forceToEnd) {
6863
- // A styles array always starts with a number identifying the
6864
- // mode/overlays that it is based on (for easy invalidation).
6865
- var st = [cm.state.modeGen], lineClasses = {};
6866
- // Compute the base array of styles
6867
- runMode(cm, line.text, cm.doc.mode, state, function(end, style) {
6868
- st.push(end, style);
6869
- }, lineClasses, forceToEnd);
6870
-
6871
- // Run overlays, adjust style array.
6872
- for (var o = 0; o < cm.state.overlays.length; ++o) {
6873
- var overlay = cm.state.overlays[o], i = 1, at = 0;
6874
- runMode(cm, line.text, overlay.mode, true, function(end, style) {
6875
- var start = i;
6876
- // Ensure there's a token end at the current position, and that i points at it
6877
- while (at < end) {
6878
- var i_end = st[i];
6879
- if (i_end > end)
6880
- st.splice(i, 1, end, st[i+1], i_end);
6881
- i += 2;
6882
- at = Math.min(end, i_end);
6883
- }
6884
- if (!style) return;
6885
- if (overlay.opaque) {
6886
- st.splice(start, i - start, end, "cm-overlay " + style);
6887
- i = start + 2;
6888
- } else {
6889
- for (; start < i; start += 2) {
6890
- var cur = st[start+1];
6891
- st[start+1] = (cur ? cur + " " : "") + "cm-overlay " + style;
6892
- }
6893
- }
6894
- }, lineClasses);
6895
- }
6896
-
6897
- return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null};
6898
- }
6899
-
6900
- function getLineStyles(cm, line, updateFrontier) {
6901
- if (!line.styles || line.styles[0] != cm.state.modeGen) {
6902
- var state = getStateBefore(cm, lineNo(line));
6903
- var result = highlightLine(cm, line, line.text.length > cm.options.maxHighlightLength ? copyState(cm.doc.mode, state) : state);
6904
- line.stateAfter = state;
6905
- line.styles = result.styles;
6906
- if (result.classes) line.styleClasses = result.classes;
6907
- else if (line.styleClasses) line.styleClasses = null;
6908
- if (updateFrontier === cm.doc.frontier) cm.doc.frontier++;
6909
- }
6910
- return line.styles;
6911
- }
6912
-
6913
- // Lightweight form of highlight -- proceed over this line and
6914
- // update state, but don't save a style array. Used for lines that
6915
- // aren't currently visible.
6916
- function processLine(cm, text, state, startAt) {
6917
- var mode = cm.doc.mode;
6918
- var stream = new StringStream(text, cm.options.tabSize);
6919
- stream.start = stream.pos = startAt || 0;
6920
- if (text == "") callBlankLine(mode, state);
6921
- while (!stream.eol()) {
6922
- readToken(mode, stream, state);
6923
- stream.start = stream.pos;
6924
- }
6925
- }
6926
-
6927
- // Convert a style as returned by a mode (either null, or a string
6928
- // containing one or more styles) to a CSS style. This is cached,
6929
- // and also looks for line-wide styles.
6930
- var styleToClassCache = {}, styleToClassCacheWithMode = {};
6931
- function interpretTokenStyle(style, options) {
6932
- if (!style || /^\s*$/.test(style)) return null;
6933
- var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache;
6934
- return cache[style] ||
6935
- (cache[style] = style.replace(/\S+/g, "cm-$&"));
6936
- }
6937
-
6938
- // Render the DOM representation of the text of a line. Also builds
6939
- // up a 'line map', which points at the DOM nodes that represent
6940
- // specific stretches of text, and is used by the measuring code.
6941
- // The returned object contains the DOM node, this map, and
6942
- // information about line-wide styles that were set by the mode.
6943
- function buildLineContent(cm, lineView) {
6944
- // The padding-right forces the element to have a 'border', which
6945
- // is needed on Webkit to be able to get line-level bounding
6946
- // rectangles for it (in measureChar).
6947
- var content = elt("span", null, null, webkit ? "padding-right: .1px" : null);
6948
- var builder = {pre: elt("pre", [content], "CodeMirror-line"), content: content,
6949
- col: 0, pos: 0, cm: cm,
6950
- trailingSpace: false,
6951
- splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")};
6952
- lineView.measure = {};
6953
-
6954
- // Iterate over the logical lines that make up this visual line.
6955
- for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
6956
- var line = i ? lineView.rest[i - 1] : lineView.line, order;
6957
- builder.pos = 0;
6958
- builder.addToken = buildToken;
6959
- // Optionally wire in some hacks into the token-rendering
6960
- // algorithm, to deal with browser quirks.
6961
- if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))
6962
- builder.addToken = buildTokenBadBidi(builder.addToken, order);
6963
- builder.map = [];
6964
- var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);
6965
- insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));
6966
- if (line.styleClasses) {
6967
- if (line.styleClasses.bgClass)
6968
- builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "");
6969
- if (line.styleClasses.textClass)
6970
- builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "");
6971
- }
6972
-
6973
- // Ensure at least a single node is present, for measuring.
6974
- if (builder.map.length == 0)
6975
- builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure)));
6976
-
6977
- // Store the map and a cache object for the current logical line
6978
- if (i == 0) {
6979
- lineView.measure.map = builder.map;
6980
- lineView.measure.cache = {};
6981
- } else {
6982
- (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map);
6983
- (lineView.measure.caches || (lineView.measure.caches = [])).push({});
6984
- }
6985
- }
6986
-
6987
- // See issue #2901
6988
- if (webkit) {
6989
- var last = builder.content.lastChild
6990
- if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab")))
6991
- builder.content.className = "cm-tab-wrap-hack";
6992
- }
6993
-
6994
- signal(cm, "renderLine", cm, lineView.line, builder.pre);
6995
- if (builder.pre.className)
6996
- builder.textClass = joinClasses(builder.pre.className, builder.textClass || "");
6997
-
6998
- return builder;
6999
- }
7000
-
7001
- function defaultSpecialCharPlaceholder(ch) {
7002
- var token = elt("span", "\u2022", "cm-invalidchar");
7003
- token.title = "\\u" + ch.charCodeAt(0).toString(16);
7004
- token.setAttribute("aria-label", token.title);
7005
- return token;
7006
- }
7007
-
7008
- // Build up the DOM representation for a single token, and add it to
7009
- // the line map. Takes care to render special characters separately.
7010
- function buildToken(builder, text, style, startStyle, endStyle, title, css) {
7011
- if (!text) return;
7012
- var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text
7013
- var special = builder.cm.state.specialChars, mustWrap = false;
7014
- if (!special.test(text)) {
7015
- builder.col += text.length;
7016
- var content = document.createTextNode(displayText);
7017
- builder.map.push(builder.pos, builder.pos + text.length, content);
7018
- if (ie && ie_version < 9) mustWrap = true;
7019
- builder.pos += text.length;
7020
- } else {
7021
- var content = document.createDocumentFragment(), pos = 0;
7022
- while (true) {
7023
- special.lastIndex = pos;
7024
- var m = special.exec(text);
7025
- var skipped = m ? m.index - pos : text.length - pos;
7026
- if (skipped) {
7027
- var txt = document.createTextNode(displayText.slice(pos, pos + skipped));
7028
- if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
7029
- else content.appendChild(txt);
7030
- builder.map.push(builder.pos, builder.pos + skipped, txt);
7031
- builder.col += skipped;
7032
- builder.pos += skipped;
7033
- }
7034
- if (!m) break;
7035
- pos += skipped + 1;
7036
- if (m[0] == "\t") {
7037
- var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize;
7038
- var txt = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"));
7039
- txt.setAttribute("role", "presentation");
7040
- txt.setAttribute("cm-text", "\t");
7041
- builder.col += tabWidth;
7042
- } else if (m[0] == "\r" || m[0] == "\n") {
7043
- var txt = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar"));
7044
- txt.setAttribute("cm-text", m[0]);
7045
- builder.col += 1;
7046
- } else {
7047
- var txt = builder.cm.options.specialCharPlaceholder(m[0]);
7048
- txt.setAttribute("cm-text", m[0]);
7049
- if (ie && ie_version < 9) content.appendChild(elt("span", [txt]));
7050
- else content.appendChild(txt);
7051
- builder.col += 1;
7052
- }
7053
- builder.map.push(builder.pos, builder.pos + 1, txt);
7054
- builder.pos++;
7055
- }
7056
- }
7057
- builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32
7058
- if (style || startStyle || endStyle || mustWrap || css) {
7059
- var fullStyle = style || "";
7060
- if (startStyle) fullStyle += startStyle;
7061
- if (endStyle) fullStyle += endStyle;
7062
- var token = elt("span", [content], fullStyle, css);
7063
- if (title) token.title = title;
7064
- return builder.content.appendChild(token);
7065
- }
7066
- builder.content.appendChild(content);
7067
- }
7068
-
7069
- function splitSpaces(text, trailingBefore) {
7070
- if (text.length > 1 && !/ /.test(text)) return text
7071
- var spaceBefore = trailingBefore, result = ""
7072
- for (var i = 0; i < text.length; i++) {
7073
- var ch = text.charAt(i)
7074
- if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))
7075
- ch = "\u00a0"
7076
- result += ch
7077
- spaceBefore = ch == " "
7078
- }
7079
- return result
7080
- }
7081
-
7082
- // Work around nonsense dimensions being reported for stretches of
7083
- // right-to-left text.
7084
- function buildTokenBadBidi(inner, order) {
7085
- return function(builder, text, style, startStyle, endStyle, title, css) {
7086
- style = style ? style + " cm-force-border" : "cm-force-border";
7087
- var start = builder.pos, end = start + text.length;
7088
- for (;;) {
7089
- // Find the part that overlaps with the start of this text
7090
- for (var i = 0; i < order.length; i++) {
7091
- var part = order[i];
7092
- if (part.to > start && part.from <= start) break;
7093
- }
7094
- if (part.to >= end) return inner(builder, text, style, startStyle, endStyle, title, css);
7095
- inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css);
7096
- startStyle = null;
7097
- text = text.slice(part.to - start);
7098
- start = part.to;
7099
- }
7100
- };
7101
- }
7102
-
7103
- function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
7104
- var widget = !ignoreWidget && marker.widgetNode;
7105
- if (widget) builder.map.push(builder.pos, builder.pos + size, widget);
7106
- if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
7107
- if (!widget)
7108
- widget = builder.content.appendChild(document.createElement("span"));
7109
- widget.setAttribute("cm-marker", marker.id);
7110
- }
7111
- if (widget) {
7112
- builder.cm.display.input.setUneditable(widget);
7113
- builder.content.appendChild(widget);
7114
- }
7115
- builder.pos += size;
7116
- builder.trailingSpace = false
7117
- }
7118
-
7119
- // Outputs a number of spans to make up a line, taking highlighting
7120
- // and marked text into account.
7121
- function insertLineContent(line, builder, styles) {
7122
- var spans = line.markedSpans, allText = line.text, at = 0;
7123
- if (!spans) {
7124
- for (var i = 1; i < styles.length; i+=2)
7125
- builder.addToken(builder, allText.slice(at, at = styles[i]), interpretTokenStyle(styles[i+1], builder.cm.options));
7126
- return;
7127
- }
7128
-
7129
- var len = allText.length, pos = 0, i = 1, text = "", style, css;
7130
- var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed;
7131
- for (;;) {
7132
- if (nextChange == pos) { // Update current marker set
7133
- spanStyle = spanEndStyle = spanStartStyle = title = css = "";
7134
- collapsed = null; nextChange = Infinity;
7135
- var foundBookmarks = [], endStyles
7136
- for (var j = 0; j < spans.length; ++j) {
7137
- var sp = spans[j], m = sp.marker;
7138
- if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
7139
- foundBookmarks.push(m);
7140
- } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {
7141
- if (sp.to != null && sp.to != pos && nextChange > sp.to) {
7142
- nextChange = sp.to;
7143
- spanEndStyle = "";
7144
- }
7145
- if (m.className) spanStyle += " " + m.className;
7146
- if (m.css) css = (css ? css + ";" : "") + m.css;
7147
- if (m.startStyle && sp.from == pos) spanStartStyle += " " + m.startStyle;
7148
- if (m.endStyle && sp.to == nextChange) (endStyles || (endStyles = [])).push(m.endStyle, sp.to)
7149
- if (m.title && !title) title = m.title;
7150
- if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
7151
- collapsed = sp;
7152
- } else if (sp.from > pos && nextChange > sp.from) {
7153
- nextChange = sp.from;
7154
- }
7155
- }
7156
- if (endStyles) for (var j = 0; j < endStyles.length; j += 2)
7157
- if (endStyles[j + 1] == nextChange) spanEndStyle += " " + endStyles[j]
7158
-
7159
- if (!collapsed || collapsed.from == pos) for (var j = 0; j < foundBookmarks.length; ++j)
7160
- buildCollapsedSpan(builder, 0, foundBookmarks[j]);
7161
- if (collapsed && (collapsed.from || 0) == pos) {
7162
- buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
7163
- collapsed.marker, collapsed.from == null);
7164
- if (collapsed.to == null) return;
7165
- if (collapsed.to == pos) collapsed = false;
7166
- }
7167
- }
7168
- if (pos >= len) break;
7169
-
7170
- var upto = Math.min(len, nextChange);
7171
- while (true) {
7172
- if (text) {
7173
- var end = pos + text.length;
7174
- if (!collapsed) {
7175
- var tokenText = end > upto ? text.slice(0, upto - pos) : text;
7176
- builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
7177
- spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css);
7178
- }
7179
- if (end >= upto) {text = text.slice(upto - pos); pos = upto; break;}
7180
- pos = end;
7181
- spanStartStyle = "";
7182
- }
7183
- text = allText.slice(at, at = styles[i++]);
7184
- style = interpretTokenStyle(styles[i++], builder.cm.options);
7185
- }
7186
- }
7187
- }
7188
-
7189
- // DOCUMENT DATA STRUCTURE
7190
-
7191
- // By default, updates that start and end at the beginning of a line
7192
- // are treated specially, in order to make the association of line
7193
- // widgets and marker elements with the text behave more intuitive.
7194
- function isWholeLineUpdate(doc, change) {
7195
- return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
7196
- (!doc.cm || doc.cm.options.wholeLineUpdateBefore);
7197
- }
7198
-
7199
- // Perform a change on the document data structure.
7200
- function updateDoc(doc, change, markedSpans, estimateHeight) {
7201
- function spansFor(n) {return markedSpans ? markedSpans[n] : null;}
7202
- function update(line, text, spans) {
7203
- updateLine(line, text, spans, estimateHeight);
7204
- signalLater(line, "change", line, change);
7205
- }
7206
- function linesFor(start, end) {
7207
- for (var i = start, result = []; i < end; ++i)
7208
- result.push(new Line(text[i], spansFor(i), estimateHeight));
7209
- return result;
7210
- }
7211
-
7212
- var from = change.from, to = change.to, text = change.text;
7213
- var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line);
7214
- var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line;
7215
-
7216
- // Adjust the line structure
7217
- if (change.full) {
7218
- doc.insert(0, linesFor(0, text.length));
7219
- doc.remove(text.length, doc.size - text.length);
7220
- } else if (isWholeLineUpdate(doc, change)) {
7221
- // This is a whole-line replace. Treated specially to make
7222
- // sure line objects move the way they are supposed to.
7223
- var added = linesFor(0, text.length - 1);
7224
- update(lastLine, lastLine.text, lastSpans);
7225
- if (nlines) doc.remove(from.line, nlines);
7226
- if (added.length) doc.insert(from.line, added);
7227
- } else if (firstLine == lastLine) {
7228
- if (text.length == 1) {
7229
- update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans);
7230
- } else {
7231
- var added = linesFor(1, text.length - 1);
7232
- added.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight));
7233
- update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
7234
- doc.insert(from.line + 1, added);
7235
- }
7236
- } else if (text.length == 1) {
7237
- update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0));
7238
- doc.remove(from.line + 1, nlines);
7239
- } else {
7240
- update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
7241
- update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans);
7242
- var added = linesFor(1, text.length - 1);
7243
- if (nlines > 1) doc.remove(from.line + 1, nlines - 1);
7244
- doc.insert(from.line + 1, added);
7245
- }
7246
-
7247
- signalLater(doc, "change", doc, change);
7248
- }
7249
-
7250
- // The document is represented as a BTree consisting of leaves, with
7251
- // chunk of lines in them, and branches, with up to ten leaves or
7252
- // other branch nodes below them. The top node is always a branch
7253
- // node, and is the document object itself (meaning it has
7254
- // additional methods and properties).
7255
- //
7256
- // All nodes have parent links. The tree is used both to go from
7257
- // line numbers to line objects, and to go from objects to numbers.
7258
- // It also indexes by height, and is used to convert between height
7259
- // and line object, and to find the total height of the document.
7260
- //
7261
- // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
7262
-
7263
- function LeafChunk(lines) {
7264
- this.lines = lines;
7265
- this.parent = null;
7266
- for (var i = 0, height = 0; i < lines.length; ++i) {
7267
- lines[i].parent = this;
7268
- height += lines[i].height;
7269
- }
7270
- this.height = height;
7271
- }
7272
-
7273
- LeafChunk.prototype = {
7274
- chunkSize: function() { return this.lines.length; },
7275
- // Remove the n lines at offset 'at'.
7276
- removeInner: function(at, n) {
7277
- for (var i = at, e = at + n; i < e; ++i) {
7278
- var line = this.lines[i];
7279
- this.height -= line.height;
7280
- cleanUpLine(line);
7281
- signalLater(line, "delete");
7282
- }
7283
- this.lines.splice(at, n);
7284
- },
7285
- // Helper used to collapse a small branch into a single leaf.
7286
- collapse: function(lines) {
7287
- lines.push.apply(lines, this.lines);
7288
- },
7289
- // Insert the given array of lines at offset 'at', count them as
7290
- // having the given height.
7291
- insertInner: function(at, lines, height) {
7292
- this.height += height;
7293
- this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at));
7294
- for (var i = 0; i < lines.length; ++i) lines[i].parent = this;
7295
- },
7296
- // Used to iterate over a part of the tree.
7297
- iterN: function(at, n, op) {
7298
- for (var e = at + n; at < e; ++at)
7299
- if (op(this.lines[at])) return true;
7300
- }
7301
- };
7302
-
7303
- function BranchChunk(children) {
7304
- this.children = children;
7305
- var size = 0, height = 0;
7306
- for (var i = 0; i < children.length; ++i) {
7307
- var ch = children[i];
7308
- size += ch.chunkSize(); height += ch.height;
7309
- ch.parent = this;
7310
- }
7311
- this.size = size;
7312
- this.height = height;
7313
- this.parent = null;
7314
- }
7315
-
7316
- BranchChunk.prototype = {
7317
- chunkSize: function() { return this.size; },
7318
- removeInner: function(at, n) {
7319
- this.size -= n;
7320
- for (var i = 0; i < this.children.length; ++i) {
7321
- var child = this.children[i], sz = child.chunkSize();
7322
- if (at < sz) {
7323
- var rm = Math.min(n, sz - at), oldHeight = child.height;
7324
- child.removeInner(at, rm);
7325
- this.height -= oldHeight - child.height;
7326
- if (sz == rm) { this.children.splice(i--, 1); child.parent = null; }
7327
- if ((n -= rm) == 0) break;
7328
- at = 0;
7329
- } else at -= sz;
7330
- }
7331
- // If the result is smaller than 25 lines, ensure that it is a
7332
- // single leaf node.
7333
- if (this.size - n < 25 &&
7334
- (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
7335
- var lines = [];
7336
- this.collapse(lines);
7337
- this.children = [new LeafChunk(lines)];
7338
- this.children[0].parent = this;
7339
- }
7340
- },
7341
- collapse: function(lines) {
7342
- for (var i = 0; i < this.children.length; ++i) this.children[i].collapse(lines);
7343
- },
7344
- insertInner: function(at, lines, height) {
7345
- this.size += lines.length;
7346
- this.height += height;
7347
- for (var i = 0; i < this.children.length; ++i) {
7348
- var child = this.children[i], sz = child.chunkSize();
7349
- if (at <= sz) {
7350
- child.insertInner(at, lines, height);
7351
- if (child.lines && child.lines.length > 50) {
7352
- // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.
7353
- // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.
7354
- var remaining = child.lines.length % 25 + 25
7355
- for (var pos = remaining; pos < child.lines.length;) {
7356
- var leaf = new LeafChunk(child.lines.slice(pos, pos += 25));
7357
- child.height -= leaf.height;
7358
- this.children.splice(++i, 0, leaf);
7359
- leaf.parent = this;
7360
- }
7361
- child.lines = child.lines.slice(0, remaining);
7362
- this.maybeSpill();
7363
- }
7364
- break;
7365
- }
7366
- at -= sz;
7367
- }
7368
- },
7369
- // When a node has grown, check whether it should be split.
7370
- maybeSpill: function() {
7371
- if (this.children.length <= 10) return;
7372
- var me = this;
7373
- do {
7374
- var spilled = me.children.splice(me.children.length - 5, 5);
7375
- var sibling = new BranchChunk(spilled);
7376
- if (!me.parent) { // Become the parent node
7377
- var copy = new BranchChunk(me.children);
7378
- copy.parent = me;
7379
- me.children = [copy, sibling];
7380
- me = copy;
7381
- } else {
7382
- me.size -= sibling.size;
7383
- me.height -= sibling.height;
7384
- var myIndex = indexOf(me.parent.children, me);
7385
- me.parent.children.splice(myIndex + 1, 0, sibling);
7386
- }
7387
- sibling.parent = me.parent;
7388
- } while (me.children.length > 10);
7389
- me.parent.maybeSpill();
7390
- },
7391
- iterN: function(at, n, op) {
7392
- for (var i = 0; i < this.children.length; ++i) {
7393
- var child = this.children[i], sz = child.chunkSize();
7394
- if (at < sz) {
7395
- var used = Math.min(n, sz - at);
7396
- if (child.iterN(at, used, op)) return true;
7397
- if ((n -= used) == 0) break;
7398
- at = 0;
7399
- } else at -= sz;
7400
- }
7401
- }
7402
- };
7403
-
7404
- var nextDocId = 0;
7405
- var Doc = CodeMirror.Doc = function(text, mode, firstLine, lineSep) {
7406
- if (!(this instanceof Doc)) return new Doc(text, mode, firstLine, lineSep);
7407
- if (firstLine == null) firstLine = 0;
7408
-
7409
- BranchChunk.call(this, [new LeafChunk([new Line("", null)])]);
7410
- this.first = firstLine;
7411
- this.scrollTop = this.scrollLeft = 0;
7412
- this.cantEdit = false;
7413
- this.cleanGeneration = 1;
7414
- this.frontier = firstLine;
7415
- var start = Pos(firstLine, 0);
7416
- this.sel = simpleSelection(start);
7417
- this.history = new History(null);
7418
- this.id = ++nextDocId;
7419
- this.modeOption = mode;
7420
- this.lineSep = lineSep;
7421
- this.extend = false;
7422
-
7423
- if (typeof text == "string") text = this.splitLines(text);
7424
- updateDoc(this, {from: start, to: start, text: text});
7425
- setSelection(this, simpleSelection(start), sel_dontScroll);
7426
- };
7427
-
7428
- Doc.prototype = createObj(BranchChunk.prototype, {
7429
- constructor: Doc,
7430
- // Iterate over the document. Supports two forms -- with only one
7431
- // argument, it calls that for each line in the document. With
7432
- // three, it iterates over the range given by the first two (with
7433
- // the second being non-inclusive).
7434
- iter: function(from, to, op) {
7435
- if (op) this.iterN(from - this.first, to - from, op);
7436
- else this.iterN(this.first, this.first + this.size, from);
7437
- },
7438
-
7439
- // Non-public interface for adding and removing lines.
7440
- insert: function(at, lines) {
7441
- var height = 0;
7442
- for (var i = 0; i < lines.length; ++i) height += lines[i].height;
7443
- this.insertInner(at - this.first, lines, height);
7444
- },
7445
- remove: function(at, n) { this.removeInner(at - this.first, n); },
7446
-
7447
- // From here, the methods are part of the public interface. Most
7448
- // are also available from CodeMirror (editor) instances.
7449
-
7450
- getValue: function(lineSep) {
7451
- var lines = getLines(this, this.first, this.first + this.size);
7452
- if (lineSep === false) return lines;
7453
- return lines.join(lineSep || this.lineSeparator());
7454
- },
7455
- setValue: docMethodOp(function(code) {
7456
- var top = Pos(this.first, 0), last = this.first + this.size - 1;
7457
- makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
7458
- text: this.splitLines(code), origin: "setValue", full: true}, true);
7459
- setSelection(this, simpleSelection(top));
7460
- }),
7461
- replaceRange: function(code, from, to, origin) {
7462
- from = clipPos(this, from);
7463
- to = to ? clipPos(this, to) : from;
7464
- replaceRange(this, code, from, to, origin);
7465
- },
7466
- getRange: function(from, to, lineSep) {
7467
- var lines = getBetween(this, clipPos(this, from), clipPos(this, to));
7468
- if (lineSep === false) return lines;
7469
- return lines.join(lineSep || this.lineSeparator());
7470
- },
7471
-
7472
- getLine: function(line) {var l = this.getLineHandle(line); return l && l.text;},
7473
-
7474
- getLineHandle: function(line) {if (isLine(this, line)) return getLine(this, line);},
7475
- getLineNumber: function(line) {return lineNo(line);},
7476
-
7477
- getLineHandleVisualStart: function(line) {
7478
- if (typeof line == "number") line = getLine(this, line);
7479
- return visualLine(line);
7480
- },
7481
-
7482
- lineCount: function() {return this.size;},
7483
- firstLine: function() {return this.first;},
7484
- lastLine: function() {return this.first + this.size - 1;},
7485
-
7486
- clipPos: function(pos) {return clipPos(this, pos);},
7487
-
7488
- getCursor: function(start) {
7489
- var range = this.sel.primary(), pos;
7490
- if (start == null || start == "head") pos = range.head;
7491
- else if (start == "anchor") pos = range.anchor;
7492
- else if (start == "end" || start == "to" || start === false) pos = range.to();
7493
- else pos = range.from();
7494
- return pos;
7495
- },
7496
- listSelections: function() { return this.sel.ranges; },
7497
- somethingSelected: function() {return this.sel.somethingSelected();},
7498
-
7499
- setCursor: docMethodOp(function(line, ch, options) {
7500
- setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options);
7501
- }),
7502
- setSelection: docMethodOp(function(anchor, head, options) {
7503
- setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options);
7504
- }),
7505
- extendSelection: docMethodOp(function(head, other, options) {
7506
- extendSelection(this, clipPos(this, head), other && clipPos(this, other), options);
7507
- }),
7508
- extendSelections: docMethodOp(function(heads, options) {
7509
- extendSelections(this, clipPosArray(this, heads), options);
7510
- }),
7511
- extendSelectionsBy: docMethodOp(function(f, options) {
7512
- var heads = map(this.sel.ranges, f);
7513
- extendSelections(this, clipPosArray(this, heads), options);
7514
- }),
7515
- setSelections: docMethodOp(function(ranges, primary, options) {
7516
- if (!ranges.length) return;
7517
- for (var i = 0, out = []; i < ranges.length; i++)
7518
- out[i] = new Range(clipPos(this, ranges[i].anchor),
7519
- clipPos(this, ranges[i].head));
7520
- if (primary == null) primary = Math.min(ranges.length - 1, this.sel.primIndex);
7521
- setSelection(this, normalizeSelection(out, primary), options);
7522
- }),
7523
- addSelection: docMethodOp(function(anchor, head, options) {
7524
- var ranges = this.sel.ranges.slice(0);
7525
- ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)));
7526
- setSelection(this, normalizeSelection(ranges, ranges.length - 1), options);
7527
- }),
7528
-
7529
- getSelection: function(lineSep) {
7530
- var ranges = this.sel.ranges, lines;
7531
- for (var i = 0; i < ranges.length; i++) {
7532
- var sel = getBetween(this, ranges[i].from(), ranges[i].to());
7533
- lines = lines ? lines.concat(sel) : sel;
7534
- }
7535
- if (lineSep === false) return lines;
7536
- else return lines.join(lineSep || this.lineSeparator());
7537
- },
7538
- getSelections: function(lineSep) {
7539
- var parts = [], ranges = this.sel.ranges;
7540
- for (var i = 0; i < ranges.length; i++) {
7541
- var sel = getBetween(this, ranges[i].from(), ranges[i].to());
7542
- if (lineSep !== false) sel = sel.join(lineSep || this.lineSeparator());
7543
- parts[i] = sel;
7544
- }
7545
- return parts;
7546
- },
7547
- replaceSelection: function(code, collapse, origin) {
7548
- var dup = [];
7549
- for (var i = 0; i < this.sel.ranges.length; i++)
7550
- dup[i] = code;
7551
- this.replaceSelections(dup, collapse, origin || "+input");
7552
- },
7553
- replaceSelections: docMethodOp(function(code, collapse, origin) {
7554
- var changes = [], sel = this.sel;
7555
- for (var i = 0; i < sel.ranges.length; i++) {
7556
- var range = sel.ranges[i];
7557
- changes[i] = {from: range.from(), to: range.to(), text: this.splitLines(code[i]), origin: origin};
7558
- }
7559
- var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse);
7560
- for (var i = changes.length - 1; i >= 0; i--)
7561
- makeChange(this, changes[i]);
7562
- if (newSel) setSelectionReplaceHistory(this, newSel);
7563
- else if (this.cm) ensureCursorVisible(this.cm);
7564
- }),
7565
- undo: docMethodOp(function() {makeChangeFromHistory(this, "undo");}),
7566
- redo: docMethodOp(function() {makeChangeFromHistory(this, "redo");}),
7567
- undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true);}),
7568
- redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true);}),
7569
-
7570
- setExtending: function(val) {this.extend = val;},
7571
- getExtending: function() {return this.extend;},
7572
-
7573
- historySize: function() {
7574
- var hist = this.history, done = 0, undone = 0;
7575
- for (var i = 0; i < hist.done.length; i++) if (!hist.done[i].ranges) ++done;
7576
- for (var i = 0; i < hist.undone.length; i++) if (!hist.undone[i].ranges) ++undone;
7577
- return {undo: done, redo: undone};
7578
- },
7579
- clearHistory: function() {this.history = new History(this.history.maxGeneration);},
7580
-
7581
- markClean: function() {
7582
- this.cleanGeneration = this.changeGeneration(true);
7583
- },
7584
- changeGeneration: function(forceSplit) {
7585
- if (forceSplit)
7586
- this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null;
7587
- return this.history.generation;
7588
- },
7589
- isClean: function (gen) {
7590
- return this.history.generation == (gen || this.cleanGeneration);
7591
- },
7592
-
7593
- getHistory: function() {
7594
- return {done: copyHistoryArray(this.history.done),
7595
- undone: copyHistoryArray(this.history.undone)};
7596
- },
7597
- setHistory: function(histData) {
7598
- var hist = this.history = new History(this.history.maxGeneration);
7599
- hist.done = copyHistoryArray(histData.done.slice(0), null, true);
7600
- hist.undone = copyHistoryArray(histData.undone.slice(0), null, true);
7601
- },
7602
-
7603
- addLineClass: docMethodOp(function(handle, where, cls) {
7604
- return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function(line) {
7605
- var prop = where == "text" ? "textClass"
7606
- : where == "background" ? "bgClass"
7607
- : where == "gutter" ? "gutterClass" : "wrapClass";
7608
- if (!line[prop]) line[prop] = cls;
7609
- else if (classTest(cls).test(line[prop])) return false;
7610
- else line[prop] += " " + cls;
7611
- return true;
7612
- });
7613
- }),
7614
- removeLineClass: docMethodOp(function(handle, where, cls) {
7615
- return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function(line) {
7616
- var prop = where == "text" ? "textClass"
7617
- : where == "background" ? "bgClass"
7618
- : where == "gutter" ? "gutterClass" : "wrapClass";
7619
- var cur = line[prop];
7620
- if (!cur) return false;
7621
- else if (cls == null) line[prop] = null;
7622
- else {
7623
- var found = cur.match(classTest(cls));
7624
- if (!found) return false;
7625
- var end = found.index + found[0].length;
7626
- line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null;
7627
- }
7628
- return true;
7629
- });
7630
- }),
7631
-
7632
- addLineWidget: docMethodOp(function(handle, node, options) {
7633
- return addLineWidget(this, handle, node, options);
7634
- }),
7635
- removeLineWidget: function(widget) { widget.clear(); },
7636
-
7637
- markText: function(from, to, options) {
7638
- return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range");
7639
- },
7640
- setBookmark: function(pos, options) {
7641
- var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
7642
- insertLeft: options && options.insertLeft,
7643
- clearWhenEmpty: false, shared: options && options.shared,
7644
- handleMouseEvents: options && options.handleMouseEvents};
7645
- pos = clipPos(this, pos);
7646
- return markText(this, pos, pos, realOpts, "bookmark");
7647
- },
7648
- findMarksAt: function(pos) {
7649
- pos = clipPos(this, pos);
7650
- var markers = [], spans = getLine(this, pos.line).markedSpans;
7651
- if (spans) for (var i = 0; i < spans.length; ++i) {
7652
- var span = spans[i];
7653
- if ((span.from == null || span.from <= pos.ch) &&
7654
- (span.to == null || span.to >= pos.ch))
7655
- markers.push(span.marker.parent || span.marker);
7656
- }
7657
- return markers;
7658
- },
7659
- findMarks: function(from, to, filter) {
7660
- from = clipPos(this, from); to = clipPos(this, to);
7661
- var found = [], lineNo = from.line;
7662
- this.iter(from.line, to.line + 1, function(line) {
7663
- var spans = line.markedSpans;
7664
- if (spans) for (var i = 0; i < spans.length; i++) {
7665
- var span = spans[i];
7666
- if (!(span.to != null && lineNo == from.line && from.ch >= span.to ||
7667
- span.from == null && lineNo != from.line ||
7668
- span.from != null && lineNo == to.line && span.from >= to.ch) &&
7669
- (!filter || filter(span.marker)))
7670
- found.push(span.marker.parent || span.marker);
7671
- }
7672
- ++lineNo;
7673
- });
7674
- return found;
7675
- },
7676
- getAllMarks: function() {
7677
- var markers = [];
7678
- this.iter(function(line) {
7679
- var sps = line.markedSpans;
7680
- if (sps) for (var i = 0; i < sps.length; ++i)
7681
- if (sps[i].from != null) markers.push(sps[i].marker);
7682
- });
7683
- return markers;
7684
- },
7685
-
7686
- posFromIndex: function(off) {
7687
- var ch, lineNo = this.first, sepSize = this.lineSeparator().length;
7688
- this.iter(function(line) {
7689
- var sz = line.text.length + sepSize;
7690
- if (sz > off) { ch = off; return true; }
7691
- off -= sz;
7692
- ++lineNo;
7693
- });
7694
- return clipPos(this, Pos(lineNo, ch));
7695
- },
7696
- indexFromPos: function (coords) {
7697
- coords = clipPos(this, coords);
7698
- var index = coords.ch;
7699
- if (coords.line < this.first || coords.ch < 0) return 0;
7700
- var sepSize = this.lineSeparator().length;
7701
- this.iter(this.first, coords.line, function (line) {
7702
- index += line.text.length + sepSize;
7703
- });
7704
- return index;
7705
- },
7706
-
7707
- copy: function(copyHistory) {
7708
- var doc = new Doc(getLines(this, this.first, this.first + this.size),
7709
- this.modeOption, this.first, this.lineSep);
7710
- doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft;
7711
- doc.sel = this.sel;
7712
- doc.extend = false;
7713
- if (copyHistory) {
7714
- doc.history.undoDepth = this.history.undoDepth;
7715
- doc.setHistory(this.getHistory());
7716
- }
7717
- return doc;
7718
- },
7719
-
7720
- linkedDoc: function(options) {
7721
- if (!options) options = {};
7722
- var from = this.first, to = this.first + this.size;
7723
- if (options.from != null && options.from > from) from = options.from;
7724
- if (options.to != null && options.to < to) to = options.to;
7725
- var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep);
7726
- if (options.sharedHist) copy.history = this.history;
7727
- (this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist});
7728
- copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}];
7729
- copySharedMarkers(copy, findSharedMarkers(this));
7730
- return copy;
7731
- },
7732
- unlinkDoc: function(other) {
7733
- if (other instanceof CodeMirror) other = other.doc;
7734
- if (this.linked) for (var i = 0; i < this.linked.length; ++i) {
7735
- var link = this.linked[i];
7736
- if (link.doc != other) continue;
7737
- this.linked.splice(i, 1);
7738
- other.unlinkDoc(this);
7739
- detachSharedMarkers(findSharedMarkers(this));
7740
- break;
7741
- }
7742
- // If the histories were shared, split them again
7743
- if (other.history == this.history) {
7744
- var splitIds = [other.id];
7745
- linkedDocs(other, function(doc) {splitIds.push(doc.id);}, true);
7746
- other.history = new History(null);
7747
- other.history.done = copyHistoryArray(this.history.done, splitIds);
7748
- other.history.undone = copyHistoryArray(this.history.undone, splitIds);
7749
- }
7750
- },
7751
- iterLinkedDocs: function(f) {linkedDocs(this, f);},
7752
-
7753
- getMode: function() {return this.mode;},
7754
- getEditor: function() {return this.cm;},
7755
-
7756
- splitLines: function(str) {
7757
- if (this.lineSep) return str.split(this.lineSep);
7758
- return splitLinesAuto(str);
7759
- },
7760
- lineSeparator: function() { return this.lineSep || "\n"; }
7761
- });
7762
-
7763
- // Public alias.
7764
- Doc.prototype.eachLine = Doc.prototype.iter;
7765
-
7766
- // Set up methods on CodeMirror's prototype to redirect to the editor's document.
7767
- var dontDelegate = "iter insert remove copy getEditor constructor".split(" ");
7768
- for (var prop in Doc.prototype) if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)
7769
- CodeMirror.prototype[prop] = (function(method) {
7770
- return function() {return method.apply(this.doc, arguments);};
7771
- })(Doc.prototype[prop]);
7772
-
7773
- eventMixin(Doc);
7774
-
7775
- // Call f for all linked documents.
7776
- function linkedDocs(doc, f, sharedHistOnly) {
7777
- function propagate(doc, skip, sharedHist) {
7778
- if (doc.linked) for (var i = 0; i < doc.linked.length; ++i) {
7779
- var rel = doc.linked[i];
7780
- if (rel.doc == skip) continue;
7781
- var shared = sharedHist && rel.sharedHist;
7782
- if (sharedHistOnly && !shared) continue;
7783
- f(rel.doc, shared);
7784
- propagate(rel.doc, doc, shared);
7785
- }
7786
- }
7787
- propagate(doc, null, true);
7788
- }
7789
-
7790
- // Attach a document to an editor.
7791
- function attachDoc(cm, doc) {
7792
- if (doc.cm) throw new Error("This document is already in use.");
7793
- cm.doc = doc;
7794
- doc.cm = cm;
7795
- estimateLineHeights(cm);
7796
- loadMode(cm);
7797
- if (!cm.options.lineWrapping) findMaxLine(cm);
7798
- cm.options.mode = doc.modeOption;
7799
- regChange(cm);
7800
- }
7801
-
7802
- // LINE UTILITIES
7803
-
7804
- // Find the line object corresponding to the given line number.
7805
- function getLine(doc, n) {
7806
- n -= doc.first;
7807
- if (n < 0 || n >= doc.size) throw new Error("There is no line " + (n + doc.first) + " in the document.");
7808
- for (var chunk = doc; !chunk.lines;) {
7809
- for (var i = 0;; ++i) {
7810
- var child = chunk.children[i], sz = child.chunkSize();
7811
- if (n < sz) { chunk = child; break; }
7812
- n -= sz;
7813
- }
7814
- }
7815
- return chunk.lines[n];
7816
- }
7817
-
7818
- // Get the part of a document between two positions, as an array of
7819
- // strings.
7820
- function getBetween(doc, start, end) {
7821
- var out = [], n = start.line;
7822
- doc.iter(start.line, end.line + 1, function(line) {
7823
- var text = line.text;
7824
- if (n == end.line) text = text.slice(0, end.ch);
7825
- if (n == start.line) text = text.slice(start.ch);
7826
- out.push(text);
7827
- ++n;
7828
- });
7829
- return out;
7830
- }
7831
- // Get the lines between from and to, as array of strings.
7832
- function getLines(doc, from, to) {
7833
- var out = [];
7834
- doc.iter(from, to, function(line) { out.push(line.text); });
7835
- return out;
7836
- }
7837
-
7838
- // Update the height of a line, propagating the height change
7839
- // upwards to parent nodes.
7840
- function updateLineHeight(line, height) {
7841
- var diff = height - line.height;
7842
- if (diff) for (var n = line; n; n = n.parent) n.height += diff;
7843
- }
7844
-
7845
- // Given a line object, find its line number by walking up through
7846
- // its parent links.
7847
- function lineNo(line) {
7848
- if (line.parent == null) return null;
7849
- var cur = line.parent, no = indexOf(cur.lines, line);
7850
- for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
7851
- for (var i = 0;; ++i) {
7852
- if (chunk.children[i] == cur) break;
7853
- no += chunk.children[i].chunkSize();
7854
- }
7855
- }
7856
- return no + cur.first;
7857
- }
7858
-
7859
- // Find the line at the given vertical position, using the height
7860
- // information in the document tree.
7861
- function lineAtHeight(chunk, h) {
7862
- var n = chunk.first;
7863
- outer: do {
7864
- for (var i = 0; i < chunk.children.length; ++i) {
7865
- var child = chunk.children[i], ch = child.height;
7866
- if (h < ch) { chunk = child; continue outer; }
7867
- h -= ch;
7868
- n += child.chunkSize();
7869
- }
7870
- return n;
7871
- } while (!chunk.lines);
7872
- for (var i = 0; i < chunk.lines.length; ++i) {
7873
- var line = chunk.lines[i], lh = line.height;
7874
- if (h < lh) break;
7875
- h -= lh;
7876
- }
7877
- return n + i;
7878
- }
7879
-
7880
-
7881
- // Find the height above the given line.
7882
- function heightAtLine(lineObj) {
7883
- lineObj = visualLine(lineObj);
7884
-
7885
- var h = 0, chunk = lineObj.parent;
7886
- for (var i = 0; i < chunk.lines.length; ++i) {
7887
- var line = chunk.lines[i];
7888
- if (line == lineObj) break;
7889
- else h += line.height;
7890
- }
7891
- for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {
7892
- for (var i = 0; i < p.children.length; ++i) {
7893
- var cur = p.children[i];
7894
- if (cur == chunk) break;
7895
- else h += cur.height;
7896
- }
7897
- }
7898
- return h;
7899
- }
7900
-
7901
- // Get the bidi ordering for the given line (and cache it). Returns
7902
- // false for lines that are fully left-to-right, and an array of
7903
- // BidiSpan objects otherwise.
7904
- function getOrder(line) {
7905
- var order = line.order;
7906
- if (order == null) order = line.order = bidiOrdering(line.text);
7907
- return order;
7908
- }
7909
-
7910
- // HISTORY
7911
-
7912
- function History(startGen) {
7913
- // Arrays of change events and selections. Doing something adds an
7914
- // event to done and clears undo. Undoing moves events from done
7915
- // to undone, redoing moves them in the other direction.
7916
- this.done = []; this.undone = [];
7917
- this.undoDepth = Infinity;
7918
- // Used to track when changes can be merged into a single undo
7919
- // event
7920
- this.lastModTime = this.lastSelTime = 0;
7921
- this.lastOp = this.lastSelOp = null;
7922
- this.lastOrigin = this.lastSelOrigin = null;
7923
- // Used by the isClean() method
7924
- this.generation = this.maxGeneration = startGen || 1;
7925
- }
7926
-
7927
- // Create a history change event from an updateDoc-style change
7928
- // object.
7929
- function historyChangeFromChange(doc, change) {
7930
- var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)};
7931
- attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);
7932
- linkedDocs(doc, function(doc) {attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);}, true);
7933
- return histChange;
7934
- }
7935
-
7936
- // Pop all selection events off the end of a history array. Stop at
7937
- // a change event.
7938
- function clearSelectionEvents(array) {
7939
- while (array.length) {
7940
- var last = lst(array);
7941
- if (last.ranges) array.pop();
7942
- else break;
7943
- }
7944
- }
7945
-
7946
- // Find the top change event in the history. Pop off selection
7947
- // events that are in the way.
7948
- function lastChangeEvent(hist, force) {
7949
- if (force) {
7950
- clearSelectionEvents(hist.done);
7951
- return lst(hist.done);
7952
- } else if (hist.done.length && !lst(hist.done).ranges) {
7953
- return lst(hist.done);
7954
- } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
7955
- hist.done.pop();
7956
- return lst(hist.done);
7957
- }
7958
- }
7959
-
7960
- // Register a change in the history. Merges changes that are within
7961
- // a single operation, ore are close together with an origin that
7962
- // allows merging (starting with "+") into a single event.
7963
- function addChangeToHistory(doc, change, selAfter, opId) {
7964
- var hist = doc.history;
7965
- hist.undone.length = 0;
7966
- var time = +new Date, cur;
7967
-
7968
- if ((hist.lastOp == opId ||
7969
- hist.lastOrigin == change.origin && change.origin &&
7970
- ((change.origin.charAt(0) == "+" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||
7971
- change.origin.charAt(0) == "*")) &&
7972
- (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
7973
- // Merge this change into the last event
7974
- var last = lst(cur.changes);
7975
- if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
7976
- // Optimized case for simple insertion -- don't want to add
7977
- // new changesets for every character typed
7978
- last.to = changeEnd(change);
7979
- } else {
7980
- // Add new sub-event
7981
- cur.changes.push(historyChangeFromChange(doc, change));
7982
- }
7983
- } else {
7984
- // Can not be merged, start a new event.
7985
- var before = lst(hist.done);
7986
- if (!before || !before.ranges)
7987
- pushSelectionToHistory(doc.sel, hist.done);
7988
- cur = {changes: [historyChangeFromChange(doc, change)],
7989
- generation: hist.generation};
7990
- hist.done.push(cur);
7991
- while (hist.done.length > hist.undoDepth) {
7992
- hist.done.shift();
7993
- if (!hist.done[0].ranges) hist.done.shift();
7994
- }
7995
- }
7996
- hist.done.push(selAfter);
7997
- hist.generation = ++hist.maxGeneration;
7998
- hist.lastModTime = hist.lastSelTime = time;
7999
- hist.lastOp = hist.lastSelOp = opId;
8000
- hist.lastOrigin = hist.lastSelOrigin = change.origin;
8001
-
8002
- if (!last) signal(doc, "historyAdded");
8003
- }
8004
-
8005
- function selectionEventCanBeMerged(doc, origin, prev, sel) {
8006
- var ch = origin.charAt(0);
8007
- return ch == "*" ||
8008
- ch == "+" &&
8009
- prev.ranges.length == sel.ranges.length &&
8010
- prev.somethingSelected() == sel.somethingSelected() &&
8011
- new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500);
8012
- }
8013
-
8014
- // Called whenever the selection changes, sets the new selection as
8015
- // the pending selection in the history, and pushes the old pending
8016
- // selection into the 'done' array when it was significantly
8017
- // different (in number of selected ranges, emptiness, or time).
8018
- function addSelectionToHistory(doc, sel, opId, options) {
8019
- var hist = doc.history, origin = options && options.origin;
8020
-
8021
- // A new event is started when the previous origin does not match
8022
- // the current, or the origins don't allow matching. Origins
8023
- // starting with * are always merged, those starting with + are
8024
- // merged when similar and close together in time.
8025
- if (opId == hist.lastSelOp ||
8026
- (origin && hist.lastSelOrigin == origin &&
8027
- (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
8028
- selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
8029
- hist.done[hist.done.length - 1] = sel;
8030
- else
8031
- pushSelectionToHistory(sel, hist.done);
8032
-
8033
- hist.lastSelTime = +new Date;
8034
- hist.lastSelOrigin = origin;
8035
- hist.lastSelOp = opId;
8036
- if (options && options.clearRedo !== false)
8037
- clearSelectionEvents(hist.undone);
8038
- }
8039
-
8040
- function pushSelectionToHistory(sel, dest) {
8041
- var top = lst(dest);
8042
- if (!(top && top.ranges && top.equals(sel)))
8043
- dest.push(sel);
8044
- }
8045
-
8046
- // Used to store marked span information in the history.
8047
- function attachLocalSpans(doc, change, from, to) {
8048
- var existing = change["spans_" + doc.id], n = 0;
8049
- doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function(line) {
8050
- if (line.markedSpans)
8051
- (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans;
8052
- ++n;
8053
- });
8054
- }
8055
-
8056
- // When un/re-doing restores text containing marked spans, those
8057
- // that have been explicitly cleared should not be restored.
8058
- function removeClearedSpans(spans) {
8059
- if (!spans) return null;
8060
- for (var i = 0, out; i < spans.length; ++i) {
8061
- if (spans[i].marker.explicitlyCleared) { if (!out) out = spans.slice(0, i); }
8062
- else if (out) out.push(spans[i]);
8063
- }
8064
- return !out ? spans : out.length ? out : null;
8065
- }
8066
-
8067
- // Retrieve and filter the old marked spans stored in a change event.
8068
- function getOldSpans(doc, change) {
8069
- var found = change["spans_" + doc.id];
8070
- if (!found) return null;
8071
- for (var i = 0, nw = []; i < change.text.length; ++i)
8072
- nw.push(removeClearedSpans(found[i]));
8073
- return nw;
8074
- }
8075
-
8076
- // Used both to provide a JSON-safe object in .getHistory, and, when
8077
- // detaching a document, to split the history in two
8078
- function copyHistoryArray(events, newGroup, instantiateSel) {
8079
- for (var i = 0, copy = []; i < events.length; ++i) {
8080
- var event = events[i];
8081
- if (event.ranges) {
8082
- copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event);
8083
- continue;
8084
- }
8085
- var changes = event.changes, newChanges = [];
8086
- copy.push({changes: newChanges});
8087
- for (var j = 0; j < changes.length; ++j) {
8088
- var change = changes[j], m;
8089
- newChanges.push({from: change.from, to: change.to, text: change.text});
8090
- if (newGroup) for (var prop in change) if (m = prop.match(/^spans_(\d+)$/)) {
8091
- if (indexOf(newGroup, Number(m[1])) > -1) {
8092
- lst(newChanges)[prop] = change[prop];
8093
- delete change[prop];
8094
- }
8095
- }
8096
- }
8097
- }
8098
- return copy;
8099
- }
8100
-
8101
- // Rebasing/resetting history to deal with externally-sourced changes
8102
-
8103
- function rebaseHistSelSingle(pos, from, to, diff) {
8104
- if (to < pos.line) {
8105
- pos.line += diff;
8106
- } else if (from < pos.line) {
8107
- pos.line = from;
8108
- pos.ch = 0;
8109
- }
8110
- }
8111
-
8112
- // Tries to rebase an array of history events given a change in the
8113
- // document. If the change touches the same lines as the event, the
8114
- // event, and everything 'behind' it, is discarded. If the change is
8115
- // before the event, the event's positions are updated. Uses a
8116
- // copy-on-write scheme for the positions, to avoid having to
8117
- // reallocate them all on every rebase, but also avoid problems with
8118
- // shared position objects being unsafely updated.
8119
- function rebaseHistArray(array, from, to, diff) {
8120
- for (var i = 0; i < array.length; ++i) {
8121
- var sub = array[i], ok = true;
8122
- if (sub.ranges) {
8123
- if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true; }
8124
- for (var j = 0; j < sub.ranges.length; j++) {
8125
- rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff);
8126
- rebaseHistSelSingle(sub.ranges[j].head, from, to, diff);
8127
- }
8128
- continue;
8129
- }
8130
- for (var j = 0; j < sub.changes.length; ++j) {
8131
- var cur = sub.changes[j];
8132
- if (to < cur.from.line) {
8133
- cur.from = Pos(cur.from.line + diff, cur.from.ch);
8134
- cur.to = Pos(cur.to.line + diff, cur.to.ch);
8135
- } else if (from <= cur.to.line) {
8136
- ok = false;
8137
- break;
8138
- }
8139
- }
8140
- if (!ok) {
8141
- array.splice(0, i + 1);
8142
- i = 0;
8143
- }
8144
- }
8145
- }
8146
-
8147
- function rebaseHist(hist, change) {
8148
- var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1;
8149
- rebaseHistArray(hist.done, from, to, diff);
8150
- rebaseHistArray(hist.undone, from, to, diff);
8151
- }
8152
-
8153
- // EVENT UTILITIES
8154
-
8155
- // Due to the fact that we still support jurassic IE versions, some
8156
- // compatibility wrappers are needed.
8157
-
8158
- var e_preventDefault = CodeMirror.e_preventDefault = function(e) {
8159
- if (e.preventDefault) e.preventDefault();
8160
- else e.returnValue = false;
8161
- };
8162
- var e_stopPropagation = CodeMirror.e_stopPropagation = function(e) {
8163
- if (e.stopPropagation) e.stopPropagation();
8164
- else e.cancelBubble = true;
8165
- };
8166
- function e_defaultPrevented(e) {
8167
- return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false;
8168
- }
8169
- var e_stop = CodeMirror.e_stop = function(e) {e_preventDefault(e); e_stopPropagation(e);};
8170
-
8171
- function e_target(e) {return e.target || e.srcElement;}
8172
- function e_button(e) {
8173
- var b = e.which;
8174
- if (b == null) {
8175
- if (e.button & 1) b = 1;
8176
- else if (e.button & 2) b = 3;
8177
- else if (e.button & 4) b = 2;
8178
- }
8179
- if (mac && e.ctrlKey && b == 1) b = 3;
8180
- return b;
8181
- }
8182
-
8183
- // EVENT HANDLING
8184
-
8185
- // Lightweight event framework. on/off also work on DOM nodes,
8186
- // registering native DOM handlers.
8187
-
8188
- var on = CodeMirror.on = function(emitter, type, f) {
8189
- if (emitter.addEventListener)
8190
- emitter.addEventListener(type, f, false);
8191
- else if (emitter.attachEvent)
8192
- emitter.attachEvent("on" + type, f);
8193
- else {
8194
- var map = emitter._handlers || (emitter._handlers = {});
8195
- var arr = map[type] || (map[type] = []);
8196
- arr.push(f);
8197
- }
8198
- };
8199
-
8200
- var noHandlers = []
8201
- function getHandlers(emitter, type, copy) {
8202
- var arr = emitter._handlers && emitter._handlers[type]
8203
- if (copy) return arr && arr.length > 0 ? arr.slice() : noHandlers
8204
- else return arr || noHandlers
8205
- }
8206
-
8207
- var off = CodeMirror.off = function(emitter, type, f) {
8208
- if (emitter.removeEventListener)
8209
- emitter.removeEventListener(type, f, false);
8210
- else if (emitter.detachEvent)
8211
- emitter.detachEvent("on" + type, f);
8212
- else {
8213
- var handlers = getHandlers(emitter, type, false)
8214
- for (var i = 0; i < handlers.length; ++i)
8215
- if (handlers[i] == f) { handlers.splice(i, 1); break; }
8216
- }
8217
- };
8218
-
8219
- var signal = CodeMirror.signal = function(emitter, type /*, values...*/) {
8220
- var handlers = getHandlers(emitter, type, true)
8221
- if (!handlers.length) return;
8222
- var args = Array.prototype.slice.call(arguments, 2);
8223
- for (var i = 0; i < handlers.length; ++i) handlers[i].apply(null, args);
8224
- };
8225
-
8226
- var orphanDelayedCallbacks = null;
8227
-
8228
- // Often, we want to signal events at a point where we are in the
8229
- // middle of some work, but don't want the handler to start calling
8230
- // other methods on the editor, which might be in an inconsistent
8231
- // state or simply not expect any other events to happen.
8232
- // signalLater looks whether there are any handlers, and schedules
8233
- // them to be executed when the last operation ends, or, if no
8234
- // operation is active, when a timeout fires.
8235
- function signalLater(emitter, type /*, values...*/) {
8236
- var arr = getHandlers(emitter, type, false)
8237
- if (!arr.length) return;
8238
- var args = Array.prototype.slice.call(arguments, 2), list;
8239
- if (operationGroup) {
8240
- list = operationGroup.delayedCallbacks;
8241
- } else if (orphanDelayedCallbacks) {
8242
- list = orphanDelayedCallbacks;
8243
- } else {
8244
- list = orphanDelayedCallbacks = [];
8245
- setTimeout(fireOrphanDelayed, 0);
8246
- }
8247
- function bnd(f) {return function(){f.apply(null, args);};};
8248
- for (var i = 0; i < arr.length; ++i)
8249
- list.push(bnd(arr[i]));
8250
- }
8251
-
8252
- function fireOrphanDelayed() {
8253
- var delayed = orphanDelayedCallbacks;
8254
- orphanDelayedCallbacks = null;
8255
- for (var i = 0; i < delayed.length; ++i) delayed[i]();
8256
- }
8257
-
8258
- // The DOM events that CodeMirror handles can be overridden by
8259
- // registering a (non-DOM) handler on the editor for the event name,
8260
- // and preventDefault-ing the event in that handler.
8261
- function signalDOMEvent(cm, e, override) {
8262
- if (typeof e == "string")
8263
- e = {type: e, preventDefault: function() { this.defaultPrevented = true; }};
8264
- signal(cm, override || e.type, cm, e);
8265
- return e_defaultPrevented(e) || e.codemirrorIgnore;
8266
- }
8267
-
8268
- function signalCursorActivity(cm) {
8269
- var arr = cm._handlers && cm._handlers.cursorActivity;
8270
- if (!arr) return;
8271
- var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []);
8272
- for (var i = 0; i < arr.length; ++i) if (indexOf(set, arr[i]) == -1)
8273
- set.push(arr[i]);
8274
- }
8275
-
8276
- function hasHandler(emitter, type) {
8277
- return getHandlers(emitter, type).length > 0
8278
- }
8279
-
8280
- // Add on and off methods to a constructor's prototype, to make
8281
- // registering events on such objects more convenient.
8282
- function eventMixin(ctor) {
8283
- ctor.prototype.on = function(type, f) {on(this, type, f);};
8284
- ctor.prototype.off = function(type, f) {off(this, type, f);};
8285
- }
8286
-
8287
- // MISC UTILITIES
8288
-
8289
- // Number of pixels added to scroller and sizer to hide scrollbar
8290
- var scrollerGap = 30;
8291
-
8292
- // Returned or thrown by various protocols to signal 'I'm not
8293
- // handling this'.
8294
- var Pass = CodeMirror.Pass = {toString: function(){return "CodeMirror.Pass";}};
8295
-
8296
- // Reused option objects for setSelection & friends
8297
- var sel_dontScroll = {scroll: false}, sel_mouse = {origin: "*mouse"}, sel_move = {origin: "+move"};
8298
-
8299
- function Delayed() {this.id = null;}
8300
- Delayed.prototype.set = function(ms, f) {
8301
- clearTimeout(this.id);
8302
- this.id = setTimeout(f, ms);
8303
- };
8304
-
8305
- // Counts the column offset in a string, taking tabs into account.
8306
- // Used mostly to find indentation.
8307
- var countColumn = CodeMirror.countColumn = function(string, end, tabSize, startIndex, startValue) {
8308
- if (end == null) {
8309
- end = string.search(/[^\s\u00a0]/);
8310
- if (end == -1) end = string.length;
8311
- }
8312
- for (var i = startIndex || 0, n = startValue || 0;;) {
8313
- var nextTab = string.indexOf("\t", i);
8314
- if (nextTab < 0 || nextTab >= end)
8315
- return n + (end - i);
8316
- n += nextTab - i;
8317
- n += tabSize - (n % tabSize);
8318
- i = nextTab + 1;
8319
- }
8320
- };
8321
-
8322
- // The inverse of countColumn -- find the offset that corresponds to
8323
- // a particular column.
8324
- var findColumn = CodeMirror.findColumn = function(string, goal, tabSize) {
8325
- for (var pos = 0, col = 0;;) {
8326
- var nextTab = string.indexOf("\t", pos);
8327
- if (nextTab == -1) nextTab = string.length;
8328
- var skipped = nextTab - pos;
8329
- if (nextTab == string.length || col + skipped >= goal)
8330
- return pos + Math.min(skipped, goal - col);
8331
- col += nextTab - pos;
8332
- col += tabSize - (col % tabSize);
8333
- pos = nextTab + 1;
8334
- if (col >= goal) return pos;
8335
- }
8336
- }
8337
-
8338
- var spaceStrs = [""];
8339
- function spaceStr(n) {
8340
- while (spaceStrs.length <= n)
8341
- spaceStrs.push(lst(spaceStrs) + " ");
8342
- return spaceStrs[n];
8343
- }
8344
-
8345
- function lst(arr) { return arr[arr.length-1]; }
8346
-
8347
- var selectInput = function(node) { node.select(); };
8348
- if (ios) // Mobile Safari apparently has a bug where select() is broken.
8349
- selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; };
8350
- else if (ie) // Suppress mysterious IE10 errors
8351
- selectInput = function(node) { try { node.select(); } catch(_e) {} };
8352
-
8353
- function indexOf(array, elt) {
8354
- for (var i = 0; i < array.length; ++i)
8355
- if (array[i] == elt) return i;
8356
- return -1;
8357
- }
8358
- function map(array, f) {
8359
- var out = [];
8360
- for (var i = 0; i < array.length; i++) out[i] = f(array[i], i);
8361
- return out;
8362
- }
8363
-
8364
- function nothing() {}
8365
-
8366
- function createObj(base, props) {
8367
- var inst;
8368
- if (Object.create) {
8369
- inst = Object.create(base);
8370
- } else {
8371
- nothing.prototype = base;
8372
- inst = new nothing();
8373
- }
8374
- if (props) copyObj(props, inst);
8375
- return inst;
8376
- };
8377
-
8378
- function copyObj(obj, target, overwrite) {
8379
- if (!target) target = {};
8380
- for (var prop in obj)
8381
- if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
8382
- target[prop] = obj[prop];
8383
- return target;
8384
- }
8385
-
8386
- function bind(f) {
8387
- var args = Array.prototype.slice.call(arguments, 1);
8388
- return function(){return f.apply(null, args);};
8389
- }
8390
-
8391
- var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
8392
- var isWordCharBasic = CodeMirror.isWordChar = function(ch) {
8393
- return /\w/.test(ch) || ch > "\x80" &&
8394
- (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch));
8395
- };
8396
- function isWordChar(ch, helper) {
8397
- if (!helper) return isWordCharBasic(ch);
8398
- if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) return true;
8399
- return helper.test(ch);
8400
- }
8401
-
8402
- function isEmpty(obj) {
8403
- for (var n in obj) if (obj.hasOwnProperty(n) && obj[n]) return false;
8404
- return true;
8405
- }
8406
-
8407
- // Extending unicode characters. A series of a non-extending char +
8408
- // any number of extending chars is treated as a single unit as far
8409
- // as editing and measuring is concerned. This is not fully correct,
8410
- // since some scripts/fonts/browsers also treat other configurations
8411
- // of code points as a group.
8412
- var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/;
8413
- function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch); }
8414
-
8415
- // DOM UTILITIES
8416
-
8417
- function elt(tag, content, className, style) {
8418
- var e = document.createElement(tag);
8419
- if (className) e.className = className;
8420
- if (style) e.style.cssText = style;
8421
- if (typeof content == "string") e.appendChild(document.createTextNode(content));
8422
- else if (content) for (var i = 0; i < content.length; ++i) e.appendChild(content[i]);
8423
- return e;
8424
- }
8425
-
8426
- var range;
8427
- if (document.createRange) range = function(node, start, end, endNode) {
8428
- var r = document.createRange();
8429
- r.setEnd(endNode || node, end);
8430
- r.setStart(node, start);
8431
- return r;
8432
- };
8433
- else range = function(node, start, end) {
8434
- var r = document.body.createTextRange();
8435
- try { r.moveToElementText(node.parentNode); }
8436
- catch(e) { return r; }
8437
- r.collapse(true);
8438
- r.moveEnd("character", end);
8439
- r.moveStart("character", start);
8440
- return r;
8441
- };
8442
-
8443
- function removeChildren(e) {
8444
- for (var count = e.childNodes.length; count > 0; --count)
8445
- e.removeChild(e.firstChild);
8446
- return e;
8447
- }
8448
-
8449
- function removeChildrenAndAdd(parent, e) {
8450
- return removeChildren(parent).appendChild(e);
8451
- }
8452
-
8453
- var contains = CodeMirror.contains = function(parent, child) {
8454
- if (child.nodeType == 3) // Android browser always returns false when child is a textnode
8455
- child = child.parentNode;
8456
- if (parent.contains)
8457
- return parent.contains(child);
8458
- do {
8459
- if (child.nodeType == 11) child = child.host;
8460
- if (child == parent) return true;
8461
- } while (child = child.parentNode);
8462
- };
8463
-
8464
- function activeElt() {
8465
- var activeElement = document.activeElement;
8466
- while (activeElement && activeElement.root && activeElement.root.activeElement)
8467
- activeElement = activeElement.root.activeElement;
8468
- return activeElement;
8469
- }
8470
- // Older versions of IE throws unspecified error when touching
8471
- // document.activeElement in some cases (during loading, in iframe)
8472
- if (ie && ie_version < 11) activeElt = function() {
8473
- try { return document.activeElement; }
8474
- catch(e) { return document.body; }
8475
- };
8476
-
8477
- function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*"); }
8478
- var rmClass = CodeMirror.rmClass = function(node, cls) {
8479
- var current = node.className;
8480
- var match = classTest(cls).exec(current);
8481
- if (match) {
8482
- var after = current.slice(match.index + match[0].length);
8483
- node.className = current.slice(0, match.index) + (after ? match[1] + after : "");
8484
- }
8485
- };
8486
- var addClass = CodeMirror.addClass = function(node, cls) {
8487
- var current = node.className;
8488
- if (!classTest(cls).test(current)) node.className += (current ? " " : "") + cls;
8489
- };
8490
- function joinClasses(a, b) {
8491
- var as = a.split(" ");
8492
- for (var i = 0; i < as.length; i++)
8493
- if (as[i] && !classTest(as[i]).test(b)) b += " " + as[i];
8494
- return b;
8495
- }
8496
-
8497
- // WINDOW-WIDE EVENTS
8498
-
8499
- // These must be handled carefully, because naively registering a
8500
- // handler for each editor will cause the editors to never be
8501
- // garbage collected.
8502
-
8503
- function forEachCodeMirror(f) {
8504
- if (!document.body.getElementsByClassName) return;
8505
- var byClass = document.body.getElementsByClassName("CodeMirror");
8506
- for (var i = 0; i < byClass.length; i++) {
8507
- var cm = byClass[i].CodeMirror;
8508
- if (cm) f(cm);
8509
- }
8510
- }
8511
-
8512
- var globalsRegistered = false;
8513
- function ensureGlobalHandlers() {
8514
- if (globalsRegistered) return;
8515
- registerGlobalHandlers();
8516
- globalsRegistered = true;
8517
- }
8518
- function registerGlobalHandlers() {
8519
- // When the window resizes, we need to refresh active editors.
8520
- var resizeTimer;
8521
- on(window, "resize", function() {
8522
- if (resizeTimer == null) resizeTimer = setTimeout(function() {
8523
- resizeTimer = null;
8524
- forEachCodeMirror(onResize);
8525
- }, 100);
8526
- });
8527
- // When the window loses focus, we want to show the editor as blurred
8528
- on(window, "blur", function() {
8529
- forEachCodeMirror(onBlur);
8530
- });
8531
- }
8532
-
8533
- // FEATURE DETECTION
8534
-
8535
- // Detect drag-and-drop
8536
- var dragAndDrop = function() {
8537
- // There is *some* kind of drag-and-drop support in IE6-8, but I
8538
- // couldn't get it to work yet.
8539
- if (ie && ie_version < 9) return false;
8540
- var div = elt('div');
8541
- return "draggable" in div || "dragDrop" in div;
8542
- }();
8543
-
8544
- var zwspSupported;
8545
- function zeroWidthElement(measure) {
8546
- if (zwspSupported == null) {
8547
- var test = elt("span", "\u200b");
8548
- removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]));
8549
- if (measure.firstChild.offsetHeight != 0)
8550
- zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8);
8551
- }
8552
- var node = zwspSupported ? elt("span", "\u200b") :
8553
- elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px");
8554
- node.setAttribute("cm-text", "");
8555
- return node;
8556
- }
8557
-
8558
- // Feature-detect IE's crummy client rect reporting for bidi text
8559
- var badBidiRects;
8560
- function hasBadBidiRects(measure) {
8561
- if (badBidiRects != null) return badBidiRects;
8562
- var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"));
8563
- var r0 = range(txt, 0, 1).getBoundingClientRect();
8564
- var r1 = range(txt, 1, 2).getBoundingClientRect();
8565
- removeChildren(measure);
8566
- if (!r0 || r0.left == r0.right) return false; // Safari returns null in some cases (#2780)
8567
- return badBidiRects = (r1.right - r0.right < 3);
8568
- }
8569
-
8570
- // See if "".split is the broken IE version, if so, provide an
8571
- // alternative way to split lines.
8572
- var splitLinesAuto = CodeMirror.splitLines = "\n\nb".split(/\n/).length != 3 ? function(string) {
8573
- var pos = 0, result = [], l = string.length;
8574
- while (pos <= l) {
8575
- var nl = string.indexOf("\n", pos);
8576
- if (nl == -1) nl = string.length;
8577
- var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl);
8578
- var rt = line.indexOf("\r");
8579
- if (rt != -1) {
8580
- result.push(line.slice(0, rt));
8581
- pos += rt + 1;
8582
- } else {
8583
- result.push(line);
8584
- pos = nl + 1;
8585
- }
8586
- }
8587
- return result;
8588
- } : function(string){return string.split(/\r\n?|\n/);};
8589
-
8590
- var hasSelection = window.getSelection ? function(te) {
8591
- try { return te.selectionStart != te.selectionEnd; }
8592
- catch(e) { return false; }
8593
- } : function(te) {
8594
- try {var range = te.ownerDocument.selection.createRange();}
8595
- catch(e) {}
8596
- if (!range || range.parentElement() != te) return false;
8597
- return range.compareEndPoints("StartToEnd", range) != 0;
8598
- };
8599
-
8600
- var hasCopyEvent = (function() {
8601
- var e = elt("div");
8602
- if ("oncopy" in e) return true;
8603
- e.setAttribute("oncopy", "return;");
8604
- return typeof e.oncopy == "function";
8605
- })();
8606
-
8607
- var badZoomedRects = null;
8608
- function hasBadZoomedRects(measure) {
8609
- if (badZoomedRects != null) return badZoomedRects;
8610
- var node = removeChildrenAndAdd(measure, elt("span", "x"));
8611
- var normal = node.getBoundingClientRect();
8612
- var fromRange = range(node, 0, 1).getBoundingClientRect();
8613
- return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1;
8614
- }
8615
-
8616
- // KEY NAMES
8617
-
8618
- var keyNames = CodeMirror.keyNames = {
8619
- 3: "Enter", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
8620
- 19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
8621
- 36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
8622
- 46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod",
8623
- 106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete",
8624
- 173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
8625
- 221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
8626
- 63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"
8627
- };
8628
- (function() {
8629
- // Number keys
8630
- for (var i = 0; i < 10; i++) keyNames[i + 48] = keyNames[i + 96] = String(i);
8631
- // Alphabetic keys
8632
- for (var i = 65; i <= 90; i++) keyNames[i] = String.fromCharCode(i);
8633
- // Function keys
8634
- for (var i = 1; i <= 12; i++) keyNames[i + 111] = keyNames[i + 63235] = "F" + i;
8635
- })();
8636
-
8637
- // BIDI HELPERS
8638
-
8639
- function iterateBidiSections(order, from, to, f) {
8640
- if (!order) return f(from, to, "ltr");
8641
- var found = false;
8642
- for (var i = 0; i < order.length; ++i) {
8643
- var part = order[i];
8644
- if (part.from < to && part.to > from || from == to && part.to == from) {
8645
- f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr");
8646
- found = true;
8647
- }
8648
- }
8649
- if (!found) f(from, to, "ltr");
8650
- }
8651
-
8652
- function bidiLeft(part) { return part.level % 2 ? part.to : part.from; }
8653
- function bidiRight(part) { return part.level % 2 ? part.from : part.to; }
8654
-
8655
- function lineLeft(line) { var order = getOrder(line); return order ? bidiLeft(order[0]) : 0; }
8656
- function lineRight(line) {
8657
- var order = getOrder(line);
8658
- if (!order) return line.text.length;
8659
- return bidiRight(lst(order));
8660
- }
8661
-
8662
- function lineStart(cm, lineN) {
8663
- var line = getLine(cm.doc, lineN);
8664
- var visual = visualLine(line);
8665
- if (visual != line) lineN = lineNo(visual);
8666
- var order = getOrder(visual);
8667
- var ch = !order ? 0 : order[0].level % 2 ? lineRight(visual) : lineLeft(visual);
8668
- return Pos(lineN, ch);
8669
- }
8670
- function lineEnd(cm, lineN) {
8671
- var merged, line = getLine(cm.doc, lineN);
8672
- while (merged = collapsedSpanAtEnd(line)) {
8673
- line = merged.find(1, true).line;
8674
- lineN = null;
8675
- }
8676
- var order = getOrder(line);
8677
- var ch = !order ? line.text.length : order[0].level % 2 ? lineLeft(line) : lineRight(line);
8678
- return Pos(lineN == null ? lineNo(line) : lineN, ch);
8679
- }
8680
- function lineStartSmart(cm, pos) {
8681
- var start = lineStart(cm, pos.line);
8682
- var line = getLine(cm.doc, start.line);
8683
- var order = getOrder(line);
8684
- if (!order || order[0].level == 0) {
8685
- var firstNonWS = Math.max(0, line.text.search(/\S/));
8686
- var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch;
8687
- return Pos(start.line, inWS ? 0 : firstNonWS);
8688
- }
8689
- return start;
8690
- }
8691
-
8692
- function compareBidiLevel(order, a, b) {
8693
- var linedir = order[0].level;
8694
- if (a == linedir) return true;
8695
- if (b == linedir) return false;
8696
- return a < b;
8697
- }
8698
- var bidiOther;
8699
- function getBidiPartAt(order, pos) {
8700
- bidiOther = null;
8701
- for (var i = 0, found; i < order.length; ++i) {
8702
- var cur = order[i];
8703
- if (cur.from < pos && cur.to > pos) return i;
8704
- if ((cur.from == pos || cur.to == pos)) {
8705
- if (found == null) {
8706
- found = i;
8707
- } else if (compareBidiLevel(order, cur.level, order[found].level)) {
8708
- if (cur.from != cur.to) bidiOther = found;
8709
- return i;
8710
- } else {
8711
- if (cur.from != cur.to) bidiOther = i;
8712
- return found;
8713
- }
8714
- }
8715
- }
8716
- return found;
8717
- }
8718
-
8719
- function moveInLine(line, pos, dir, byUnit) {
8720
- if (!byUnit) return pos + dir;
8721
- do pos += dir;
8722
- while (pos > 0 && isExtendingChar(line.text.charAt(pos)));
8723
- return pos;
8724
- }
8725
-
8726
- // This is needed in order to move 'visually' through bi-directional
8727
- // text -- i.e., pressing left should make the cursor go left, even
8728
- // when in RTL text. The tricky part is the 'jumps', where RTL and
8729
- // LTR text touch each other. This often requires the cursor offset
8730
- // to move more than one unit, in order to visually move one unit.
8731
- function moveVisually(line, start, dir, byUnit) {
8732
- var bidi = getOrder(line);
8733
- if (!bidi) return moveLogically(line, start, dir, byUnit);
8734
- var pos = getBidiPartAt(bidi, start), part = bidi[pos];
8735
- var target = moveInLine(line, start, part.level % 2 ? -dir : dir, byUnit);
8736
-
8737
- for (;;) {
8738
- if (target > part.from && target < part.to) return target;
8739
- if (target == part.from || target == part.to) {
8740
- if (getBidiPartAt(bidi, target) == pos) return target;
8741
- part = bidi[pos += dir];
8742
- return (dir > 0) == part.level % 2 ? part.to : part.from;
8743
- } else {
8744
- part = bidi[pos += dir];
8745
- if (!part) return null;
8746
- if ((dir > 0) == part.level % 2)
8747
- target = moveInLine(line, part.to, -1, byUnit);
8748
- else
8749
- target = moveInLine(line, part.from, 1, byUnit);
8750
- }
8751
- }
8752
- }
8753
-
8754
- function moveLogically(line, start, dir, byUnit) {
8755
- var target = start + dir;
8756
- if (byUnit) while (target > 0 && isExtendingChar(line.text.charAt(target))) target += dir;
8757
- return target < 0 || target > line.text.length ? null : target;
8758
- }
8759
-
8760
- // Bidirectional ordering algorithm
8761
- // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
8762
- // that this (partially) implements.
8763
-
8764
- // One-char codes used for character types:
8765
- // L (L): Left-to-Right
8766
- // R (R): Right-to-Left
8767
- // r (AL): Right-to-Left Arabic
8768
- // 1 (EN): European Number
8769
- // + (ES): European Number Separator
8770
- // % (ET): European Number Terminator
8771
- // n (AN): Arabic Number
8772
- // , (CS): Common Number Separator
8773
- // m (NSM): Non-Spacing Mark
8774
- // b (BN): Boundary Neutral
8775
- // s (B): Paragraph Separator
8776
- // t (S): Segment Separator
8777
- // w (WS): Whitespace
8778
- // N (ON): Other Neutrals
8779
-
8780
- // Returns null if characters are ordered as they appear
8781
- // (left-to-right), or an array of sections ({from, to, level}
8782
- // objects) in the order in which they occur visually.
8783
- var bidiOrdering = (function() {
8784
- // Character types for codepoints 0 to 0xff
8785
- var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";
8786
- // Character types for codepoints 0x600 to 0x6ff
8787
- var arabicTypes = "rrrrrrrrrrrr,rNNmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmrrrrrrrnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmNmmmm";
8788
- function charType(code) {
8789
- if (code <= 0xf7) return lowTypes.charAt(code);
8790
- else if (0x590 <= code && code <= 0x5f4) return "R";
8791
- else if (0x600 <= code && code <= 0x6ed) return arabicTypes.charAt(code - 0x600);
8792
- else if (0x6ee <= code && code <= 0x8ac) return "r";
8793
- else if (0x2000 <= code && code <= 0x200b) return "w";
8794
- else if (code == 0x200c) return "b";
8795
- else return "L";
8796
- }
8797
-
8798
- var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
8799
- var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;
8800
- // Browsers seem to always treat the boundaries of block elements as being L.
8801
- var outerType = "L";
8802
-
8803
- function BidiSpan(level, from, to) {
8804
- this.level = level;
8805
- this.from = from; this.to = to;
8806
- }
8807
-
8808
- return function(str) {
8809
- if (!bidiRE.test(str)) return false;
8810
- var len = str.length, types = [];
8811
- for (var i = 0, type; i < len; ++i)
8812
- types.push(type = charType(str.charCodeAt(i)));
8813
-
8814
- // W1. Examine each non-spacing mark (NSM) in the level run, and
8815
- // change the type of the NSM to the type of the previous
8816
- // character. If the NSM is at the start of the level run, it will
8817
- // get the type of sor.
8818
- for (var i = 0, prev = outerType; i < len; ++i) {
8819
- var type = types[i];
8820
- if (type == "m") types[i] = prev;
8821
- else prev = type;
8822
- }
8823
-
8824
- // W2. Search backwards from each instance of a European number
8825
- // until the first strong type (R, L, AL, or sor) is found. If an
8826
- // AL is found, change the type of the European number to Arabic
8827
- // number.
8828
- // W3. Change all ALs to R.
8829
- for (var i = 0, cur = outerType; i < len; ++i) {
8830
- var type = types[i];
8831
- if (type == "1" && cur == "r") types[i] = "n";
8832
- else if (isStrong.test(type)) { cur = type; if (type == "r") types[i] = "R"; }
8833
- }
8834
-
8835
- // W4. A single European separator between two European numbers
8836
- // changes to a European number. A single common separator between
8837
- // two numbers of the same type changes to that type.
8838
- for (var i = 1, prev = types[0]; i < len - 1; ++i) {
8839
- var type = types[i];
8840
- if (type == "+" && prev == "1" && types[i+1] == "1") types[i] = "1";
8841
- else if (type == "," && prev == types[i+1] &&
8842
- (prev == "1" || prev == "n")) types[i] = prev;
8843
- prev = type;
8844
- }
8845
-
8846
- // W5. A sequence of European terminators adjacent to European
8847
- // numbers changes to all European numbers.
8848
- // W6. Otherwise, separators and terminators change to Other
8849
- // Neutral.
8850
- for (var i = 0; i < len; ++i) {
8851
- var type = types[i];
8852
- if (type == ",") types[i] = "N";
8853
- else if (type == "%") {
8854
- for (var end = i + 1; end < len && types[end] == "%"; ++end) {}
8855
- var replace = (i && types[i-1] == "!") || (end < len && types[end] == "1") ? "1" : "N";
8856
- for (var j = i; j < end; ++j) types[j] = replace;
8857
- i = end - 1;
8858
- }
8859
- }
8860
-
8861
- // W7. Search backwards from each instance of a European number
8862
- // until the first strong type (R, L, or sor) is found. If an L is
8863
- // found, then change the type of the European number to L.
8864
- for (var i = 0, cur = outerType; i < len; ++i) {
8865
- var type = types[i];
8866
- if (cur == "L" && type == "1") types[i] = "L";
8867
- else if (isStrong.test(type)) cur = type;
8868
- }
8869
-
8870
- // N1. A sequence of neutrals takes the direction of the
8871
- // surrounding strong text if the text on both sides has the same
8872
- // direction. European and Arabic numbers act as if they were R in
8873
- // terms of their influence on neutrals. Start-of-level-run (sor)
8874
- // and end-of-level-run (eor) are used at level run boundaries.
8875
- // N2. Any remaining neutrals take the embedding direction.
8876
- for (var i = 0; i < len; ++i) {
8877
- if (isNeutral.test(types[i])) {
8878
- for (var end = i + 1; end < len && isNeutral.test(types[end]); ++end) {}
8879
- var before = (i ? types[i-1] : outerType) == "L";
8880
- var after = (end < len ? types[end] : outerType) == "L";
8881
- var replace = before || after ? "L" : "R";
8882
- for (var j = i; j < end; ++j) types[j] = replace;
8883
- i = end - 1;
8884
- }
8885
- }
8886
-
8887
- // Here we depart from the documented algorithm, in order to avoid
8888
- // building up an actual levels array. Since there are only three
8889
- // levels (0, 1, 2) in an implementation that doesn't take
8890
- // explicit embedding into account, we can build up the order on
8891
- // the fly, without following the level-based algorithm.
8892
- var order = [], m;
8893
- for (var i = 0; i < len;) {
8894
- if (countsAsLeft.test(types[i])) {
8895
- var start = i;
8896
- for (++i; i < len && countsAsLeft.test(types[i]); ++i) {}
8897
- order.push(new BidiSpan(0, start, i));
8898
- } else {
8899
- var pos = i, at = order.length;
8900
- for (++i; i < len && types[i] != "L"; ++i) {}
8901
- for (var j = pos; j < i;) {
8902
- if (countsAsNum.test(types[j])) {
8903
- if (pos < j) order.splice(at, 0, new BidiSpan(1, pos, j));
8904
- var nstart = j;
8905
- for (++j; j < i && countsAsNum.test(types[j]); ++j) {}
8906
- order.splice(at, 0, new BidiSpan(2, nstart, j));
8907
- pos = j;
8908
- } else ++j;
8909
- }
8910
- if (pos < i) order.splice(at, 0, new BidiSpan(1, pos, i));
8911
- }
8912
- }
8913
- if (order[0].level == 1 && (m = str.match(/^\s+/))) {
8914
- order[0].from = m[0].length;
8915
- order.unshift(new BidiSpan(0, 0, m[0].length));
8916
- }
8917
- if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
8918
- lst(order).to -= m[0].length;
8919
- order.push(new BidiSpan(0, len - m[0].length, len));
8920
- }
8921
- if (order[0].level == 2)
8922
- order.unshift(new BidiSpan(1, order[0].to, order[0].to));
8923
- if (order[0].level != lst(order).level)
8924
- order.push(new BidiSpan(order[0].level, len, len));
8925
-
8926
- return order;
8927
- };
8928
- })();
8929
-
8930
- // THE END
8931
-
8932
- CodeMirror.version = "5.17.0";
8933
-
8934
- return CodeMirror;
8935
- });
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
inc/lib/codemirror/{codemirror.css → lib/codemirror.css} RENAMED
@@ -5,6 +5,7 @@
5
  font-family: monospace;
6
  height: 300px;
7
  color: black;
 
8
  }
9
 
10
  /* PADDING */
@@ -58,7 +59,12 @@
58
  .cm-fat-cursor div.CodeMirror-cursors {
59
  z-index: 1;
60
  }
61
-
 
 
 
 
 
62
  .cm-animate-fat-cursor {
63
  width: auto;
64
  border: 0;
@@ -119,7 +125,7 @@
119
  .cm-s-default .cm-property,
120
  .cm-s-default .cm-operator {}
121
  .cm-s-default .cm-variable-2 {color: #05a;}
122
- .cm-s-default .cm-variable-3 {color: #085;}
123
  .cm-s-default .cm-comment {color: #a50;}
124
  .cm-s-default .cm-string {color: #a11;}
125
  .cm-s-default .cm-string-2 {color: #f50;}
@@ -139,8 +145,8 @@
139
 
140
  /* Default styles for common addons */
141
 
142
- div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
143
- div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
144
  .CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
145
  .CodeMirror-activeline-background {background: #e8f2ff;}
146
 
@@ -206,9 +212,6 @@ div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
206
  display: inline-block;
207
  vertical-align: top;
208
  margin-bottom: -30px;
209
- /* Hack to make IE7 behave */
210
- *zoom:1;
211
- *display:inline;
212
  }
213
  .CodeMirror-gutter-wrapper {
214
  position: absolute;
@@ -226,11 +229,8 @@ div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
226
  cursor: default;
227
  z-index: 4;
228
  }
229
- .CodeMirror-gutter-wrapper {
230
- -webkit-user-select: none;
231
- -moz-user-select: none;
232
- user-select: none;
233
- }
234
 
235
  .CodeMirror-lines {
236
  cursor: text;
@@ -252,8 +252,8 @@ div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
252
  position: relative;
253
  overflow: visible;
254
  -webkit-tap-highlight-color: transparent;
255
- -webkit-font-variant-ligatures: none;
256
- font-variant-ligatures: none;
257
  }
258
  .CodeMirror-wrap pre {
259
  word-wrap: break-word;
@@ -270,11 +270,13 @@ div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
270
  .CodeMirror-linewidget {
271
  position: relative;
272
  z-index: 2;
273
- overflow: auto;
274
  }
275
 
276
  .CodeMirror-widget {}
277
 
 
 
278
  .CodeMirror-code {
279
  outline: none;
280
  }
@@ -323,13 +325,10 @@ div.CodeMirror-dragcursors {
323
  .CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }
324
 
325
  .cm-searching {
326
- background: #ffa;
327
- background: rgba(255, 255, 0, .4);
328
  }
329
 
330
- /* IE7 hack to prevent it from returning funny offsetTops on the spans */
331
- .CodeMirror span { *vertical-align: text-bottom; }
332
-
333
  /* Used to force a border model for a node */
334
  .cm-force-border { padding-right: .1px; }
335
 
5
  font-family: monospace;
6
  height: 300px;
7
  color: black;
8
+ direction: ltr;
9
  }
10
 
11
  /* PADDING */
59
  .cm-fat-cursor div.CodeMirror-cursors {
60
  z-index: 1;
61
  }
62
+ .cm-fat-cursor-mark {
63
+ background-color: rgba(20, 255, 20, 0.5);
64
+ -webkit-animation: blink 1.06s steps(1) infinite;
65
+ -moz-animation: blink 1.06s steps(1) infinite;
66
+ animation: blink 1.06s steps(1) infinite;
67
+ }
68
  .cm-animate-fat-cursor {
69
  width: auto;
70
  border: 0;
125
  .cm-s-default .cm-property,
126
  .cm-s-default .cm-operator {}
127
  .cm-s-default .cm-variable-2 {color: #05a;}
128
+ .cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}
129
  .cm-s-default .cm-comment {color: #a50;}
130
  .cm-s-default .cm-string {color: #a11;}
131
  .cm-s-default .cm-string-2 {color: #f50;}
145
 
146
  /* Default styles for common addons */
147
 
148
+ div.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}
149
+ div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}
150
  .CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
151
  .CodeMirror-activeline-background {background: #e8f2ff;}
152
 
212
  display: inline-block;
213
  vertical-align: top;
214
  margin-bottom: -30px;
 
 
 
215
  }
216
  .CodeMirror-gutter-wrapper {
217
  position: absolute;
229
  cursor: default;
230
  z-index: 4;
231
  }
232
+ .CodeMirror-gutter-wrapper ::selection { background-color: transparent }
233
+ .CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent }
 
 
 
234
 
235
  .CodeMirror-lines {
236
  cursor: text;
252
  position: relative;
253
  overflow: visible;
254
  -webkit-tap-highlight-color: transparent;
255
+ -webkit-font-variant-ligatures: contextual;
256
+ font-variant-ligatures: contextual;
257
  }
258
  .CodeMirror-wrap pre {
259
  word-wrap: break-word;
270
  .CodeMirror-linewidget {
271
  position: relative;
272
  z-index: 2;
273
+ padding: 0.1px; /* Force widget margins to stay inside of the container */
274
  }
275
 
276
  .CodeMirror-widget {}
277
 
278
+ .CodeMirror-rtl pre { direction: rtl; }
279
+
280
  .CodeMirror-code {
281
  outline: none;
282
  }
325
  .CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }
326
 
327
  .cm-searching {
328
+ background-color: #ffa;
329
+ background-color: rgba(255, 255, 0, .4);
330
  }
331
 
 
 
 
332
  /* Used to force a border model for a node */
333
  .cm-force-border { padding-right: .1px; }
334
 
inc/lib/codemirror/lib/codemirror.js ADDED
@@ -0,0 +1,9685 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://codemirror.net/LICENSE
3
+
4
+ // This is CodeMirror (http://codemirror.net), a code editor
5
+ // implemented in JavaScript on top of the browser's DOM.
6
+ //
7
+ // You can find some technical background for some of the code below
8
+ // at http://marijnhaverbeke.nl/blog/#cm-internals .
9
+
10
+ (function (global, factory) {
11
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
12
+ typeof define === 'function' && define.amd ? define(factory) :
13
+ (global.CodeMirror = factory());
14
+ }(this, (function () { 'use strict';
15
+
16
+ // Kludges for bugs and behavior differences that can't be feature
17
+ // detected are enabled based on userAgent etc sniffing.
18
+ var userAgent = navigator.userAgent
19
+ var platform = navigator.platform
20
+
21
+ var gecko = /gecko\/\d/i.test(userAgent)
22
+ var ie_upto10 = /MSIE \d/.test(userAgent)
23
+ var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent)
24
+ var edge = /Edge\/(\d+)/.exec(userAgent)
25
+ var ie = ie_upto10 || ie_11up || edge
26
+ var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1])
27
+ var webkit = !edge && /WebKit\//.test(userAgent)
28
+ var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent)
29
+ var chrome = !edge && /Chrome\//.test(userAgent)
30
+ var presto = /Opera\//.test(userAgent)
31
+ var safari = /Apple Computer/.test(navigator.vendor)
32
+ var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent)
33
+ var phantom = /PhantomJS/.test(userAgent)
34
+
35
+ var ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent)
36
+ var android = /Android/.test(userAgent)
37
+ // This is woefully incomplete. Suggestions for alternative methods welcome.
38
+ var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent)
39
+ var mac = ios || /Mac/.test(platform)
40
+ var chromeOS = /\bCrOS\b/.test(userAgent)
41
+ var windows = /win/i.test(platform)
42
+
43
+ var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/)
44
+ if (presto_version) { presto_version = Number(presto_version[1]) }
45
+ if (presto_version && presto_version >= 15) { presto = false; webkit = true }
46
+ // Some browsers use the wrong event properties to signal cmd/ctrl on OS X
47
+ var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11))
48
+ var captureRightClick = gecko || (ie && ie_version >= 9)
49
+
50
+ function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") }
51
+
52
+ var rmClass = function(node, cls) {
53
+ var current = node.className
54
+ var match = classTest(cls).exec(current)
55
+ if (match) {
56
+ var after = current.slice(match.index + match[0].length)
57
+ node.className = current.slice(0, match.index) + (after ? match[1] + after : "")
58
+ }
59
+ }
60
+
61
+ function removeChildren(e) {
62
+ for (var count = e.childNodes.length; count > 0; --count)
63
+ { e.removeChild(e.firstChild) }
64
+ return e
65
+ }
66
+
67
+ function removeChildrenAndAdd(parent, e) {
68
+ return removeChildren(parent).appendChild(e)
69
+ }
70
+
71
+ function elt(tag, content, className, style) {
72
+ var e = document.createElement(tag)
73
+ if (className) { e.className = className }
74
+ if (style) { e.style.cssText = style }
75
+ if (typeof content == "string") { e.appendChild(document.createTextNode(content)) }
76
+ else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]) } }
77
+ return e
78
+ }
79
+ // wrapper for elt, which removes the elt from the accessibility tree
80
+ function eltP(tag, content, className, style) {
81
+ var e = elt(tag, content, className, style)
82
+ e.setAttribute("role", "presentation")
83
+ return e
84
+ }
85
+
86
+ var range
87
+ if (document.createRange) { range = function(node, start, end, endNode) {
88
+ var r = document.createRange()
89
+ r.setEnd(endNode || node, end)
90
+ r.setStart(node, start)
91
+ return r
92
+ } }
93
+ else { range = function(node, start, end) {
94
+ var r = document.body.createTextRange()
95
+ try { r.moveToElementText(node.parentNode) }
96
+ catch(e) { return r }
97
+ r.collapse(true)
98
+ r.moveEnd("character", end)
99
+ r.moveStart("character", start)
100
+ return r
101
+ } }
102
+
103
+ function contains(parent, child) {
104
+ if (child.nodeType == 3) // Android browser always returns false when child is a textnode
105
+ { child = child.parentNode }
106
+ if (parent.contains)
107
+ { return parent.contains(child) }
108
+ do {
109
+ if (child.nodeType == 11) { child = child.host }
110
+ if (child == parent) { return true }
111
+ } while (child = child.parentNode)
112
+ }
113
+
114
+ function activeElt() {
115
+ // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement.
116
+ // IE < 10 will throw when accessed while the page is loading or in an iframe.
117
+ // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.
118
+ var activeElement
119
+ try {
120
+ activeElement = document.activeElement
121
+ } catch(e) {
122
+ activeElement = document.body || null
123
+ }
124
+ while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement)
125
+ { activeElement = activeElement.shadowRoot.activeElement }
126
+ return activeElement
127
+ }
128
+
129
+ function addClass(node, cls) {
130
+ var current = node.className
131
+ if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls }
132
+ }
133
+ function joinClasses(a, b) {
134
+ var as = a.split(" ")
135
+ for (var i = 0; i < as.length; i++)
136
+ { if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i] } }
137
+ return b
138
+ }
139
+
140
+ var selectInput = function(node) { node.select() }
141
+ if (ios) // Mobile Safari apparently has a bug where select() is broken.
142
+ { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length } }
143
+ else if (ie) // Suppress mysterious IE10 errors
144
+ { selectInput = function(node) { try { node.select() } catch(_e) {} } }
145
+
146
+ function bind(f) {
147
+ var args = Array.prototype.slice.call(arguments, 1)
148
+ return function(){return f.apply(null, args)}
149
+ }
150
+
151
+ function copyObj(obj, target, overwrite) {
152
+ if (!target) { target = {} }
153
+ for (var prop in obj)
154
+ { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
155
+ { target[prop] = obj[prop] } }
156
+ return target
157
+ }
158
+
159
+ // Counts the column offset in a string, taking tabs into account.
160
+ // Used mostly to find indentation.
161
+ function countColumn(string, end, tabSize, startIndex, startValue) {
162
+ if (end == null) {
163
+ end = string.search(/[^\s\u00a0]/)
164
+ if (end == -1) { end = string.length }
165
+ }
166
+ for (var i = startIndex || 0, n = startValue || 0;;) {
167
+ var nextTab = string.indexOf("\t", i)
168
+ if (nextTab < 0 || nextTab >= end)
169
+ { return n + (end - i) }
170
+ n += nextTab - i
171
+ n += tabSize - (n % tabSize)
172
+ i = nextTab + 1
173
+ }
174
+ }
175
+
176
+ var Delayed = function() {this.id = null};
177
+ Delayed.prototype.set = function (ms, f) {
178
+ clearTimeout(this.id)
179
+ this.id = setTimeout(f, ms)
180
+ };
181
+
182
+ function indexOf(array, elt) {
183
+ for (var i = 0; i < array.length; ++i)
184
+ { if (array[i] == elt) { return i } }
185
+ return -1
186
+ }
187
+
188
+ // Number of pixels added to scroller and sizer to hide scrollbar
189
+ var scrollerGap = 30
190
+
191
+ // Returned or thrown by various protocols to signal 'I'm not
192
+ // handling this'.
193
+ var Pass = {toString: function(){return "CodeMirror.Pass"}}
194
+
195
+ // Reused option objects for setSelection & friends
196
+ var sel_dontScroll = {scroll: false};
197
+ var sel_mouse = {origin: "*mouse"};
198
+ var sel_move = {origin: "+move"};
199
+ // The inverse of countColumn -- find the offset that corresponds to
200
+ // a particular column.
201
+ function findColumn(string, goal, tabSize) {
202
+ for (var pos = 0, col = 0;;) {
203
+ var nextTab = string.indexOf("\t", pos)
204
+ if (nextTab == -1) { nextTab = string.length }
205
+ var skipped = nextTab - pos
206
+ if (nextTab == string.length || col + skipped >= goal)
207
+ { return pos + Math.min(skipped, goal - col) }
208
+ col += nextTab - pos
209
+ col += tabSize - (col % tabSize)
210
+ pos = nextTab + 1
211
+ if (col >= goal) { return pos }
212
+ }
213
+ }
214
+
215
+ var spaceStrs = [""]
216
+ function spaceStr(n) {
217
+ while (spaceStrs.length <= n)
218
+ { spaceStrs.push(lst(spaceStrs) + " ") }
219
+ return spaceStrs[n]
220
+ }
221
+
222
+ function lst(arr) { return arr[arr.length-1] }
223
+
224
+ function map(array, f) {
225
+ var out = []
226
+ for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i) }
227
+ return out
228
+ }
229
+
230
+ function insertSorted(array, value, score) {
231
+ var pos = 0, priority = score(value)
232
+ while (pos < array.length && score(array[pos]) <= priority) { pos++ }
233
+ array.splice(pos, 0, value)
234
+ }
235
+
236
+ function nothing() {}
237
+
238
+ function createObj(base, props) {
239
+ var inst
240
+ if (Object.create) {
241
+ inst = Object.create(base)
242
+ } else {
243
+ nothing.prototype = base
244
+ inst = new nothing()
245
+ }
246
+ if (props) { copyObj(props, inst) }
247
+ return inst
248
+ }
249
+
250
+ var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/
251
+ function isWordCharBasic(ch) {
252
+ return /\w/.test(ch) || ch > "\x80" &&
253
+ (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))
254
+ }
255
+ function isWordChar(ch, helper) {
256
+ if (!helper) { return isWordCharBasic(ch) }
257
+ if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true }
258
+ return helper.test(ch)
259
+ }
260
+
261
+ function isEmpty(obj) {
262
+ for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }
263
+ return true
264
+ }
265
+
266
+ // Extending unicode characters. A series of a non-extending char +
267
+ // any number of extending chars is treated as a single unit as far
268
+ // as editing and measuring is concerned. This is not fully correct,
269
+ // since some scripts/fonts/browsers also treat other configurations
270
+ // of code points as a group.
271
+ var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/
272
+ function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }
273
+
274
+ // Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.
275
+ function skipExtendingChars(str, pos, dir) {
276
+ while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir }
277
+ return pos
278
+ }
279
+
280
+ // Returns the value from the range [`from`; `to`] that satisfies
281
+ // `pred` and is closest to `from`. Assumes that at least `to`
282
+ // satisfies `pred`. Supports `from` being greater than `to`.
283
+ function findFirst(pred, from, to) {
284
+ // At any point we are certain `to` satisfies `pred`, don't know
285
+ // whether `from` does.
286
+ var dir = from > to ? -1 : 1
287
+ for (;;) {
288
+ if (from == to) { return from }
289
+ var midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF)
290
+ if (mid == from) { return pred(mid) ? from : to }
291
+ if (pred(mid)) { to = mid }
292
+ else { from = mid + dir }
293
+ }
294
+ }
295
+
296
+ // The display handles the DOM integration, both for input reading
297
+ // and content drawing. It holds references to DOM nodes and
298
+ // display-related state.
299
+
300
+ function Display(place, doc, input) {
301
+ var d = this
302
+ this.input = input
303
+
304
+ // Covers bottom-right square when both scrollbars are present.
305
+ d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler")
306
+ d.scrollbarFiller.setAttribute("cm-not-content", "true")
307
+ // Covers bottom of gutter when coverGutterNextToScrollbar is on
308
+ // and h scrollbar is present.
309
+ d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler")
310
+ d.gutterFiller.setAttribute("cm-not-content", "true")
311
+ // Will contain the actual code, positioned to cover the viewport.
312
+ d.lineDiv = eltP("div", null, "CodeMirror-code")
313
+ // Elements are added to these to represent selection and cursors.
314
+ d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1")
315
+ d.cursorDiv = elt("div", null, "CodeMirror-cursors")
316
+ // A visibility: hidden element used to find the size of things.
317
+ d.measure = elt("div", null, "CodeMirror-measure")
318
+ // When lines outside of the viewport are measured, they are drawn in this.
319
+ d.lineMeasure = elt("div", null, "CodeMirror-measure")
320
+ // Wraps everything that needs to exist inside the vertically-padded coordinate system
321
+ d.lineSpace = eltP("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
322
+ null, "position: relative; outline: none")
323
+ var lines = eltP("div", [d.lineSpace], "CodeMirror-lines")
324
+ // Moved around its parent to cover visible view.
325
+ d.mover = elt("div", [lines], null, "position: relative")
326
+ // Set to the height of the document, allowing scrolling.
327
+ d.sizer = elt("div", [d.mover], "CodeMirror-sizer")
328
+ d.sizerWidth = null
329
+ // Behavior of elts with overflow: auto and padding is
330
+ // inconsistent across browsers. This is used to ensure the
331
+ // scrollable area is big enough.
332
+ d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;")
333
+ // Will contain the gutters, if any.
334
+ d.gutters = elt("div", null, "CodeMirror-gutters")
335
+ d.lineGutter = null
336
+ // Actual scrollable element.
337
+ d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll")
338
+ d.scroller.setAttribute("tabIndex", "-1")
339
+ // The element in which the editor lives.
340
+ d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror")
341
+
342
+ // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
343
+ if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0 }
344
+ if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true }
345
+
346
+ if (place) {
347
+ if (place.appendChild) { place.appendChild(d.wrapper) }
348
+ else { place(d.wrapper) }
349
+ }
350
+
351
+ // Current rendered range (may be bigger than the view window).
352
+ d.viewFrom = d.viewTo = doc.first
353
+ d.reportedViewFrom = d.reportedViewTo = doc.first
354
+ // Information about the rendered lines.
355
+ d.view = []
356
+ d.renderedView = null
357
+ // Holds info about a single rendered line when it was rendered
358
+ // for measurement, while not in view.
359
+ d.externalMeasured = null
360
+ // Empty space (in pixels) above the view
361
+ d.viewOffset = 0
362
+ d.lastWrapHeight = d.lastWrapWidth = 0
363
+ d.updateLineNumbers = null
364
+
365
+ d.nativeBarWidth = d.barHeight = d.barWidth = 0
366
+ d.scrollbarsClipped = false
367
+
368
+ // Used to only resize the line number gutter when necessary (when
369
+ // the amount of lines crosses a boundary that makes its width change)
370
+ d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null
371
+ // Set to true when a non-horizontal-scrolling line widget is
372
+ // added. As an optimization, line widget aligning is skipped when
373
+ // this is false.
374
+ d.alignWidgets = false
375
+
376
+ d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
377
+
378
+ // Tracks the maximum line length so that the horizontal scrollbar
379
+ // can be kept static when scrolling.
380
+ d.maxLine = null
381
+ d.maxLineLength = 0
382
+ d.maxLineChanged = false
383
+
384
+ // Used for measuring wheel scrolling granularity
385
+ d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null
386
+
387
+ // True when shift is held down.
388
+ d.shift = false
389
+
390
+ // Used to track whether anything happened since the context menu
391
+ // was opened.
392
+ d.selForContextMenu = null
393
+
394
+ d.activeTouch = null
395
+
396
+ input.init(d)
397
+ }
398
+
399
+ // Find the line object corresponding to the given line number.
400
+ function getLine(doc, n) {
401
+ n -= doc.first
402
+ if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") }
403
+ var chunk = doc
404
+ while (!chunk.lines) {
405
+ for (var i = 0;; ++i) {
406
+ var child = chunk.children[i], sz = child.chunkSize()
407
+ if (n < sz) { chunk = child; break }
408
+ n -= sz
409
+ }
410
+ }
411
+ return chunk.lines[n]
412
+ }
413
+
414
+ // Get the part of a document between two positions, as an array of
415
+ // strings.
416
+ function getBetween(doc, start, end) {
417
+ var out = [], n = start.line
418
+ doc.iter(start.line, end.line + 1, function (line) {
419
+ var text = line.text
420
+ if (n == end.line) { text = text.slice(0, end.ch) }
421
+ if (n == start.line) { text = text.slice(start.ch) }
422
+ out.push(text)
423
+ ++n
424
+ })
425
+ return out
426
+ }
427
+ // Get the lines between from and to, as array of strings.
428
+ function getLines(doc, from, to) {
429
+ var out = []
430
+ doc.iter(from, to, function (line) { out.push(line.text) }) // iter aborts when callback returns truthy value
431
+ return out
432
+ }
433
+
434
+ // Update the height of a line, propagating the height change
435
+ // upwards to parent nodes.
436
+ function updateLineHeight(line, height) {
437
+ var diff = height - line.height
438
+ if (diff) { for (var n = line; n; n = n.parent) { n.height += diff } }
439
+ }
440
+
441
+ // Given a line object, find its line number by walking up through
442
+ // its parent links.
443
+ function lineNo(line) {
444
+ if (line.parent == null) { return null }
445
+ var cur = line.parent, no = indexOf(cur.lines, line)
446
+ for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
447
+ for (var i = 0;; ++i) {
448
+ if (chunk.children[i] == cur) { break }
449
+ no += chunk.children[i].chunkSize()
450
+ }
451
+ }
452
+ return no + cur.first
453
+ }
454
+
455
+ // Find the line at the given vertical position, using the height
456
+ // information in the document tree.
457
+ function lineAtHeight(chunk, h) {
458
+ var n = chunk.first
459
+ outer: do {
460
+ for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {
461
+ var child = chunk.children[i$1], ch = child.height
462
+ if (h < ch) { chunk = child; continue outer }
463
+ h -= ch
464
+ n += child.chunkSize()
465
+ }
466
+ return n
467
+ } while (!chunk.lines)
468
+ var i = 0
469
+ for (; i < chunk.lines.length; ++i) {
470
+ var line = chunk.lines[i], lh = line.height
471
+ if (h < lh) { break }
472
+ h -= lh
473
+ }
474
+ return n + i
475
+ }
476
+
477
+ function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}
478
+
479
+ function lineNumberFor(options, i) {
480
+ return String(options.lineNumberFormatter(i + options.firstLineNumber))
481
+ }
482
+
483
+ // A Pos instance represents a position within the text.
484
+ function Pos(line, ch, sticky) {
485
+ if ( sticky === void 0 ) sticky = null;
486
+
487
+ if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) }
488
+ this.line = line
489
+ this.ch = ch
490
+ this.sticky = sticky
491
+ }
492
+
493
+ // Compare two positions, return 0 if they are the same, a negative
494
+ // number when a is less, and a positive number otherwise.
495
+ function cmp(a, b) { return a.line - b.line || a.ch - b.ch }
496
+
497
+ function equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 }
498
+
499
+ function copyPos(x) {return Pos(x.line, x.ch)}
500
+ function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }
501
+ function minPos(a, b) { return cmp(a, b) < 0 ? a : b }
502
+
503
+ // Most of the external API clips given positions to make sure they
504
+ // actually exist within the document.
505
+ function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}
506
+ function clipPos(doc, pos) {
507
+ if (pos.line < doc.first) { return Pos(doc.first, 0) }
508
+ var last = doc.first + doc.size - 1
509
+ if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }
510
+ return clipToLen(pos, getLine(doc, pos.line).text.length)
511
+ }
512
+ function clipToLen(pos, linelen) {
513
+ var ch = pos.ch
514
+ if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }
515
+ else if (ch < 0) { return Pos(pos.line, 0) }
516
+ else { return pos }
517
+ }
518
+ function clipPosArray(doc, array) {
519
+ var out = []
520
+ for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]) }
521
+ return out
522
+ }
523
+
524
+ // Optimize some code when these features are not used.
525
+ var sawReadOnlySpans = false;
526
+ var sawCollapsedSpans = false;
527
+ function seeReadOnlySpans() {
528
+ sawReadOnlySpans = true
529
+ }
530
+
531
+ function seeCollapsedSpans() {
532
+ sawCollapsedSpans = true
533
+ }
534
+
535
+ // TEXTMARKER SPANS
536
+
537
+ function MarkedSpan(marker, from, to) {
538
+ this.marker = marker
539
+ this.from = from; this.to = to
540
+ }
541
+
542
+ // Search an array of spans for a span matching the given marker.
543
+ function getMarkedSpanFor(spans, marker) {
544
+ if (spans) { for (var i = 0; i < spans.length; ++i) {
545
+ var span = spans[i]
546
+ if (span.marker == marker) { return span }
547
+ } }
548
+ }
549
+ // Remove a span from an array, returning undefined if no spans are
550
+ // left (we don't store arrays for lines without spans).
551
+ function removeMarkedSpan(spans, span) {
552
+ var r
553
+ for (var i = 0; i < spans.length; ++i)
554
+ { if (spans[i] != span) { (r || (r = [])).push(spans[i]) } }
555
+ return r
556
+ }
557
+ // Add a span to a line.
558
+ function addMarkedSpan(line, span) {
559
+ line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]
560
+ span.marker.attachLine(line)
561
+ }
562
+
563
+ // Used for the algorithm that adjusts markers for a change in the
564
+ // document. These functions cut an array of spans at a given
565
+ // character position, returning an array of remaining chunks (or
566
+ // undefined if nothing remains).
567
+ function markedSpansBefore(old, startCh, isInsert) {
568
+ var nw
569
+ if (old) { for (var i = 0; i < old.length; ++i) {
570
+ var span = old[i], marker = span.marker
571
+ var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh)
572
+ if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
573
+ var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)
574
+ ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to))
575
+ }
576
+ } }
577
+ return nw
578
+ }
579
+ function markedSpansAfter(old, endCh, isInsert) {
580
+ var nw
581
+ if (old) { for (var i = 0; i < old.length; ++i) {
582
+ var span = old[i], marker = span.marker
583
+ var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh)
584
+ if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
585
+ var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)
586
+ ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
587
+ span.to == null ? null : span.to - endCh))
588
+ }
589
+ } }
590
+ return nw
591
+ }
592
+
593
+ // Given a change object, compute the new set of marker spans that
594
+ // cover the line in which the change took place. Removes spans
595
+ // entirely within the change, reconnects spans belonging to the
596
+ // same marker that appear on both sides of the change, and cuts off
597
+ // spans partially within the change. Returns an array of span
598
+ // arrays with one element for each line in (after) the change.
599
+ function stretchSpansOverChange(doc, change) {
600
+ if (change.full) { return null }
601
+ var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans
602
+ var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans
603
+ if (!oldFirst && !oldLast) { return null }
604
+
605
+ var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0
606
+ // Get the spans that 'stick out' on both sides
607
+ var first = markedSpansBefore(oldFirst, startCh, isInsert)
608
+ var last = markedSpansAfter(oldLast, endCh, isInsert)
609
+
610
+ // Next, merge those two ends
611
+ var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0)
612
+ if (first) {
613
+ // Fix up .to properties of first
614
+ for (var i = 0; i < first.length; ++i) {
615
+ var span = first[i]
616
+ if (span.to == null) {
617
+ var found = getMarkedSpanFor(last, span.marker)
618
+ if (!found) { span.to = startCh }
619
+ else if (sameLine) { span.to = found.to == null ? null : found.to + offset }
620
+ }
621
+ }
622
+ }
623
+ if (last) {
624
+ // Fix up .from in last (or move them into first in case of sameLine)
625
+ for (var i$1 = 0; i$1 < last.length; ++i$1) {
626
+ var span$1 = last[i$1]
627
+ if (span$1.to != null) { span$1.to += offset }
628
+ if (span$1.from == null) {
629
+ var found$1 = getMarkedSpanFor(first, span$1.marker)
630
+ if (!found$1) {
631
+ span$1.from = offset
632
+ if (sameLine) { (first || (first = [])).push(span$1) }
633
+ }
634
+ } else {
635
+ span$1.from += offset
636
+ if (sameLine) { (first || (first = [])).push(span$1) }
637
+ }
638
+ }
639
+ }
640
+ // Make sure we didn't create any zero-length spans
641
+ if (first) { first = clearEmptySpans(first) }
642
+ if (last && last != first) { last = clearEmptySpans(last) }
643
+
644
+ var newMarkers = [first]
645
+ if (!sameLine) {
646
+ // Fill gap with whole-line-spans
647
+ var gap = change.text.length - 2, gapMarkers
648
+ if (gap > 0 && first)
649
+ { for (var i$2 = 0; i$2 < first.length; ++i$2)
650
+ { if (first[i$2].to == null)
651
+ { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)) } } }
652
+ for (var i$3 = 0; i$3 < gap; ++i$3)
653
+ { newMarkers.push(gapMarkers) }
654
+ newMarkers.push(last)
655
+ }
656
+ return newMarkers
657
+ }
658
+
659
+ // Remove spans that are empty and don't have a clearWhenEmpty
660
+ // option of false.
661
+ function clearEmptySpans(spans) {
662
+ for (var i = 0; i < spans.length; ++i) {
663
+ var span = spans[i]
664
+ if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
665
+ { spans.splice(i--, 1) }
666
+ }
667
+ if (!spans.length) { return null }
668
+ return spans
669
+ }
670
+
671
+ // Used to 'clip' out readOnly ranges when making a change.
672
+ function removeReadOnlyRanges(doc, from, to) {
673
+ var markers = null
674
+ doc.iter(from.line, to.line + 1, function (line) {
675
+ if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
676
+ var mark = line.markedSpans[i].marker
677
+ if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
678
+ { (markers || (markers = [])).push(mark) }
679
+ } }
680
+ })
681
+ if (!markers) { return null }
682
+ var parts = [{from: from, to: to}]
683
+ for (var i = 0; i < markers.length; ++i) {
684
+ var mk = markers[i], m = mk.find(0)
685
+ for (var j = 0; j < parts.length; ++j) {
686
+ var p = parts[j]
687
+ if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }
688
+ var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to)
689
+ if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
690
+ { newParts.push({from: p.from, to: m.from}) }
691
+ if (dto > 0 || !mk.inclusiveRight && !dto)
692
+ { newParts.push({from: m.to, to: p.to}) }
693
+ parts.splice.apply(parts, newParts)
694
+ j += newParts.length - 3
695
+ }
696
+ }
697
+ return parts
698
+ }
699
+
700
+ // Connect or disconnect spans from a line.
701
+ function detachMarkedSpans(line) {
702
+ var spans = line.markedSpans
703
+ if (!spans) { return }
704
+ for (var i = 0; i < spans.length; ++i)
705
+ { spans[i].marker.detachLine(line) }
706
+ line.markedSpans = null
707
+ }
708
+ function attachMarkedSpans(line, spans) {
709
+ if (!spans) { return }
710
+ for (var i = 0; i < spans.length; ++i)
711
+ { spans[i].marker.attachLine(line) }
712
+ line.markedSpans = spans
713
+ }
714
+
715
+ // Helpers used when computing which overlapping collapsed span
716
+ // counts as the larger one.
717
+ function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }
718
+ function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }
719
+
720
+ // Returns a number indicating which of two overlapping collapsed
721
+ // spans is larger (and thus includes the other). Falls back to
722
+ // comparing ids when the spans cover exactly the same range.
723
+ function compareCollapsedMarkers(a, b) {
724
+ var lenDiff = a.lines.length - b.lines.length
725
+ if (lenDiff != 0) { return lenDiff }
726
+ var aPos = a.find(), bPos = b.find()
727
+ var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b)
728
+ if (fromCmp) { return -fromCmp }
729
+ var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b)
730
+ if (toCmp) { return toCmp }
731
+ return b.id - a.id
732
+ }
733
+
734
+ // Find out whether a line ends or starts in a collapsed span. If
735
+ // so, return the marker for that span.
736
+ function collapsedSpanAtSide(line, start) {
737
+ var sps = sawCollapsedSpans && line.markedSpans, found
738
+ if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
739
+ sp = sps[i]
740
+ if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
741
+ (!found || compareCollapsedMarkers(found, sp.marker) < 0))
742
+ { found = sp.marker }
743
+ } }
744
+ return found
745
+ }
746
+ function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }
747
+ function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }
748
+
749
+ function collapsedSpanAround(line, ch) {
750
+ var sps = sawCollapsedSpans && line.markedSpans, found
751
+ if (sps) { for (var i = 0; i < sps.length; ++i) {
752
+ var sp = sps[i]
753
+ if (sp.marker.collapsed && (sp.from == null || sp.from < ch) && (sp.to == null || sp.to > ch) &&
754
+ (!found || compareCollapsedMarkers(found, sp.marker) < 0)) { found = sp.marker }
755
+ } }
756
+ return found
757
+ }
758
+
759
+ // Test whether there exists a collapsed span that partially
760
+ // overlaps (covers the start or end, but not both) of a new span.
761
+ // Such overlap is not allowed.
762
+ function conflictingCollapsedRange(doc, lineNo, from, to, marker) {
763
+ var line = getLine(doc, lineNo)
764
+ var sps = sawCollapsedSpans && line.markedSpans
765
+ if (sps) { for (var i = 0; i < sps.length; ++i) {
766
+ var sp = sps[i]
767
+ if (!sp.marker.collapsed) { continue }
768
+ var found = sp.marker.find(0)
769
+ var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker)
770
+ var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker)
771
+ if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }
772
+ if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||
773
+ fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))
774
+ { return true }
775
+ } }
776
+ }
777
+
778
+ // A visual line is a line as drawn on the screen. Folding, for
779
+ // example, can cause multiple logical lines to appear on the same
780
+ // visual line. This finds the start of the visual line that the
781
+ // given line is part of (usually that is the line itself).
782
+ function visualLine(line) {
783
+ var merged
784
+ while (merged = collapsedSpanAtStart(line))
785
+ { line = merged.find(-1, true).line }
786
+ return line
787
+ }
788
+
789
+ function visualLineEnd(line) {
790
+ var merged
791
+ while (merged = collapsedSpanAtEnd(line))
792
+ { line = merged.find(1, true).line }
793
+ return line
794
+ }
795
+
796
+ // Returns an array of logical lines that continue the visual line
797
+ // started by the argument, or undefined if there are no such lines.
798
+ function visualLineContinued(line) {
799
+ var merged, lines
800
+ while (merged = collapsedSpanAtEnd(line)) {
801
+ line = merged.find(1, true).line
802
+ ;(lines || (lines = [])).push(line)
803
+ }
804
+ return lines
805
+ }
806
+
807
+ // Get the line number of the start of the visual line that the
808
+ // given line number is part of.
809
+ function visualLineNo(doc, lineN) {
810
+ var line = getLine(doc, lineN), vis = visualLine(line)
811
+ if (line == vis) { return lineN }
812
+ return lineNo(vis)
813
+ }
814
+
815
+ // Get the line number of the start of the next visual line after
816
+ // the given line.
817
+ function visualLineEndNo(doc, lineN) {
818
+ if (lineN > doc.lastLine()) { return lineN }
819
+ var line = getLine(doc, lineN), merged
820
+ if (!lineIsHidden(doc, line)) { return lineN }
821
+ while (merged = collapsedSpanAtEnd(line))
822
+ { line = merged.find(1, true).line }
823
+ return lineNo(line) + 1
824
+ }
825
+
826
+ // Compute whether a line is hidden. Lines count as hidden when they
827
+ // are part of a visual line that starts with another line, or when
828
+ // they are entirely covered by collapsed, non-widget span.
829
+ function lineIsHidden(doc, line) {
830
+ var sps = sawCollapsedSpans && line.markedSpans
831
+ if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
832
+ sp = sps[i]
833
+ if (!sp.marker.collapsed) { continue }
834
+ if (sp.from == null) { return true }
835
+ if (sp.marker.widgetNode) { continue }
836
+ if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
837
+ { return true }
838
+ } }
839
+ }
840
+ function lineIsHiddenInner(doc, line, span) {
841
+ if (span.to == null) {
842
+ var end = span.marker.find(1, true)
843
+ return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))
844
+ }
845
+ if (span.marker.inclusiveRight && span.to == line.text.length)
846
+ { return true }
847
+ for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {
848
+ sp = line.markedSpans[i]
849
+ if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
850
+ (sp.to == null || sp.to != span.from) &&
851
+ (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
852
+ lineIsHiddenInner(doc, line, sp)) { return true }
853
+ }
854
+ }
855
+
856
+ // Find the height above the given line.
857
+ function heightAtLine(lineObj) {
858
+ lineObj = visualLine(lineObj)
859
+
860
+ var h = 0, chunk = lineObj.parent
861
+ for (var i = 0; i < chunk.lines.length; ++i) {
862
+ var line = chunk.lines[i]
863
+ if (line == lineObj) { break }
864
+ else { h += line.height }
865
+ }
866
+ for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {
867
+ for (var i$1 = 0; i$1 < p.children.length; ++i$1) {
868
+ var cur = p.children[i$1]
869
+ if (cur == chunk) { break }
870
+ else { h += cur.height }
871
+ }
872
+ }
873
+ return h
874
+ }
875
+
876
+ // Compute the character length of a line, taking into account
877
+ // collapsed ranges (see markText) that might hide parts, and join
878
+ // other lines onto it.
879
+ function lineLength(line) {
880
+ if (line.height == 0) { return 0 }
881
+ var len = line.text.length, merged, cur = line
882
+ while (merged = collapsedSpanAtStart(cur)) {
883
+ var found = merged.find(0, true)
884
+ cur = found.from.line
885
+ len += found.from.ch - found.to.ch
886
+ }
887
+ cur = line
888
+ while (merged = collapsedSpanAtEnd(cur)) {
889
+ var found$1 = merged.find(0, true)
890
+ len -= cur.text.length - found$1.from.ch
891
+ cur = found$1.to.line
892
+ len += cur.text.length - found$1.to.ch
893
+ }
894
+ return len
895
+ }
896
+
897
+ // Find the longest line in the document.
898
+ function findMaxLine(cm) {
899
+ var d = cm.display, doc = cm.doc
900
+ d.maxLine = getLine(doc, doc.first)
901
+ d.maxLineLength = lineLength(d.maxLine)
902
+ d.maxLineChanged = true
903
+ doc.iter(function (line) {
904
+ var len = lineLength(line)
905
+ if (len > d.maxLineLength) {
906
+ d.maxLineLength = len
907
+ d.maxLine = line
908
+ }
909
+ })
910
+ }
911
+
912
+ // BIDI HELPERS
913
+
914
+ function iterateBidiSections(order, from, to, f) {
915
+ if (!order) { return f(from, to, "ltr", 0) }
916
+ var found = false
917
+ for (var i = 0; i < order.length; ++i) {
918
+ var part = order[i]
919
+ if (part.from < to && part.to > from || from == to && part.to == from) {
920
+ f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr", i)
921
+ found = true
922
+ }
923
+ }
924
+ if (!found) { f(from, to, "ltr") }
925
+ }
926
+
927
+ var bidiOther = null
928
+ function getBidiPartAt(order, ch, sticky) {
929
+ var found
930
+ bidiOther = null
931
+ for (var i = 0; i < order.length; ++i) {
932
+ var cur = order[i]
933
+ if (cur.from < ch && cur.to > ch) { return i }
934
+ if (cur.to == ch) {
935
+ if (cur.from != cur.to && sticky == "before") { found = i }
936
+ else { bidiOther = i }
937
+ }
938
+ if (cur.from == ch) {
939
+ if (cur.from != cur.to && sticky != "before") { found = i }
940
+ else { bidiOther = i }
941
+ }
942
+ }
943
+ return found != null ? found : bidiOther
944
+ }
945
+
946
+ // Bidirectional ordering algorithm
947
+ // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
948
+ // that this (partially) implements.
949
+
950
+ // One-char codes used for character types:
951
+ // L (L): Left-to-Right
952
+ // R (R): Right-to-Left
953
+ // r (AL): Right-to-Left Arabic
954
+ // 1 (EN): European Number
955
+ // + (ES): European Number Separator
956
+ // % (ET): European Number Terminator
957
+ // n (AN): Arabic Number
958
+ // , (CS): Common Number Separator
959
+ // m (NSM): Non-Spacing Mark
960
+ // b (BN): Boundary Neutral
961
+ // s (B): Paragraph Separator
962
+ // t (S): Segment Separator
963
+ // w (WS): Whitespace
964
+ // N (ON): Other Neutrals
965
+
966
+ // Returns null if characters are ordered as they appear
967
+ // (left-to-right), or an array of sections ({from, to, level}
968
+ // objects) in the order in which they occur visually.
969
+ var bidiOrdering = (function() {
970
+ // Character types for codepoints 0 to 0xff
971
+ var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN"
972
+ // Character types for codepoints 0x600 to 0x6f9
973
+ var arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111"
974
+ function charType(code) {
975
+ if (code <= 0xf7) { return lowTypes.charAt(code) }
976
+ else if (0x590 <= code && code <= 0x5f4) { return "R" }
977
+ else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }
978
+ else if (0x6ee <= code && code <= 0x8ac) { return "r" }
979
+ else if (0x2000 <= code && code <= 0x200b) { return "w" }
980
+ else if (code == 0x200c) { return "b" }
981
+ else { return "L" }
982
+ }
983
+
984
+ var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/
985
+ var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/
986
+
987
+ function BidiSpan(level, from, to) {
988
+ this.level = level
989
+ this.from = from; this.to = to
990
+ }
991
+
992
+ return function(str, direction) {
993
+ var outerType = direction == "ltr" ? "L" : "R"
994
+
995
+ if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) { return false }
996
+ var len = str.length, types = []
997
+ for (var i = 0; i < len; ++i)
998
+ { types.push(charType(str.charCodeAt(i))) }
999
+
1000
+ // W1. Examine each non-spacing mark (NSM) in the level run, and
1001
+ // change the type of the NSM to the type of the previous
1002
+ // character. If the NSM is at the start of the level run, it will
1003
+ // get the type of sor.
1004
+ for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {
1005
+ var type = types[i$1]
1006
+ if (type == "m") { types[i$1] = prev }
1007
+ else { prev = type }
1008
+ }
1009
+
1010
+ // W2. Search backwards from each instance of a European number
1011
+ // until the first strong type (R, L, AL, or sor) is found. If an
1012
+ // AL is found, change the type of the European number to Arabic
1013
+ // number.
1014
+ // W3. Change all ALs to R.
1015
+ for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {
1016
+ var type$1 = types[i$2]
1017
+ if (type$1 == "1" && cur == "r") { types[i$2] = "n" }
1018
+ else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R" } }
1019
+ }
1020
+
1021
+ // W4. A single European separator between two European numbers
1022
+ // changes to a European number. A single common separator between
1023
+ // two numbers of the same type changes to that type.
1024
+ for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
1025
+ var type$2 = types[i$3]
1026
+ if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1" }
1027
+ else if (type$2 == "," && prev$1 == types[i$3+1] &&
1028
+ (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1 }
1029
+ prev$1 = type$2
1030
+ }
1031
+
1032
+ // W5. A sequence of European terminators adjacent to European
1033
+ // numbers changes to all European numbers.
1034
+ // W6. Otherwise, separators and terminators change to Other
1035
+ // Neutral.
1036
+ for (var i$4 = 0; i$4 < len; ++i$4) {
1037
+ var type$3 = types[i$4]
1038
+ if (type$3 == ",") { types[i$4] = "N" }
1039
+ else if (type$3 == "%") {
1040
+ var end = (void 0)
1041
+ for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {}
1042
+ var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N"
1043
+ for (var j = i$4; j < end; ++j) { types[j] = replace }
1044
+ i$4 = end - 1
1045
+ }
1046
+ }
1047
+
1048
+ // W7. Search backwards from each instance of a European number
1049
+ // until the first strong type (R, L, or sor) is found. If an L is
1050
+ // found, then change the type of the European number to L.
1051
+ for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
1052
+ var type$4 = types[i$5]
1053
+ if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L" }
1054
+ else if (isStrong.test(type$4)) { cur$1 = type$4 }
1055
+ }
1056
+
1057
+ // N1. A sequence of neutrals takes the direction of the
1058
+ // surrounding strong text if the text on both sides has the same
1059
+ // direction. European and Arabic numbers act as if they were R in
1060
+ // terms of their influence on neutrals. Start-of-level-run (sor)
1061
+ // and end-of-level-run (eor) are used at level run boundaries.
1062
+ // N2. Any remaining neutrals take the embedding direction.
1063
+ for (var i$6 = 0; i$6 < len; ++i$6) {
1064
+ if (isNeutral.test(types[i$6])) {
1065
+ var end$1 = (void 0)
1066
+ for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}
1067
+ var before = (i$6 ? types[i$6-1] : outerType) == "L"
1068
+ var after = (end$1 < len ? types[end$1] : outerType) == "L"
1069
+ var replace$1 = before == after ? (before ? "L" : "R") : outerType
1070
+ for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1 }
1071
+ i$6 = end$1 - 1
1072
+ }
1073
+ }
1074
+
1075
+ // Here we depart from the documented algorithm, in order to avoid
1076
+ // building up an actual levels array. Since there are only three
1077
+ // levels (0, 1, 2) in an implementation that doesn't take
1078
+ // explicit embedding into account, we can build up the order on
1079
+ // the fly, without following the level-based algorithm.
1080
+ var order = [], m
1081
+ for (var i$7 = 0; i$7 < len;) {
1082
+ if (countsAsLeft.test(types[i$7])) {
1083
+ var start = i$7
1084
+ for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}
1085
+ order.push(new BidiSpan(0, start, i$7))
1086
+ } else {
1087
+ var pos = i$7, at = order.length
1088
+ for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}
1089
+ for (var j$2 = pos; j$2 < i$7;) {
1090
+ if (countsAsNum.test(types[j$2])) {
1091
+ if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)) }
1092
+ var nstart = j$2
1093
+ for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}
1094
+ order.splice(at, 0, new BidiSpan(2, nstart, j$2))
1095
+ pos = j$2
1096
+ } else { ++j$2 }
1097
+ }
1098
+ if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)) }
1099
+ }
1100
+ }
1101
+ if (direction == "ltr") {
1102
+ if (order[0].level == 1 && (m = str.match(/^\s+/))) {
1103
+ order[0].from = m[0].length
1104
+ order.unshift(new BidiSpan(0, 0, m[0].length))
1105
+ }
1106
+ if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
1107
+ lst(order).to -= m[0].length
1108
+ order.push(new BidiSpan(0, len - m[0].length, len))
1109
+ }
1110
+ }
1111
+
1112
+ return direction == "rtl" ? order.reverse() : order
1113
+ }
1114
+ })()
1115
+
1116
+ // Get the bidi ordering for the given line (and cache it). Returns
1117
+ // false for lines that are fully left-to-right, and an array of
1118
+ // BidiSpan objects otherwise.
1119
+ function getOrder(line, direction) {
1120
+ var order = line.order
1121
+ if (order == null) { order = line.order = bidiOrdering(line.text, direction) }
1122
+ return order
1123
+ }
1124
+
1125
+ // EVENT HANDLING
1126
+
1127
+ // Lightweight event framework. on/off also work on DOM nodes,
1128
+ // registering native DOM handlers.
1129
+
1130
+ var noHandlers = []
1131
+
1132
+ var on = function(emitter, type, f) {
1133
+ if (emitter.addEventListener) {
1134
+ emitter.addEventListener(type, f, false)
1135
+ } else if (emitter.attachEvent) {
1136
+ emitter.attachEvent("on" + type, f)
1137
+ } else {
1138
+ var map = emitter._handlers || (emitter._handlers = {})
1139
+ map[type] = (map[type] || noHandlers).concat(f)
1140
+ }
1141
+ }
1142
+
1143
+ function getHandlers(emitter, type) {
1144
+ return emitter._handlers && emitter._handlers[type] || noHandlers
1145
+ }
1146
+
1147
+ function off(emitter, type, f) {
1148
+ if (emitter.removeEventListener) {
1149
+ emitter.removeEventListener(type, f, false)
1150
+ } else if (emitter.detachEvent) {
1151
+ emitter.detachEvent("on" + type, f)
1152
+ } else {
1153
+ var map = emitter._handlers, arr = map && map[type]
1154
+ if (arr) {
1155
+ var index = indexOf(arr, f)
1156
+ if (index > -1)
1157
+ { map[type] = arr.slice(0, index).concat(arr.slice(index + 1)) }
1158
+ }
1159
+ }
1160
+ }
1161
+
1162
+ function signal(emitter, type /*, values...*/) {
1163
+ var handlers = getHandlers(emitter, type)
1164
+ if (!handlers.length) { return }
1165
+ var args = Array.prototype.slice.call(arguments, 2)
1166
+ for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args) }
1167
+ }
1168
+
1169
+ // The DOM events that CodeMirror handles can be overridden by
1170
+ // registering a (non-DOM) handler on the editor for the event name,
1171
+ // and preventDefault-ing the event in that handler.
1172
+ function signalDOMEvent(cm, e, override) {
1173
+ if (typeof e == "string")
1174
+ { e = {type: e, preventDefault: function() { this.defaultPrevented = true }} }
1175
+ signal(cm, override || e.type, cm, e)
1176
+ return e_defaultPrevented(e) || e.codemirrorIgnore
1177
+ }
1178
+
1179
+ function signalCursorActivity(cm) {
1180
+ var arr = cm._handlers && cm._handlers.cursorActivity
1181
+ if (!arr) { return }
1182
+ var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = [])
1183
+ for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)
1184
+ { set.push(arr[i]) } }
1185
+ }
1186
+
1187
+ function hasHandler(emitter, type) {
1188
+ return getHandlers(emitter, type).length > 0
1189
+ }
1190
+
1191
+ // Add on and off methods to a constructor's prototype, to make
1192
+ // registering events on such objects more convenient.
1193
+ function eventMixin(ctor) {
1194
+ ctor.prototype.on = function(type, f) {on(this, type, f)}
1195
+ ctor.prototype.off = function(type, f) {off(this, type, f)}
1196
+ }
1197
+
1198
+ // Due to the fact that we still support jurassic IE versions, some
1199
+ // compatibility wrappers are needed.
1200
+
1201
+ function e_preventDefault(e) {
1202
+ if (e.preventDefault) { e.preventDefault() }
1203
+ else { e.returnValue = false }
1204
+ }
1205
+ function e_stopPropagation(e) {
1206
+ if (e.stopPropagation) { e.stopPropagation() }
1207
+ else { e.cancelBubble = true }
1208
+ }
1209
+ function e_defaultPrevented(e) {
1210
+ return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false
1211
+ }
1212
+ function e_stop(e) {e_preventDefault(e); e_stopPropagation(e)}
1213
+
1214
+ function e_target(e) {return e.target || e.srcElement}
1215
+ function e_button(e) {
1216
+ var b = e.which
1217
+ if (b == null) {
1218
+ if (e.button & 1) { b = 1 }
1219
+ else if (e.button & 2) { b = 3 }
1220
+ else if (e.button & 4) { b = 2 }
1221
+ }
1222
+ if (mac && e.ctrlKey && b == 1) { b = 3 }
1223
+ return b
1224
+ }
1225
+
1226
+ // Detect drag-and-drop
1227
+ var dragAndDrop = function() {
1228
+ // There is *some* kind of drag-and-drop support in IE6-8, but I
1229
+ // couldn't get it to work yet.
1230
+ if (ie && ie_version < 9) { return false }
1231
+ var div = elt('div')
1232
+ return "draggable" in div || "dragDrop" in div
1233
+ }()
1234
+
1235
+ var zwspSupported
1236
+ function zeroWidthElement(measure) {
1237
+ if (zwspSupported == null) {
1238
+ var test = elt("span", "\u200b")
1239
+ removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]))
1240
+ if (measure.firstChild.offsetHeight != 0)
1241
+ { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8) }
1242
+ }
1243
+ var node = zwspSupported ? elt("span", "\u200b") :
1244
+ elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px")
1245
+ node.setAttribute("cm-text", "")
1246
+ return node
1247
+ }
1248
+
1249
+ // Feature-detect IE's crummy client rect reporting for bidi text
1250
+ var badBidiRects
1251
+ function hasBadBidiRects(measure) {
1252
+ if (badBidiRects != null) { return badBidiRects }
1253
+ var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"))
1254
+ var r0 = range(txt, 0, 1).getBoundingClientRect()
1255
+ var r1 = range(txt, 1, 2).getBoundingClientRect()
1256
+ removeChildren(measure)
1257
+ if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)
1258
+ return badBidiRects = (r1.right - r0.right < 3)
1259
+ }
1260
+
1261
+ // See if "".split is the broken IE version, if so, provide an
1262
+ // alternative way to split lines.
1263
+ var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) {
1264
+ var pos = 0, result = [], l = string.length
1265
+ while (pos <= l) {
1266
+ var nl = string.indexOf("\n", pos)
1267
+ if (nl == -1) { nl = string.length }
1268
+ var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl)
1269
+ var rt = line.indexOf("\r")
1270
+ if (rt != -1) {
1271
+ result.push(line.slice(0, rt))
1272
+ pos += rt + 1
1273
+ } else {
1274
+ result.push(line)
1275
+ pos = nl + 1
1276
+ }
1277
+ }
1278
+ return result
1279
+ } : function (string) { return string.split(/\r\n?|\n/); }
1280
+
1281
+ var hasSelection = window.getSelection ? function (te) {
1282
+ try { return te.selectionStart != te.selectionEnd }
1283
+ catch(e) { return false }
1284
+ } : function (te) {
1285
+ var range
1286
+ try {range = te.ownerDocument.selection.createRange()}
1287
+ catch(e) {}
1288
+ if (!range || range.parentElement() != te) { return false }
1289
+ return range.compareEndPoints("StartToEnd", range) != 0
1290
+ }
1291
+
1292
+ var hasCopyEvent = (function () {
1293
+ var e = elt("div")
1294
+ if ("oncopy" in e) { return true }
1295
+ e.setAttribute("oncopy", "return;")
1296
+ return typeof e.oncopy == "function"
1297
+ })()
1298
+
1299
+ var badZoomedRects = null
1300
+ function hasBadZoomedRects(measure) {
1301
+ if (badZoomedRects != null) { return badZoomedRects }
1302
+ var node = removeChildrenAndAdd(measure, elt("span", "x"))
1303
+ var normal = node.getBoundingClientRect()
1304
+ var fromRange = range(node, 0, 1).getBoundingClientRect()
1305
+ return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1
1306
+ }
1307
+
1308
+ var modes = {};
1309
+ var mimeModes = {};
1310
+ // Extra arguments are stored as the mode's dependencies, which is
1311
+ // used by (legacy) mechanisms like loadmode.js to automatically
1312
+ // load a mode. (Preferred mechanism is the require/define calls.)
1313
+ function defineMode(name, mode) {
1314
+ if (arguments.length > 2)
1315
+ { mode.dependencies = Array.prototype.slice.call(arguments, 2) }
1316
+ modes[name] = mode
1317
+ }
1318
+
1319
+ function defineMIME(mime, spec) {
1320
+ mimeModes[mime] = spec
1321
+ }
1322
+
1323
+ // Given a MIME type, a {name, ...options} config object, or a name
1324
+ // string, return a mode config object.
1325
+ function resolveMode(spec) {
1326
+ if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
1327
+ spec = mimeModes[spec]
1328
+ } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
1329
+ var found = mimeModes[spec.name]
1330
+ if (typeof found == "string") { found = {name: found} }
1331
+ spec = createObj(found, spec)
1332
+ spec.name = found.name
1333
+ } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
1334
+ return resolveMode("application/xml")
1335
+ } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) {
1336
+ return resolveMode("application/json")
1337
+ }
1338
+ if (typeof spec == "string") { return {name: spec} }
1339
+ else { return spec || {name: "null"} }
1340
+ }
1341
+
1342
+ // Given a mode spec (anything that resolveMode accepts), find and
1343
+ // initialize an actual mode object.
1344
+ function getMode(options, spec) {
1345
+ spec = resolveMode(spec)
1346
+ var mfactory = modes[spec.name]
1347
+ if (!mfactory) { return getMode(options, "text/plain") }
1348
+ var modeObj = mfactory(options, spec)
1349
+ if (modeExtensions.hasOwnProperty(spec.name)) {
1350
+ var exts = modeExtensions[spec.name]
1351
+ for (var prop in exts) {
1352
+ if (!exts.hasOwnProperty(prop)) { continue }
1353
+ if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop] }
1354
+ modeObj[prop] = exts[prop]
1355
+ }
1356
+ }
1357
+ modeObj.name = spec.name
1358
+ if (spec.helperType) { modeObj.helperType = spec.helperType }
1359
+ if (spec.modeProps) { for (var prop$1 in spec.modeProps)
1360
+ { modeObj[prop$1] = spec.modeProps[prop$1] } }
1361
+
1362
+ return modeObj
1363
+ }
1364
+
1365
+ // This can be used to attach properties to mode objects from
1366
+ // outside the actual mode definition.
1367
+ var modeExtensions = {}
1368
+ function extendMode(mode, properties) {
1369
+ var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {})
1370
+ copyObj(properties, exts)
1371
+ }
1372
+
1373
+ function copyState(mode, state) {
1374
+ if (state === true) { return state }
1375
+ if (mode.copyState) { return mode.copyState(state) }
1376
+ var nstate = {}
1377
+ for (var n in state) {
1378
+ var val = state[n]
1379
+ if (val instanceof Array) { val = val.concat([]) }
1380
+ nstate[n] = val
1381
+ }
1382
+ return nstate
1383
+ }
1384
+
1385
+ // Given a mode and a state (for that mode), find the inner mode and
1386
+ // state at the position that the state refers to.
1387
+ function innerMode(mode, state) {
1388
+ var info
1389
+ while (mode.innerMode) {
1390
+ info = mode.innerMode(state)
1391
+ if (!info || info.mode == mode) { break }
1392
+ state = info.state
1393
+ mode = info.mode
1394
+ }
1395
+ return info || {mode: mode, state: state}
1396
+ }
1397
+
1398
+ function startState(mode, a1, a2) {
1399
+ return mode.startState ? mode.startState(a1, a2) : true
1400
+ }
1401
+
1402
+ // STRING STREAM
1403
+
1404
+ // Fed to the mode parsers, provides helper functions to make
1405
+ // parsers more succinct.
1406
+
1407
+ var StringStream = function(string, tabSize, lineOracle) {
1408
+ this.pos = this.start = 0
1409
+ this.string = string
1410
+ this.tabSize = tabSize || 8
1411
+ this.lastColumnPos = this.lastColumnValue = 0
1412
+ this.lineStart = 0
1413
+ this.lineOracle = lineOracle
1414
+ };
1415
+
1416
+ StringStream.prototype.eol = function () {return this.pos >= this.string.length};
1417
+ StringStream.prototype.sol = function () {return this.pos == this.lineStart};
1418
+ StringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined};
1419
+ StringStream.prototype.next = function () {
1420
+ if (this.pos < this.string.length)
1421
+ { return this.string.charAt(this.pos++) }
1422
+ };
1423
+ StringStream.prototype.eat = function (match) {
1424
+ var ch = this.string.charAt(this.pos)
1425
+ var ok
1426
+ if (typeof match == "string") { ok = ch == match }
1427
+ else { ok = ch && (match.test ? match.test(ch) : match(ch)) }
1428
+ if (ok) {++this.pos; return ch}
1429
+ };
1430
+ StringStream.prototype.eatWhile = function (match) {
1431
+ var start = this.pos
1432
+ while (this.eat(match)){}
1433
+ return this.pos > start
1434
+ };
1435
+ StringStream.prototype.eatSpace = function () {
1436
+ var this$1 = this;
1437
+
1438
+ var start = this.pos
1439
+ while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos }
1440
+ return this.pos > start
1441
+ };
1442
+ StringStream.prototype.skipToEnd = function () {this.pos = this.string.length};
1443
+ StringStream.prototype.skipTo = function (ch) {
1444
+ var found = this.string.indexOf(ch, this.pos)
1445
+ if (found > -1) {this.pos = found; return true}
1446
+ };
1447
+ StringStream.prototype.backUp = function (n) {this.pos -= n};
1448
+ StringStream.prototype.column = function () {
1449
+ if (this.lastColumnPos < this.start) {
1450
+ this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue)
1451
+ this.lastColumnPos = this.start
1452
+ }
1453
+ return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
1454
+ };
1455
+ StringStream.prototype.indentation = function () {
1456
+ return countColumn(this.string, null, this.tabSize) -
1457
+ (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
1458
+ };
1459
+ StringStream.prototype.match = function (pattern, consume, caseInsensitive) {
1460
+ if (typeof pattern == "string") {
1461
+ var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; }
1462
+ var substr = this.string.substr(this.pos, pattern.length)
1463
+ if (cased(substr) == cased(pattern)) {
1464
+ if (consume !== false) { this.pos += pattern.length }
1465
+ return true
1466
+ }
1467
+ } else {
1468
+ var match = this.string.slice(this.pos).match(pattern)
1469
+ if (match && match.index > 0) { return null }
1470
+ if (match && consume !== false) { this.pos += match[0].length }
1471
+ return match
1472
+ }
1473
+ };
1474
+ StringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)};
1475
+ StringStream.prototype.hideFirstChars = function (n, inner) {
1476
+ this.lineStart += n
1477
+ try { return inner() }
1478
+ finally { this.lineStart -= n }
1479
+ };
1480
+ StringStream.prototype.lookAhead = function (n) {
1481
+ var oracle = this.lineOracle
1482
+ return oracle && oracle.lookAhead(n)
1483
+ };
1484
+ StringStream.prototype.baseToken = function () {
1485
+ var oracle = this.lineOracle
1486
+ return oracle && oracle.baseToken(this.pos)
1487
+ };
1488
+
1489
+ var SavedContext = function(state, lookAhead) {
1490
+ this.state = state
1491
+ this.lookAhead = lookAhead
1492
+ };
1493
+
1494
+ var Context = function(doc, state, line, lookAhead) {
1495
+ this.state = state
1496
+ this.doc = doc
1497
+ this.line = line
1498
+ this.maxLookAhead = lookAhead || 0
1499
+ this.baseTokens = null
1500
+ this.baseTokenPos = 1
1501
+ };
1502
+
1503
+ Context.prototype.lookAhead = function (n) {
1504
+ var line = this.doc.getLine(this.line + n)
1505
+ if (line != null && n > this.maxLookAhead) { this.maxLookAhead = n }
1506
+ return line
1507
+ };
1508
+
1509
+ Context.prototype.baseToken = function (n) {
1510
+ var this$1 = this;
1511
+
1512
+ if (!this.baseTokens) { return null }
1513
+ while (this.baseTokens[this.baseTokenPos] <= n)
1514
+ { this$1.baseTokenPos += 2 }
1515
+ var type = this.baseTokens[this.baseTokenPos + 1]
1516
+ return {type: type && type.replace(/( |^)overlay .*/, ""),
1517
+ size: this.baseTokens[this.baseTokenPos] - n}
1518
+ };
1519
+
1520
+ Context.prototype.nextLine = function () {
1521
+ this.line++
1522
+ if (this.maxLookAhead > 0) { this.maxLookAhead-- }
1523
+ };
1524
+
1525
+ Context.fromSaved = function (doc, saved, line) {
1526
+ if (saved instanceof SavedContext)
1527
+ { return new Context(doc, copyState(doc.mode, saved.state), line, saved.lookAhead) }
1528
+ else
1529
+ { return new Context(doc, copyState(doc.mode, saved), line) }
1530
+ };
1531
+
1532
+ Context.prototype.save = function (copy) {
1533
+ var state = copy !== false ? copyState(this.doc.mode, this.state) : this.state
1534
+ return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state
1535
+ };
1536
+
1537
+
1538
+ // Compute a style array (an array starting with a mode generation
1539
+ // -- for invalidation -- followed by pairs of end positions and
1540
+ // style strings), which is used to highlight the tokens on the
1541
+ // line.
1542
+ function highlightLine(cm, line, context, forceToEnd) {
1543
+ // A styles array always starts with a number identifying the
1544
+ // mode/overlays that it is based on (for easy invalidation).
1545
+ var st = [cm.state.modeGen], lineClasses = {}
1546
+ // Compute the base array of styles
1547
+ runMode(cm, line.text, cm.doc.mode, context, function (end, style) { return st.push(end, style); },
1548
+ lineClasses, forceToEnd)
1549
+ var state = context.state
1550
+
1551
+ // Run overlays, adjust style array.
1552
+ var loop = function ( o ) {
1553
+ context.baseTokens = st
1554
+ var overlay = cm.state.overlays[o], i = 1, at = 0
1555
+ context.state = true
1556
+ runMode(cm, line.text, overlay.mode, context, function (end, style) {
1557
+ var start = i
1558
+ // Ensure there's a token end at the current position, and that i points at it
1559
+ while (at < end) {
1560
+ var i_end = st[i]
1561
+ if (i_end > end)
1562
+ { st.splice(i, 1, end, st[i+1], i_end) }
1563
+ i += 2
1564
+ at = Math.min(end, i_end)
1565
+ }
1566
+ if (!style) { return }
1567
+ if (overlay.opaque) {
1568
+ st.splice(start, i - start, end, "overlay " + style)
1569
+ i = start + 2
1570
+ } else {
1571
+ for (; start < i; start += 2) {
1572
+ var cur = st[start+1]
1573
+ st[start+1] = (cur ? cur + " " : "") + "overlay " + style
1574
+ }
1575
+ }
1576
+ }, lineClasses)
1577
+ context.state = state
1578
+ context.baseTokens = null
1579
+ context.baseTokenPos = 1
1580
+ };
1581
+
1582
+ for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );
1583
+
1584
+ return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}
1585
+ }
1586
+
1587
+ function getLineStyles(cm, line, updateFrontier) {
1588
+ if (!line.styles || line.styles[0] != cm.state.modeGen) {
1589
+ var context = getContextBefore(cm, lineNo(line))
1590
+ var resetState = line.text.length > cm.options.maxHighlightLength && copyState(cm.doc.mode, context.state)
1591
+ var result = highlightLine(cm, line, context)
1592
+ if (resetState) { context.state = resetState }
1593
+ line.stateAfter = context.save(!resetState)
1594
+ line.styles = result.styles
1595
+ if (result.classes) { line.styleClasses = result.classes }
1596
+ else if (line.styleClasses) { line.styleClasses = null }
1597
+ if (updateFrontier === cm.doc.highlightFrontier)
1598
+ { cm.doc.modeFrontier = Math.max(cm.doc.modeFrontier, ++cm.doc.highlightFrontier) }
1599
+ }
1600
+ return line.styles
1601
+ }
1602
+
1603
+ function getContextBefore(cm, n, precise) {
1604
+ var doc = cm.doc, display = cm.display
1605
+ if (!doc.mode.startState) { return new Context(doc, true, n) }
1606
+ var start = findStartLine(cm, n, precise)
1607
+ var saved = start > doc.first && getLine(doc, start - 1).stateAfter
1608
+ var context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start)
1609
+
1610
+ doc.iter(start, n, function (line) {
1611
+ processLine(cm, line.text, context)
1612
+ var pos = context.line
1613
+ line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null
1614
+ context.nextLine()
1615
+ })
1616
+ if (precise) { doc.modeFrontier = context.line }
1617
+ return context
1618
+ }
1619
+
1620
+ // Lightweight form of highlight -- proceed over this line and
1621
+ // update state, but don't save a style array. Used for lines that
1622
+ // aren't currently visible.
1623
+ function processLine(cm, text, context, startAt) {
1624
+ var mode = cm.doc.mode
1625
+ var stream = new StringStream(text, cm.options.tabSize, context)
1626
+ stream.start = stream.pos = startAt || 0
1627
+ if (text == "") { callBlankLine(mode, context.state) }
1628
+ while (!stream.eol()) {
1629
+ readToken(mode, stream, context.state)
1630
+ stream.start = stream.pos
1631
+ }
1632
+ }
1633
+
1634
+ function callBlankLine(mode, state) {
1635
+ if (mode.blankLine) { return mode.blankLine(state) }
1636
+ if (!mode.innerMode) { return }
1637
+ var inner = innerMode(mode, state)
1638
+ if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }
1639
+ }
1640
+
1641
+ function readToken(mode, stream, state, inner) {
1642
+ for (var i = 0; i < 10; i++) {
1643
+ if (inner) { inner[0] = innerMode(mode, state).mode }
1644
+ var style = mode.token(stream, state)
1645
+ if (stream.pos > stream.start) { return style }
1646
+ }
1647
+ throw new Error("Mode " + mode.name + " failed to advance stream.")
1648
+ }
1649
+
1650
+ var Token = function(stream, type, state) {
1651
+ this.start = stream.start; this.end = stream.pos
1652
+ this.string = stream.current()
1653
+ this.type = type || null
1654
+ this.state = state
1655
+ };
1656
+
1657
+ // Utility for getTokenAt and getLineTokens
1658
+ function takeToken(cm, pos, precise, asArray) {
1659
+ var doc = cm.doc, mode = doc.mode, style
1660
+ pos = clipPos(doc, pos)
1661
+ var line = getLine(doc, pos.line), context = getContextBefore(cm, pos.line, precise)
1662
+ var stream = new StringStream(line.text, cm.options.tabSize, context), tokens
1663
+ if (asArray) { tokens = [] }
1664
+ while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
1665
+ stream.start = stream.pos
1666
+ style = readToken(mode, stream, context.state)
1667
+ if (asArray) { tokens.push(new Token(stream, style, copyState(doc.mode, context.state))) }
1668
+ }
1669
+ return asArray ? tokens : new Token(stream, style, context.state)
1670
+ }
1671
+
1672
+ function extractLineClasses(type, output) {
1673
+ if (type) { for (;;) {
1674
+ var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/)
1675
+ if (!lineClass) { break }
1676
+ type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length)
1677
+ var prop = lineClass[1] ? "bgClass" : "textClass"
1678
+ if (output[prop] == null)
1679
+ { output[prop] = lineClass[2] }
1680
+ else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
1681
+ { output[prop] += " " + lineClass[2] }
1682
+ } }
1683
+ return type
1684
+ }
1685
+
1686
+ // Run the given mode's parser over a line, calling f for each token.
1687
+ function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) {
1688
+ var flattenSpans = mode.flattenSpans
1689
+ if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans }
1690
+ var curStart = 0, curStyle = null
1691
+ var stream = new StringStream(text, cm.options.tabSize, context), style
1692
+ var inner = cm.options.addModeClass && [null]
1693
+ if (text == "") { extractLineClasses(callBlankLine(mode, context.state), lineClasses) }
1694
+ while (!stream.eol()) {
1695
+ if (stream.pos > cm.options.maxHighlightLength) {
1696
+ flattenSpans = false
1697
+ if (forceToEnd) { processLine(cm, text, context, stream.pos) }
1698
+ stream.pos = text.length
1699
+ style = null
1700
+ } else {
1701
+ style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses)
1702
+ }
1703
+ if (inner) {
1704
+ var mName = inner[0].name
1705
+ if (mName) { style = "m-" + (style ? mName + " " + style : mName) }
1706
+ }
1707
+ if (!flattenSpans || curStyle != style) {
1708
+ while (curStart < stream.start) {
1709
+ curStart = Math.min(stream.start, curStart + 5000)
1710
+ f(curStart, curStyle)
1711
+ }
1712
+ curStyle = style
1713
+ }
1714
+ stream.start = stream.pos
1715
+ }
1716
+ while (curStart < stream.pos) {
1717
+ // Webkit seems to refuse to render text nodes longer than 57444
1718
+ // characters, and returns inaccurate measurements in nodes
1719
+ // starting around 5000 chars.
1720
+ var pos = Math.min(stream.pos, curStart + 5000)
1721
+ f(pos, curStyle)
1722
+ curStart = pos
1723
+ }
1724
+ }
1725
+
1726
+ // Finds the line to start with when starting a parse. Tries to
1727
+ // find a line with a stateAfter, so that it can start with a
1728
+ // valid state. If that fails, it returns the line with the
1729
+ // smallest indentation, which tends to need the least context to
1730
+ // parse correctly.
1731
+ function findStartLine(cm, n, precise) {
1732
+ var minindent, minline, doc = cm.doc
1733
+ var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100)
1734
+ for (var search = n; search > lim; --search) {
1735
+ if (search <= doc.first) { return doc.first }
1736
+ var line = getLine(doc, search - 1), after = line.stateAfter
1737
+ if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier))
1738
+ { return search }
1739
+ var indented = countColumn(line.text, null, cm.options.tabSize)
1740
+ if (minline == null || minindent > indented) {
1741
+ minline = search - 1
1742
+ minindent = indented
1743
+ }
1744
+ }
1745
+ return minline
1746
+ }
1747
+
1748
+ function retreatFrontier(doc, n) {
1749
+ doc.modeFrontier = Math.min(doc.modeFrontier, n)
1750
+ if (doc.highlightFrontier < n - 10) { return }
1751
+ var start = doc.first
1752
+ for (var line = n - 1; line > start; line--) {
1753
+ var saved = getLine(doc, line).stateAfter
1754
+ // change is on 3
1755
+ // state on line 1 looked ahead 2 -- so saw 3
1756
+ // test 1 + 2 < 3 should cover this
1757
+ if (saved && (!(saved instanceof SavedContext) || line + saved.lookAhead < n)) {
1758
+ start = line + 1
1759
+ break
1760
+ }
1761
+ }
1762
+ doc.highlightFrontier = Math.min(doc.highlightFrontier, start)
1763
+ }
1764
+
1765
+ // LINE DATA STRUCTURE
1766
+
1767
+ // Line objects. These hold state related to a line, including
1768
+ // highlighting info (the styles array).
1769
+ var Line = function(text, markedSpans, estimateHeight) {
1770
+ this.text = text
1771
+ attachMarkedSpans(this, markedSpans)
1772
+ this.height = estimateHeight ? estimateHeight(this) : 1
1773
+ };
1774
+
1775
+ Line.prototype.lineNo = function () { return lineNo(this) };
1776
+ eventMixin(Line)
1777
+
1778
+ // Change the content (text, markers) of a line. Automatically
1779
+ // invalidates cached information and tries to re-estimate the
1780
+ // line's height.
1781
+ function updateLine(line, text, markedSpans, estimateHeight) {
1782
+ line.text = text
1783
+ if (line.stateAfter) { line.stateAfter = null }
1784
+ if (line.styles) { line.styles = null }
1785
+ if (line.order != null) { line.order = null }
1786
+ detachMarkedSpans(line)
1787
+ attachMarkedSpans(line, markedSpans)
1788
+ var estHeight = estimateHeight ? estimateHeight(line) : 1
1789
+ if (estHeight != line.height) { updateLineHeight(line, estHeight) }
1790
+ }
1791
+
1792
+ // Detach a line from the document tree and its markers.
1793
+ function cleanUpLine(line) {
1794
+ line.parent = null
1795
+ detachMarkedSpans(line)
1796
+ }
1797
+
1798
+ // Convert a style as returned by a mode (either null, or a string
1799
+ // containing one or more styles) to a CSS style. This is cached,
1800
+ // and also looks for line-wide styles.
1801
+ var styleToClassCache = {};
1802
+ var styleToClassCacheWithMode = {};
1803
+ function interpretTokenStyle(style, options) {
1804
+ if (!style || /^\s*$/.test(style)) { return null }
1805
+ var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache
1806
+ return cache[style] ||
1807
+ (cache[style] = style.replace(/\S+/g, "cm-$&"))
1808
+ }
1809
+
1810
+ // Render the DOM representation of the text of a line. Also builds
1811
+ // up a 'line map', which points at the DOM nodes that represent
1812
+ // specific stretches of text, and is used by the measuring code.
1813
+ // The returned object contains the DOM node, this map, and
1814
+ // information about line-wide styles that were set by the mode.
1815
+ function buildLineContent(cm, lineView) {
1816
+ // The padding-right forces the element to have a 'border', which
1817
+ // is needed on Webkit to be able to get line-level bounding
1818
+ // rectangles for it (in measureChar).
1819
+ var content = eltP("span", null, null, webkit ? "padding-right: .1px" : null)
1820
+ var builder = {pre: eltP("pre", [content], "CodeMirror-line"), content: content,
1821
+ col: 0, pos: 0, cm: cm,
1822
+ trailingSpace: false,
1823
+ splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")}
1824
+ lineView.measure = {}
1825
+
1826
+ // Iterate over the logical lines that make up this visual line.
1827
+ for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
1828
+ var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0)
1829
+ builder.pos = 0
1830
+ builder.addToken = buildToken
1831
+ // Optionally wire in some hacks into the token-rendering
1832
+ // algorithm, to deal with browser quirks.
1833
+ if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction)))
1834
+ { builder.addToken = buildTokenBadBidi(builder.addToken, order) }
1835
+ builder.map = []
1836
+ var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line)
1837
+ insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate))
1838
+ if (line.styleClasses) {
1839
+ if (line.styleClasses.bgClass)
1840
+ { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "") }
1841
+ if (line.styleClasses.textClass)
1842
+ { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "") }
1843
+ }
1844
+
1845
+ // Ensure at least a single node is present, for measuring.
1846
+ if (builder.map.length == 0)
1847
+ { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))) }
1848
+
1849
+ // Store the map and a cache object for the current logical line
1850
+ if (i == 0) {
1851
+ lineView.measure.map = builder.map
1852
+ lineView.measure.cache = {}
1853
+ } else {
1854
+ ;(lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)
1855
+ ;(lineView.measure.caches || (lineView.measure.caches = [])).push({})
1856
+ }
1857
+ }
1858
+
1859
+ // See issue #2901
1860
+ if (webkit) {
1861
+ var last = builder.content.lastChild
1862
+ if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab")))
1863
+ { builder.content.className = "cm-tab-wrap-hack" }
1864
+ }
1865
+
1866
+ signal(cm, "renderLine", cm, lineView.line, builder.pre)
1867
+ if (builder.pre.className)
1868
+ { builder.textClass = joinClasses(builder.pre.className, builder.textClass || "") }
1869
+
1870
+ return builder
1871
+ }
1872
+
1873
+ function defaultSpecialCharPlaceholder(ch) {
1874
+ var token = elt("span", "\u2022", "cm-invalidchar")
1875
+ token.title = "\\u" + ch.charCodeAt(0).toString(16)
1876
+ token.setAttribute("aria-label", token.title)
1877
+ return token
1878
+ }
1879
+
1880
+ // Build up the DOM representation for a single token, and add it to
1881
+ // the line map. Takes care to render special characters separately.
1882
+ function buildToken(builder, text, style, startStyle, endStyle, title, css) {
1883
+ if (!text) { return }
1884
+ var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text
1885
+ var special = builder.cm.state.specialChars, mustWrap = false
1886
+ var content
1887
+ if (!special.test(text)) {
1888
+ builder.col += text.length
1889
+ content = document.createTextNode(displayText)
1890
+ builder.map.push(builder.pos, builder.pos + text.length, content)
1891
+ if (ie && ie_version < 9) { mustWrap = true }
1892
+ builder.pos += text.length
1893
+ } else {
1894
+ content = document.createDocumentFragment()
1895
+ var pos = 0
1896
+ while (true) {
1897
+ special.lastIndex = pos
1898
+ var m = special.exec(text)
1899
+ var skipped = m ? m.index - pos : text.length - pos
1900
+ if (skipped) {
1901
+ var txt = document.createTextNode(displayText.slice(pos, pos + skipped))
1902
+ if (ie && ie_version < 9) { content.appendChild(elt("span", [txt])) }
1903
+ else { content.appendChild(txt) }
1904
+ builder.map.push(builder.pos, builder.pos + skipped, txt)
1905
+ builder.col += skipped
1906
+ builder.pos += skipped
1907
+ }
1908
+ if (!m) { break }
1909
+ pos += skipped + 1
1910
+ var txt$1 = (void 0)
1911
+ if (m[0] == "\t") {
1912
+ var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize
1913
+ txt$1 = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"))
1914
+ txt$1.setAttribute("role", "presentation")
1915
+ txt$1.setAttribute("cm-text", "\t")
1916
+ builder.col += tabWidth
1917
+ } else if (m[0] == "\r" || m[0] == "\n") {
1918
+ txt$1 = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar"))
1919
+ txt$1.setAttribute("cm-text", m[0])
1920
+ builder.col += 1
1921
+ } else {
1922
+ txt$1 = builder.cm.options.specialCharPlaceholder(m[0])
1923
+ txt$1.setAttribute("cm-text", m[0])
1924
+ if (ie && ie_version < 9) { content.appendChild(elt("span", [txt$1])) }
1925
+ else { content.appendChild(txt$1) }
1926
+ builder.col += 1
1927
+ }
1928
+ builder.map.push(builder.pos, builder.pos + 1, txt$1)
1929
+ builder.pos++
1930
+ }
1931
+ }
1932
+ builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32
1933
+ if (style || startStyle || endStyle || mustWrap || css) {
1934
+ var fullStyle = style || ""
1935
+ if (startStyle) { fullStyle += startStyle }
1936
+ if (endStyle) { fullStyle += endStyle }
1937
+ var token = elt("span", [content], fullStyle, css)
1938
+ if (title) { token.title = title }
1939
+ return builder.content.appendChild(token)
1940
+ }
1941
+ builder.content.appendChild(content)
1942
+ }
1943
+
1944
+ function splitSpaces(text, trailingBefore) {
1945
+ if (text.length > 1 && !/ /.test(text)) { return text }
1946
+ var spaceBefore = trailingBefore, result = ""
1947
+ for (var i = 0; i < text.length; i++) {
1948
+ var ch = text.charAt(i)
1949
+ if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))
1950
+ { ch = "\u00a0" }
1951
+ result += ch
1952
+ spaceBefore = ch == " "
1953
+ }
1954
+ return result
1955
+ }
1956
+
1957
+ // Work around nonsense dimensions being reported for stretches of
1958
+ // right-to-left text.
1959
+ function buildTokenBadBidi(inner, order) {
1960
+ return function (builder, text, style, startStyle, endStyle, title, css) {
1961
+ style = style ? style + " cm-force-border" : "cm-force-border"
1962
+ var start = builder.pos, end = start + text.length
1963
+ for (;;) {
1964
+ // Find the part that overlaps with the start of this text
1965
+ var part = (void 0)
1966
+ for (var i = 0; i < order.length; i++) {
1967
+ part = order[i]
1968
+ if (part.to > start && part.from <= start) { break }
1969
+ }
1970
+ if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) }
1971
+ inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css)
1972
+ startStyle = null
1973
+ text = text.slice(part.to - start)
1974
+ start = part.to
1975
+ }
1976
+ }
1977
+ }
1978
+
1979
+ function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
1980
+ var widget = !ignoreWidget && marker.widgetNode
1981
+ if (widget) { builder.map.push(builder.pos, builder.pos + size, widget) }
1982
+ if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
1983
+ if (!widget)
1984
+ { widget = builder.content.appendChild(document.createElement("span")) }
1985
+ widget.setAttribute("cm-marker", marker.id)
1986
+ }
1987
+ if (widget) {
1988
+ builder.cm.display.input.setUneditable(widget)
1989
+ builder.content.appendChild(widget)
1990
+ }
1991
+ builder.pos += size
1992
+ builder.trailingSpace = false
1993
+ }
1994
+
1995
+ // Outputs a number of spans to make up a line, taking highlighting
1996
+ // and marked text into account.
1997
+ function insertLineContent(line, builder, styles) {
1998
+ var spans = line.markedSpans, allText = line.text, at = 0
1999
+ if (!spans) {
2000
+ for (var i$1 = 1; i$1 < styles.length; i$1+=2)
2001
+ { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)) }
2002
+ return
2003
+ }
2004
+
2005
+ var len = allText.length, pos = 0, i = 1, text = "", style, css
2006
+ var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed
2007
+ for (;;) {
2008
+ if (nextChange == pos) { // Update current marker set
2009
+ spanStyle = spanEndStyle = spanStartStyle = title = css = ""
2010
+ collapsed = null; nextChange = Infinity
2011
+ var foundBookmarks = [], endStyles = (void 0)
2012
+ for (var j = 0; j < spans.length; ++j) {
2013
+ var sp = spans[j], m = sp.marker
2014
+ if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
2015
+ foundBookmarks.push(m)
2016
+ } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {
2017
+ if (sp.to != null && sp.to != pos && nextChange > sp.to) {
2018
+ nextChange = sp.to
2019
+ spanEndStyle = ""
2020
+ }
2021
+ if (m.className) { spanStyle += " " + m.className }
2022
+ if (m.css) { css = (css ? css + ";" : "") + m.css }
2023
+ if (m.startStyle && sp.from == pos) { spanStartStyle += " " + m.startStyle }
2024
+ if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to) }
2025
+ if (m.title && !title) { title = m.title }
2026
+ if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
2027
+ { collapsed = sp }
2028
+ } else if (sp.from > pos && nextChange > sp.from) {
2029
+ nextChange = sp.from
2030
+ }
2031
+ }
2032
+ if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2)
2033
+ { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += " " + endStyles[j$1] } } }
2034
+
2035
+ if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)
2036
+ { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]) } }
2037
+ if (collapsed && (collapsed.from || 0) == pos) {
2038
+ buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
2039
+ collapsed.marker, collapsed.from == null)
2040
+ if (collapsed.to == null) { return }
2041
+ if (collapsed.to == pos) { collapsed = false }
2042
+ }
2043
+ }
2044
+ if (pos >= len) { break }
2045
+
2046
+ var upto = Math.min(len, nextChange)
2047
+ while (true) {
2048
+ if (text) {
2049
+ var end = pos + text.length
2050
+ if (!collapsed) {
2051
+ var tokenText = end > upto ? text.slice(0, upto - pos) : text
2052
+ builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
2053
+ spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css)
2054
+ }
2055
+ if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}
2056
+ pos = end
2057
+ spanStartStyle = ""
2058
+ }
2059
+ text = allText.slice(at, at = styles[i++])
2060
+ style = interpretTokenStyle(styles[i++], builder.cm.options)
2061
+ }
2062
+ }
2063
+ }
2064
+
2065
+
2066
+ // These objects are used to represent the visible (currently drawn)
2067
+ // part of the document. A LineView may correspond to multiple
2068
+ // logical lines, if those are connected by collapsed ranges.
2069
+ function LineView(doc, line, lineN) {
2070
+ // The starting line
2071
+ this.line = line
2072
+ // Continuing lines, if any
2073
+ this.rest = visualLineContinued(line)
2074
+ // Number of logical lines in this visual line
2075
+ this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1
2076
+ this.node = this.text = null
2077
+ this.hidden = lineIsHidden(doc, line)
2078
+ }
2079
+
2080
+ // Create a range of LineView objects for the given lines.
2081
+ function buildViewArray(cm, from, to) {
2082
+ var array = [], nextPos
2083
+ for (var pos = from; pos < to; pos = nextPos) {
2084
+ var view = new LineView(cm.doc, getLine(cm.doc, pos), pos)
2085
+ nextPos = pos + view.size
2086
+ array.push(view)
2087
+ }
2088
+ return array
2089
+ }
2090
+
2091
+ var operationGroup = null
2092
+
2093
+ function pushOperation(op) {
2094
+ if (operationGroup) {
2095
+ operationGroup.ops.push(op)
2096
+ } else {
2097
+ op.ownsGroup = operationGroup = {
2098
+ ops: [op],
2099
+ delayedCallbacks: []
2100
+ }
2101
+ }
2102
+ }
2103
+
2104
+ function fireCallbacksForOps(group) {
2105
+ // Calls delayed callbacks and cursorActivity handlers until no
2106
+ // new ones appear
2107
+ var callbacks = group.delayedCallbacks, i = 0
2108
+ do {
2109
+ for (; i < callbacks.length; i++)
2110
+ { callbacks[i].call(null) }
2111
+ for (var j = 0; j < group.ops.length; j++) {
2112
+ var op = group.ops[j]
2113
+ if (op.cursorActivityHandlers)
2114
+ { while (op.cursorActivityCalled < op.cursorActivityHandlers.length)
2115
+ { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm) } }
2116
+ }
2117
+ } while (i < callbacks.length)
2118
+ }
2119
+
2120
+ function finishOperation(op, endCb) {
2121
+ var group = op.ownsGroup
2122
+ if (!group) { return }
2123
+
2124
+ try { fireCallbacksForOps(group) }
2125
+ finally {
2126
+ operationGroup = null
2127
+ endCb(group)
2128
+ }
2129
+ }
2130
+
2131
+ var orphanDelayedCallbacks = null
2132
+
2133
+ // Often, we want to signal events at a point where we are in the
2134
+ // middle of some work, but don't want the handler to start calling
2135
+ // other methods on the editor, which might be in an inconsistent
2136
+ // state or simply not expect any other events to happen.
2137
+ // signalLater looks whether there are any handlers, and schedules
2138
+ // them to be executed when the last operation ends, or, if no
2139
+ // operation is active, when a timeout fires.
2140
+ function signalLater(emitter, type /*, values...*/) {
2141
+ var arr = getHandlers(emitter, type)
2142
+ if (!arr.length) { return }
2143
+ var args = Array.prototype.slice.call(arguments, 2), list
2144
+ if (operationGroup) {
2145
+ list = operationGroup.delayedCallbacks
2146
+ } else if (orphanDelayedCallbacks) {
2147
+ list = orphanDelayedCallbacks
2148
+ } else {
2149
+ list = orphanDelayedCallbacks = []
2150
+ setTimeout(fireOrphanDelayed, 0)
2151
+ }
2152
+ var loop = function ( i ) {
2153
+ list.push(function () { return arr[i].apply(null, args); })
2154
+ };
2155
+
2156
+ for (var i = 0; i < arr.length; ++i)
2157
+ loop( i );
2158
+ }
2159
+
2160
+ function fireOrphanDelayed() {
2161
+ var delayed = orphanDelayedCallbacks
2162
+ orphanDelayedCallbacks = null
2163
+ for (var i = 0; i < delayed.length; ++i) { delayed[i]() }
2164
+ }
2165
+
2166
+ // When an aspect of a line changes, a string is added to
2167
+ // lineView.changes. This updates the relevant part of the line's
2168
+ // DOM structure.
2169
+ function updateLineForChanges(cm, lineView, lineN, dims) {
2170
+ for (var j = 0; j < lineView.changes.length; j++) {
2171
+ var type = lineView.changes[j]
2172
+ if (type == "text") { updateLineText(cm, lineView) }
2173
+ else if (type == "gutter") { updateLineGutter(cm, lineView, lineN, dims) }
2174
+ else if (type == "class") { updateLineClasses(cm, lineView) }
2175
+ else if (type == "widget") { updateLineWidgets(cm, lineView, dims) }
2176
+ }
2177
+ lineView.changes = null
2178
+ }
2179
+
2180
+ // Lines with gutter elements, widgets or a background class need to
2181
+ // be wrapped, and have the extra elements added to the wrapper div
2182
+ function ensureLineWrapped(lineView) {
2183
+ if (lineView.node == lineView.text) {
2184
+ lineView.node = elt("div", null, null, "position: relative")
2185
+ if (lineView.text.parentNode)
2186
+ { lineView.text.parentNode.replaceChild(lineView.node, lineView.text) }
2187
+ lineView.node.appendChild(lineView.text)
2188
+ if (ie && ie_version < 8) { lineView.node.style.zIndex = 2 }
2189
+ }
2190
+ return lineView.node
2191
+ }
2192
+
2193
+ function updateLineBackground(cm, lineView) {
2194
+ var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass
2195
+ if (cls) { cls += " CodeMirror-linebackground" }
2196
+ if (lineView.background) {
2197
+ if (cls) { lineView.background.className = cls }
2198
+ else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null }
2199
+ } else if (cls) {
2200
+ var wrap = ensureLineWrapped(lineView)
2201
+ lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild)
2202
+ cm.display.input.setUneditable(lineView.background)
2203
+ }
2204
+ }
2205
+
2206
+ // Wrapper around buildLineContent which will reuse the structure
2207
+ // in display.externalMeasured when possible.
2208
+ function getLineContent(cm, lineView) {
2209
+ var ext = cm.display.externalMeasured
2210
+ if (ext && ext.line == lineView.line) {
2211
+ cm.display.externalMeasured = null
2212
+ lineView.measure = ext.measure
2213
+ return ext.built
2214
+ }
2215
+ return buildLineContent(cm, lineView)
2216
+ }
2217
+
2218
+ // Redraw the line's text. Interacts with the background and text
2219
+ // classes because the mode may output tokens that influence these
2220
+ // classes.
2221
+ function updateLineText(cm, lineView) {
2222
+ var cls = lineView.text.className
2223
+ var built = getLineContent(cm, lineView)
2224
+ if (lineView.text == lineView.node) { lineView.node = built.pre }
2225
+ lineView.text.parentNode.replaceChild(built.pre, lineView.text)
2226
+ lineView.text = built.pre
2227
+ if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
2228
+ lineView.bgClass = built.bgClass
2229
+ lineView.textClass = built.textClass
2230
+ updateLineClasses(cm, lineView)
2231
+ } else if (cls) {
2232
+ lineView.text.className = cls
2233
+ }
2234
+ }
2235
+
2236
+ function updateLineClasses(cm, lineView) {
2237
+ updateLineBackground(cm, lineView)
2238
+ if (lineView.line.wrapClass)
2239
+ { ensureLineWrapped(lineView).className = lineView.line.wrapClass }
2240
+ else if (lineView.node != lineView.text)
2241
+ { lineView.node.className = "" }
2242
+ var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass
2243
+ lineView.text.className = textClass || ""
2244
+ }
2245
+
2246
+ function updateLineGutter(cm, lineView, lineN, dims) {
2247
+ if (lineView.gutter) {
2248
+ lineView.node.removeChild(lineView.gutter)
2249
+ lineView.gutter = null
2250
+ }
2251
+ if (lineView.gutterBackground) {
2252
+ lineView.node.removeChild(lineView.gutterBackground)
2253
+ lineView.gutterBackground = null
2254
+ }
2255
+ if (lineView.line.gutterClass) {
2256
+ var wrap = ensureLineWrapped(lineView)
2257
+ lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass,
2258
+ ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px; width: " + (dims.gutterTotalWidth) + "px"))
2259
+ cm.display.input.setUneditable(lineView.gutterBackground)
2260
+ wrap.insertBefore(lineView.gutterBackground, lineView.text)
2261
+ }
2262
+ var markers = lineView.line.gutterMarkers
2263
+ if (cm.options.lineNumbers || markers) {
2264
+ var wrap$1 = ensureLineWrapped(lineView)
2265
+ var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px"))
2266
+ cm.display.input.setUneditable(gutterWrap)
2267
+ wrap$1.insertBefore(gutterWrap, lineView.text)
2268
+ if (lineView.line.gutterClass)
2269
+ { gutterWrap.className += " " + lineView.line.gutterClass }
2270
+ if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
2271
+ { lineView.lineNumber = gutterWrap.appendChild(
2272
+ elt("div", lineNumberFor(cm.options, lineN),
2273
+ "CodeMirror-linenumber CodeMirror-gutter-elt",
2274
+ ("left: " + (dims.gutterLeft["CodeMirror-linenumbers"]) + "px; width: " + (cm.display.lineNumInnerWidth) + "px"))) }
2275
+ if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) {
2276
+ var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]
2277
+ if (found)
2278
+ { gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt",
2279
+ ("left: " + (dims.gutterLeft[id]) + "px; width: " + (dims.gutterWidth[id]) + "px"))) }
2280
+ } }
2281
+ }
2282
+ }
2283
+
2284
+ function updateLineWidgets(cm, lineView, dims) {
2285
+ if (lineView.alignable) { lineView.alignable = null }
2286
+ for (var node = lineView.node.firstChild, next = (void 0); node; node = next) {
2287
+ next = node.nextSibling
2288
+ if (node.className == "CodeMirror-linewidget")
2289
+ { lineView.node.removeChild(node) }
2290
+ }
2291
+ insertLineWidgets(cm, lineView, dims)
2292
+ }
2293
+
2294
+ // Build a line's DOM representation from scratch
2295
+ function buildLineElement(cm, lineView, lineN, dims) {
2296
+ var built = getLineContent(cm, lineView)
2297
+ lineView.text = lineView.node = built.pre
2298
+ if (built.bgClass) { lineView.bgClass = built.bgClass }
2299
+ if (built.textClass) { lineView.textClass = built.textClass }
2300
+
2301
+ updateLineClasses(cm, lineView)
2302
+ updateLineGutter(cm, lineView, lineN, dims)
2303
+ insertLineWidgets(cm, lineView, dims)
2304
+ return lineView.node
2305
+ }
2306
+
2307
+ // A lineView may contain multiple logical lines (when merged by
2308
+ // collapsed spans). The widgets for all of them need to be drawn.
2309
+ function insertLineWidgets(cm, lineView, dims) {
2310
+ insertLineWidgetsFor(cm, lineView.line, lineView, dims, true)
2311
+ if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
2312
+ { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false) } }
2313
+ }
2314
+
2315
+ function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
2316
+ if (!line.widgets) { return }
2317
+ var wrap = ensureLineWrapped(lineView)
2318
+ for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
2319
+ var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget")
2320
+ if (!widget.handleMouseEvents) { node.setAttribute("cm-ignore-events", "true") }
2321
+ positionLineWidget(widget, node, lineView, dims)
2322
+ cm.display.input.setUneditable(node)
2323
+ if (allowAbove && widget.above)
2324
+ { wrap.insertBefore(node, lineView.gutter || lineView.text) }
2325
+ else
2326
+ { wrap.appendChild(node) }
2327
+ signalLater(widget, "redraw")
2328
+ }
2329
+ }
2330
+
2331
+ function positionLineWidget(widget, node, lineView, dims) {
2332
+ if (widget.noHScroll) {
2333
+ ;(lineView.alignable || (lineView.alignable = [])).push(node)
2334
+ var width = dims.wrapperWidth
2335
+ node.style.left = dims.fixedPos + "px"
2336
+ if (!widget.coverGutter) {
2337
+ width -= dims.gutterTotalWidth
2338
+ node.style.paddingLeft = dims.gutterTotalWidth + "px"
2339
+ }
2340
+ node.style.width = width + "px"
2341
+ }
2342
+ if (widget.coverGutter) {
2343
+ node.style.zIndex = 5
2344
+ node.style.position = "relative"
2345
+ if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + "px" }
2346
+ }
2347
+ }
2348
+
2349
+ function widgetHeight(widget) {
2350
+ if (widget.height != null) { return widget.height }
2351
+ var cm = widget.doc.cm
2352
+ if (!cm) { return 0 }
2353
+ if (!contains(document.body, widget.node)) {
2354
+ var parentStyle = "position: relative;"
2355
+ if (widget.coverGutter)
2356
+ { parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;" }
2357
+ if (widget.noHScroll)
2358
+ { parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;" }
2359
+ removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle))
2360
+ }
2361
+ return widget.height = widget.node.parentNode.offsetHeight
2362
+ }
2363
+
2364
+ // Return true when the given mouse event happened in a widget
2365
+ function eventInWidget(display, e) {
2366
+ for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
2367
+ if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
2368
+ (n.parentNode == display.sizer && n != display.mover))
2369
+ { return true }
2370
+ }
2371
+ }
2372
+
2373
+ // POSITION MEASUREMENT
2374
+
2375
+ function paddingTop(display) {return display.lineSpace.offsetTop}
2376
+ function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight}
2377
+ function paddingH(display) {
2378
+ if (display.cachedPaddingH) { return display.cachedPaddingH }
2379
+ var e = removeChildrenAndAdd(display.measure, elt("pre", "x"))
2380
+ var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle
2381
+ var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)}
2382
+ if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data }
2383
+ return data
2384
+ }
2385
+
2386
+ function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }
2387
+ function displayWidth(cm) {
2388
+ return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth
2389
+ }
2390
+ function displayHeight(cm) {
2391
+ return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight
2392
+ }
2393
+
2394
+ // Ensure the lineView.wrapping.heights array is populated. This is
2395
+ // an array of bottom offsets for the lines that make up a drawn
2396
+ // line. When lineWrapping is on, there might be more than one
2397
+ // height.
2398
+ function ensureLineHeights(cm, lineView, rect) {
2399
+ var wrapping = cm.options.lineWrapping
2400
+ var curWidth = wrapping && displayWidth(cm)
2401
+ if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
2402
+ var heights = lineView.measure.heights = []
2403
+ if (wrapping) {
2404
+ lineView.measure.width = curWidth
2405
+ var rects = lineView.text.firstChild.getClientRects()
2406
+ for (var i = 0; i < rects.length - 1; i++) {
2407
+ var cur = rects[i], next = rects[i + 1]
2408
+ if (Math.abs(cur.bottom - next.bottom) > 2)
2409
+ { heights.push((cur.bottom + next.top) / 2 - rect.top) }
2410
+ }
2411
+ }
2412
+ heights.push(rect.bottom - rect.top)
2413
+ }
2414
+ }
2415
+
2416
+ // Find a line map (mapping character offsets to text nodes) and a
2417
+ // measurement cache for the given line number. (A line view might
2418
+ // contain multiple lines when collapsed ranges are present.)
2419
+ function mapFromLineView(lineView, line, lineN) {
2420
+ if (lineView.line == line)
2421
+ { return {map: lineView.measure.map, cache: lineView.measure.cache} }
2422
+ for (var i = 0; i < lineView.rest.length; i++)
2423
+ { if (lineView.rest[i] == line)
2424
+ { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }
2425
+ for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)
2426
+ { if (lineNo(lineView.rest[i$1]) > lineN)
2427
+ { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }
2428
+ }
2429
+
2430
+ // Render a line into the hidden node display.externalMeasured. Used
2431
+ // when measurement is needed for a line that's not in the viewport.
2432
+ function updateExternalMeasurement(cm, line) {
2433
+ line = visualLine(line)
2434
+ var lineN = lineNo(line)
2435
+ var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN)
2436
+ view.lineN = lineN
2437
+ var built = view.built = buildLineContent(cm, view)
2438
+ view.text = built.pre
2439
+ removeChildrenAndAdd(cm.display.lineMeasure, built.pre)
2440
+ return view
2441
+ }
2442
+
2443
+ // Get a {top, bottom, left, right} box (in line-local coordinates)
2444
+ // for a given character.
2445
+ function measureChar(cm, line, ch, bias) {
2446
+ return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)
2447
+ }
2448
+
2449
+ // Find a line view that corresponds to the given line number.
2450
+ function findViewForLine(cm, lineN) {
2451
+ if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
2452
+ { return cm.display.view[findViewIndex(cm, lineN)] }
2453
+ var ext = cm.display.externalMeasured
2454
+ if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
2455
+ { return ext }
2456
+ }
2457
+
2458
+ // Measurement can be split in two steps, the set-up work that
2459
+ // applies to the whole line, and the measurement of the actual
2460
+ // character. Functions like coordsChar, that need to do a lot of
2461
+ // measurements in a row, can thus ensure that the set-up work is
2462
+ // only done once.
2463
+ function prepareMeasureForLine(cm, line) {
2464
+ var lineN = lineNo(line)
2465
+ var view = findViewForLine(cm, lineN)
2466
+ if (view && !view.text) {
2467
+ view = null
2468
+ } else if (view && view.changes) {
2469
+ updateLineForChanges(cm, view, lineN, getDimensions(cm))
2470
+ cm.curOp.forceUpdate = true
2471
+ }
2472
+ if (!view)
2473
+ { view = updateExternalMeasurement(cm, line) }
2474
+
2475
+ var info = mapFromLineView(view, line, lineN)
2476
+ return {
2477
+ line: line, view: view, rect: null,
2478
+ map: info.map, cache: info.cache, before: info.before,
2479
+ hasHeights: false
2480
+ }
2481
+ }
2482
+
2483
+ // Given a prepared measurement object, measures the position of an
2484
+ // actual character (or fetches it from the cache).
2485
+ function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
2486
+ if (prepared.before) { ch = -1 }
2487
+ var key = ch + (bias || ""), found
2488
+ if (prepared.cache.hasOwnProperty(key)) {
2489
+ found = prepared.cache[key]
2490
+ } else {
2491
+ if (!prepared.rect)
2492
+ { prepared.rect = prepared.view.text.getBoundingClientRect() }
2493
+ if (!prepared.hasHeights) {
2494
+ ensureLineHeights(cm, prepared.view, prepared.rect)
2495
+ prepared.hasHeights = true
2496
+ }
2497
+ found = measureCharInner(cm, prepared, ch, bias)
2498
+ if (!found.bogus) { prepared.cache[key] = found }
2499
+ }
2500
+ return {left: found.left, right: found.right,
2501
+ top: varHeight ? found.rtop : found.top,
2502
+ bottom: varHeight ? found.rbottom : found.bottom}
2503
+ }
2504
+
2505
+ var nullRect = {left: 0, right: 0, top: 0, bottom: 0}
2506
+
2507
+ function nodeAndOffsetInLineMap(map, ch, bias) {
2508
+ var node, start, end, collapse, mStart, mEnd
2509
+ // First, search the line map for the text node corresponding to,
2510
+ // or closest to, the target character.
2511
+ for (var i = 0; i < map.length; i += 3) {
2512
+ mStart = map[i]
2513
+ mEnd = map[i + 1]
2514
+ if (ch < mStart) {
2515
+ start = 0; end = 1
2516
+ collapse = "left"
2517
+ } else if (ch < mEnd) {
2518
+ start = ch - mStart
2519
+ end = start + 1
2520
+ } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {
2521
+ end = mEnd - mStart
2522
+ start = end - 1
2523
+ if (ch >= mEnd) { collapse = "right" }
2524
+ }
2525
+ if (start != null) {
2526
+ node = map[i + 2]
2527
+ if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right"))
2528
+ { collapse = bias }
2529
+ if (bias == "left" && start == 0)
2530
+ { while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {
2531
+ node = map[(i -= 3) + 2]
2532
+ collapse = "left"
2533
+ } }
2534
+ if (bias == "right" && start == mEnd - mStart)
2535
+ { while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {
2536
+ node = map[(i += 3) + 2]
2537
+ collapse = "right"
2538
+ } }
2539
+ break
2540
+ }
2541
+ }
2542
+ return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd}
2543
+ }
2544
+
2545
+ function getUsefulRect(rects, bias) {
2546
+ var rect = nullRect
2547
+ if (bias == "left") { for (var i = 0; i < rects.length; i++) {
2548
+ if ((rect = rects[i]).left != rect.right) { break }
2549
+ } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {
2550
+ if ((rect = rects[i$1]).left != rect.right) { break }
2551
+ } }
2552
+ return rect
2553
+ }
2554
+
2555
+ function measureCharInner(cm, prepared, ch, bias) {
2556
+ var place = nodeAndOffsetInLineMap(prepared.map, ch, bias)
2557
+ var node = place.node, start = place.start, end = place.end, collapse = place.collapse
2558
+
2559
+ var rect
2560
+ if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
2561
+ for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned
2562
+ while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start }
2563
+ while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end }
2564
+ if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)
2565
+ { rect = node.parentNode.getBoundingClientRect() }
2566
+ else
2567
+ { rect = getUsefulRect(range(node, start, end).getClientRects(), bias) }
2568
+ if (rect.left || rect.right || start == 0) { break }
2569
+ end = start
2570
+ start = start - 1
2571
+ collapse = "right"
2572
+ }
2573
+ if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect) }
2574
+ } else { // If it is a widget, simply get the box for the whole widget.
2575
+ if (start > 0) { collapse = bias = "right" }
2576
+ var rects
2577
+ if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
2578
+ { rect = rects[bias == "right" ? rects.length - 1 : 0] }
2579
+ else
2580
+ { rect = node.getBoundingClientRect() }
2581
+ }
2582
+ if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
2583
+ var rSpan = node.parentNode.getClientRects()[0]
2584
+ if (rSpan)
2585
+ { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom} }
2586
+ else
2587
+ { rect = nullRect }
2588
+ }
2589
+
2590
+ var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top
2591
+ var mid = (rtop + rbot) / 2
2592
+ var heights = prepared.view.measure.heights
2593
+ var i = 0
2594
+ for (; i < heights.length - 1; i++)
2595
+ { if (mid < heights[i]) { break } }
2596
+ var top = i ? heights[i - 1] : 0, bot = heights[i]
2597
+ var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left,
2598
+ right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left,
2599
+ top: top, bottom: bot}
2600
+ if (!rect.left && !rect.right) { result.bogus = true }
2601
+ if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot }
2602
+
2603
+ return result
2604
+ }
2605
+
2606
+ // Work around problem with bounding client rects on ranges being
2607
+ // returned incorrectly when zoomed on IE10 and below.
2608
+ function maybeUpdateRectForZooming(measure, rect) {
2609
+ if (!window.screen || screen.logicalXDPI == null ||
2610
+ screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
2611
+ { return rect }
2612
+ var scaleX = screen.logicalXDPI / screen.deviceXDPI
2613
+ var scaleY = screen.logicalYDPI / screen.deviceYDPI
2614
+ return {left: rect.left * scaleX, right: rect.right * scaleX,
2615
+ top: rect.top * scaleY, bottom: rect.bottom * scaleY}
2616
+ }
2617
+
2618
+ function clearLineMeasurementCacheFor(lineView) {
2619
+ if (lineView.measure) {
2620
+ lineView.measure.cache = {}
2621
+ lineView.measure.heights = null
2622
+ if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
2623
+ { lineView.measure.caches[i] = {} } }
2624
+ }
2625
+ }
2626
+
2627
+ function clearLineMeasurementCache(cm) {
2628
+ cm.display.externalMeasure = null
2629
+ removeChildren(cm.display.lineMeasure)
2630
+ for (var i = 0; i < cm.display.view.length; i++)
2631
+ { clearLineMeasurementCacheFor(cm.display.view[i]) }
2632
+ }
2633
+
2634
+ function clearCaches(cm) {
2635
+ clearLineMeasurementCache(cm)
2636
+ cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null
2637
+ if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true }
2638
+ cm.display.lineNumChars = null
2639
+ }
2640
+
2641
+ function pageScrollX() {
2642
+ // Work around https://bugs.chromium.org/p/chromium/issues/detail?id=489206
2643
+ // which causes page_Offset and bounding client rects to use
2644
+ // different reference viewports and invalidate our calculations.
2645
+ if (chrome && android) { return -(document.body.getBoundingClientRect().left - parseInt(getComputedStyle(document.body).marginLeft)) }
2646
+ return window.pageXOffset || (document.documentElement || document.body).scrollLeft
2647
+ }
2648
+ function pageScrollY() {
2649
+ if (chrome && android) { return -(document.body.getBoundingClientRect().top - parseInt(getComputedStyle(document.body).marginTop)) }
2650
+ return window.pageYOffset || (document.documentElement || document.body).scrollTop
2651
+ }
2652
+
2653
+ function widgetTopHeight(lineObj) {
2654
+ var height = 0
2655
+ if (lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above)
2656
+ { height += widgetHeight(lineObj.widgets[i]) } } }
2657
+ return height
2658
+ }
2659
+
2660
+ // Converts a {top, bottom, left, right} box from line-local
2661
+ // coordinates into another coordinate system. Context may be one of
2662
+ // "line", "div" (display.lineDiv), "local"./null (editor), "window",
2663
+ // or "page".
2664
+ function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {
2665
+ if (!includeWidgets) {
2666
+ var height = widgetTopHeight(lineObj)
2667
+ rect.top += height; rect.bottom += height
2668
+ }
2669
+ if (context == "line") { return rect }
2670
+ if (!context) { context = "local" }
2671
+ var yOff = heightAtLine(lineObj)
2672
+ if (context == "local") { yOff += paddingTop(cm.display) }
2673
+ else { yOff -= cm.display.viewOffset }
2674
+ if (context == "page" || context == "window") {
2675
+ var lOff = cm.display.lineSpace.getBoundingClientRect()
2676
+ yOff += lOff.top + (context == "window" ? 0 : pageScrollY())
2677
+ var xOff = lOff.left + (context == "window" ? 0 : pageScrollX())
2678
+ rect.left += xOff; rect.right += xOff
2679
+ }
2680
+ rect.top += yOff; rect.bottom += yOff
2681
+ return rect
2682
+ }
2683
+
2684
+ // Coverts a box from "div" coords to another coordinate system.
2685
+ // Context may be "window", "page", "div", or "local"./null.
2686
+ function fromCoordSystem(cm, coords, context) {
2687
+ if (context == "div") { return coords }
2688
+ var left = coords.left, top = coords.top
2689
+ // First move into "page" coordinate system
2690
+ if (context == "page") {
2691
+ left -= pageScrollX()
2692
+ top -= pageScrollY()
2693
+ } else if (context == "local" || !context) {
2694
+ var localBox = cm.display.sizer.getBoundingClientRect()
2695
+ left += localBox.left
2696
+ top += localBox.top
2697
+ }
2698
+
2699
+ var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect()
2700
+ return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}
2701
+ }
2702
+
2703
+ function charCoords(cm, pos, context, lineObj, bias) {
2704
+ if (!lineObj) { lineObj = getLine(cm.doc, pos.line) }
2705
+ return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)
2706
+ }
2707
+
2708
+ // Returns a box for a given cursor position, which may have an
2709
+ // 'other' property containing the position of the secondary cursor
2710
+ // on a bidi boundary.
2711
+ // A cursor Pos(line, char, "before") is on the same visual line as `char - 1`
2712
+ // and after `char - 1` in writing order of `char - 1`
2713
+ // A cursor Pos(line, char, "after") is on the same visual line as `char`
2714
+ // and before `char` in writing order of `char`
2715
+ // Examples (upper-case letters are RTL, lower-case are LTR):
2716
+ // Pos(0, 1, ...)
2717
+ // before after
2718
+ // ab a|b a|b
2719
+ // aB a|B aB|
2720
+ // Ab |Ab A|b
2721
+ // AB B|A B|A
2722
+ // Every position after the last character on a line is considered to stick
2723
+ // to the last character on the line.
2724
+ function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
2725
+ lineObj = lineObj || getLine(cm.doc, pos.line)
2726
+ if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj) }
2727
+ function get(ch, right) {
2728
+ var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight)
2729
+ if (right) { m.left = m.right; } else { m.right = m.left }
2730
+ return intoCoordSystem(cm, lineObj, m, context)
2731
+ }
2732
+ var order = getOrder(lineObj, cm.doc.direction), ch = pos.ch, sticky = pos.sticky
2733
+ if (ch >= lineObj.text.length) {
2734
+ ch = lineObj.text.length
2735
+ sticky = "before"
2736
+ } else if (ch <= 0) {
2737
+ ch = 0
2738
+ sticky = "after"
2739
+ }
2740
+ if (!order) { return get(sticky == "before" ? ch - 1 : ch, sticky == "before") }
2741
+
2742
+ function getBidi(ch, partPos, invert) {
2743
+ var part = order[partPos], right = part.level == 1
2744
+ return get(invert ? ch - 1 : ch, right != invert)
2745
+ }
2746
+ var partPos = getBidiPartAt(order, ch, sticky)
2747
+ var other = bidiOther
2748
+ var val = getBidi(ch, partPos, sticky == "before")
2749
+ if (other != null) { val.other = getBidi(ch, other, sticky != "before") }
2750
+ return val
2751
+ }
2752
+
2753
+ // Used to cheaply estimate the coordinates for a position. Used for
2754
+ // intermediate scroll updates.
2755
+ function estimateCoords(cm, pos) {
2756
+ var left = 0
2757
+ pos = clipPos(cm.doc, pos)
2758
+ if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch }
2759
+ var lineObj = getLine(cm.doc, pos.line)
2760
+ var top = heightAtLine(lineObj) + paddingTop(cm.display)
2761
+ return {left: left, right: left, top: top, bottom: top + lineObj.height}
2762
+ }
2763
+
2764
+ // Positions returned by coordsChar contain some extra information.
2765
+ // xRel is the relative x position of the input coordinates compared
2766
+ // to the found position (so xRel > 0 means the coordinates are to
2767
+ // the right of the character position, for example). When outside
2768
+ // is true, that means the coordinates lie outside the line's
2769
+ // vertical range.
2770
+ function PosWithInfo(line, ch, sticky, outside, xRel) {
2771
+ var pos = Pos(line, ch, sticky)
2772
+ pos.xRel = xRel
2773
+ if (outside) { pos.outside = true }
2774
+ return pos
2775
+ }
2776
+
2777
+ // Compute the character position closest to the given coordinates.
2778
+ // Input must be lineSpace-local ("div" coordinate system).
2779
+ function coordsChar(cm, x, y) {
2780
+ var doc = cm.doc
2781
+ y += cm.display.viewOffset
2782
+ if (y < 0) { return PosWithInfo(doc.first, 0, null, true, -1) }
2783
+ var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1
2784
+ if (lineN > last)
2785
+ { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, true, 1) }
2786
+ if (x < 0) { x = 0 }
2787
+
2788
+ var lineObj = getLine(doc, lineN)
2789
+ for (;;) {
2790
+ var found = coordsCharInner(cm, lineObj, lineN, x, y)
2791
+ var collapsed = collapsedSpanAround(lineObj, found.ch + (found.xRel > 0 ? 1 : 0))
2792
+ if (!collapsed) { return found }
2793
+ var rangeEnd = collapsed.find(1)
2794
+ if (rangeEnd.line == lineN) { return rangeEnd }
2795
+ lineObj = getLine(doc, lineN = rangeEnd.line)
2796
+ }
2797
+ }
2798
+
2799
+ function wrappedLineExtent(cm, lineObj, preparedMeasure, y) {
2800
+ y -= widgetTopHeight(lineObj)
2801
+ var end = lineObj.text.length
2802
+ var begin = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch - 1).bottom <= y; }, end, 0)
2803
+ end = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch).top > y; }, begin, end)
2804
+ return {begin: begin, end: end}
2805
+ }
2806
+
2807
+ function wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) {
2808
+ if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj) }
2809
+ var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), "line").top
2810
+ return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop)
2811
+ }
2812
+
2813
+ // Returns true if the given side of a box is after the given
2814
+ // coordinates, in top-to-bottom, left-to-right order.
2815
+ function boxIsAfter(box, x, y, left) {
2816
+ return box.bottom <= y ? false : box.top > y ? true : (left ? box.left : box.right) > x
2817
+ }
2818
+
2819
+ function coordsCharInner(cm, lineObj, lineNo, x, y) {
2820
+ // Move y into line-local coordinate space
2821
+ y -= heightAtLine(lineObj)
2822
+ var preparedMeasure = prepareMeasureForLine(cm, lineObj)
2823
+ // When directly calling `measureCharPrepared`, we have to adjust
2824
+ // for the widgets at this line.
2825
+ var widgetHeight = widgetTopHeight(lineObj)
2826
+ var begin = 0, end = lineObj.text.length, ltr = true
2827
+
2828
+ var order = getOrder(lineObj, cm.doc.direction)
2829
+ // If the line isn't plain left-to-right text, first figure out
2830
+ // which bidi section the coordinates fall into.
2831
+ if (order) {
2832
+ var part = (cm.options.lineWrapping ? coordsBidiPartWrapped : coordsBidiPart)
2833
+ (cm, lineObj, lineNo, preparedMeasure, order, x, y)
2834
+ ltr = part.level != 1
2835
+ // The awkward -1 offsets are needed because findFirst (called
2836
+ // on these below) will treat its first bound as inclusive,
2837
+ // second as exclusive, but we want to actually address the
2838
+ // characters in the part's range
2839
+ begin = ltr ? part.from : part.to - 1
2840
+ end = ltr ? part.to : part.from - 1
2841
+ }
2842
+
2843
+ // A binary search to find the first character whose bounding box
2844
+ // starts after the coordinates. If we run across any whose box wrap
2845
+ // the coordinates, store that.
2846
+ var chAround = null, boxAround = null
2847
+ var ch = findFirst(function (ch) {
2848
+ var box = measureCharPrepared(cm, preparedMeasure, ch)
2849
+ box.top += widgetHeight; box.bottom += widgetHeight
2850
+ if (!boxIsAfter(box, x, y, false)) { return false }
2851
+ if (box.top <= y && box.left <= x) {
2852
+ chAround = ch
2853
+ boxAround = box
2854
+ }
2855
+ return true
2856
+ }, begin, end)
2857
+
2858
+ var baseX, sticky, outside = false
2859
+ // If a box around the coordinates was found, use that
2860
+ if (boxAround) {
2861
+ // Distinguish coordinates nearer to the left or right side of the box
2862
+ var atLeft = x - boxAround.left < boxAround.right - x, atStart = atLeft == ltr
2863
+ ch = chAround + (atStart ? 0 : 1)
2864
+ sticky = atStart ? "after" : "before"
2865
+ baseX = atLeft ? boxAround.left : boxAround.right
2866
+ } else {
2867
+ // (Adjust for extended bound, if necessary.)
2868
+ if (!ltr && (ch == end || ch == begin)) { ch++ }
2869
+ // To determine which side to associate with, get the box to the
2870
+ // left of the character and compare it's vertical position to the
2871
+ // coordinates
2872
+ sticky = ch == 0 ? "after" : ch == lineObj.text.length ? "before" :
2873
+ (measureCharPrepared(cm, preparedMeasure, ch - (ltr ? 1 : 0)).bottom + widgetHeight <= y) == ltr ?
2874
+ "after" : "before"
2875
+ // Now get accurate coordinates for this place, in order to get a
2876
+ // base X position
2877
+ var coords = cursorCoords(cm, Pos(lineNo, ch, sticky), "line", lineObj, preparedMeasure)
2878
+ baseX = coords.left
2879
+ outside = y < coords.top || y >= coords.bottom
2880
+ }
2881
+
2882
+ ch = skipExtendingChars(lineObj.text, ch, 1)
2883
+ return PosWithInfo(lineNo, ch, sticky, outside, x - baseX)
2884
+ }
2885
+
2886
+ function coordsBidiPart(cm, lineObj, lineNo, preparedMeasure, order, x, y) {
2887
+ // Bidi parts are sorted left-to-right, and in a non-line-wrapping
2888
+ // situation, we can take this ordering to correspond to the visual
2889
+ // ordering. This finds the first part whose end is after the given
2890
+ // coordinates.
2891
+ var index = findFirst(function (i) {
2892
+ var part = order[i], ltr = part.level != 1
2893
+ return boxIsAfter(cursorCoords(cm, Pos(lineNo, ltr ? part.to : part.from, ltr ? "before" : "after"),
2894
+ "line", lineObj, preparedMeasure), x, y, true)
2895
+ }, 0, order.length - 1)
2896
+ var part = order[index]
2897
+ // If this isn't the first part, the part's start is also after
2898
+ // the coordinates, and the coordinates aren't on the same line as
2899
+ // that start, move one part back.
2900
+ if (index > 0) {
2901
+ var ltr = part.level != 1
2902
+ var start = cursorCoords(cm, Pos(lineNo, ltr ? part.from : part.to, ltr ? "after" : "before"),
2903
+ "line", lineObj, preparedMeasure)
2904
+ if (boxIsAfter(start, x, y, true) && start.top > y)
2905
+ { part = order[index - 1] }
2906
+ }
2907
+ return part
2908
+ }
2909
+
2910
+ function coordsBidiPartWrapped(cm, lineObj, _lineNo, preparedMeasure, order, x, y) {
2911
+ // In a wrapped line, rtl text on wrapping boundaries can do things
2912
+ // that don't correspond to the ordering in our `order` array at
2913
+ // all, so a binary search doesn't work, and we want to return a
2914
+ // part that only spans one line so that the binary search in
2915
+ // coordsCharInner is safe. As such, we first find the extent of the
2916
+ // wrapped line, and then do a flat search in which we discard any
2917
+ // spans that aren't on the line.
2918
+ var ref = wrappedLineExtent(cm, lineObj, preparedMeasure, y);
2919
+ var begin = ref.begin;
2920
+ var end = ref.end;
2921
+ if (/\s/.test(lineObj.text.charAt(end - 1))) { end-- }
2922
+ var part = null, closestDist = null
2923
+ for (var i = 0; i < order.length; i++) {
2924
+ var p = order[i]
2925
+ if (p.from >= end || p.to <= begin) { continue }
2926
+ var ltr = p.level != 1
2927
+ var endX = measureCharPrepared(cm, preparedMeasure, ltr ? Math.min(end, p.to) - 1 : Math.max(begin, p.from)).right
2928
+ // Weigh against spans ending before this, so that they are only
2929
+ // picked if nothing ends after
2930
+ var dist = endX < x ? x - endX + 1e9 : endX - x
2931
+ if (!part || closestDist > dist) {
2932
+ part = p
2933
+ closestDist = dist
2934
+ }
2935
+ }
2936
+ if (!part) { part = order[order.length - 1] }
2937
+ // Clip the part to the wrapped line.
2938
+ if (part.from < begin) { part = {from: begin, to: part.to, level: part.level} }
2939
+ if (part.to > end) { part = {from: part.from, to: end, level: part.level} }
2940
+ return part
2941
+ }
2942
+
2943
+ var measureText
2944
+ // Compute the default text height.
2945
+ function textHeight(display) {
2946
+ if (display.cachedTextHeight != null) { return display.cachedTextHeight }
2947
+ if (measureText == null) {
2948
+ measureText = elt("pre")
2949
+ // Measure a bunch of lines, for browsers that compute
2950
+ // fractional heights.
2951
+ for (var i = 0; i < 49; ++i) {
2952
+ measureText.appendChild(document.createTextNode("x"))
2953
+ measureText.appendChild(elt("br"))
2954
+ }
2955
+ measureText.appendChild(document.createTextNode("x"))
2956
+ }
2957
+ removeChildrenAndAdd(display.measure, measureText)
2958
+ var height = measureText.offsetHeight / 50
2959
+ if (height > 3) { display.cachedTextHeight = height }
2960
+ removeChildren(display.measure)
2961
+ return height || 1
2962
+ }
2963
+
2964
+ // Compute the default character width.
2965
+ function charWidth(display) {
2966
+ if (display.cachedCharWidth != null) { return display.cachedCharWidth }
2967
+ var anchor = elt("span", "xxxxxxxxxx")
2968
+ var pre = elt("pre", [anchor])
2969
+ removeChildrenAndAdd(display.measure, pre)
2970
+ var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10
2971
+ if (width > 2) { display.cachedCharWidth = width }
2972
+ return width || 10
2973
+ }
2974
+
2975
+ // Do a bulk-read of the DOM positions and sizes needed to draw the
2976
+ // view, so that we don't interleave reading and writing to the DOM.
2977
+ function getDimensions(cm) {
2978
+ var d = cm.display, left = {}, width = {}
2979
+ var gutterLeft = d.gutters.clientLeft
2980
+ for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
2981
+ left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft
2982
+ width[cm.options.gutters[i]] = n.clientWidth
2983
+ }
2984
+ return {fixedPos: compensateForHScroll(d),
2985
+ gutterTotalWidth: d.gutters.offsetWidth,
2986
+ gutterLeft: left,
2987
+ gutterWidth: width,
2988
+ wrapperWidth: d.wrapper.clientWidth}
2989
+ }
2990
+
2991
+ // Computes display.scroller.scrollLeft + display.gutters.offsetWidth,
2992
+ // but using getBoundingClientRect to get a sub-pixel-accurate
2993
+ // result.
2994
+ function compensateForHScroll(display) {
2995
+ return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left
2996
+ }
2997
+
2998
+ // Returns a function that estimates the height of a line, to use as
2999
+ // first approximation until the line becomes visible (and is thus
3000
+ // properly measurable).
3001
+ function estimateHeight(cm) {
3002
+ var th = textHeight(cm.display), wrapping = cm.options.lineWrapping
3003
+ var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3)
3004
+ return function (line) {
3005
+ if (lineIsHidden(cm.doc, line)) { return 0 }
3006
+
3007
+ var widgetsHeight = 0
3008
+ if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) {
3009
+ if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height }
3010
+ } }
3011
+
3012
+ if (wrapping)
3013
+ { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th }
3014
+ else
3015
+ { return widgetsHeight + th }
3016
+ }
3017
+ }
3018
+
3019
+ function estimateLineHeights(cm) {
3020
+ var doc = cm.doc, est = estimateHeight(cm)
3021
+ doc.iter(function (line) {
3022
+ var estHeight = est(line)
3023
+ if (estHeight != line.height) { updateLineHeight(line, estHeight) }
3024
+ })
3025
+ }
3026
+
3027
+ // Given a mouse event, find the corresponding position. If liberal
3028
+ // is false, it checks whether a gutter or scrollbar was clicked,
3029
+ // and returns null if it was. forRect is used by rectangular
3030
+ // selections, and tries to estimate a character position even for
3031
+ // coordinates beyond the right of the text.
3032
+ function posFromMouse(cm, e, liberal, forRect) {
3033
+ var display = cm.display
3034
+ if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") { return null }
3035
+
3036
+ var x, y, space = display.lineSpace.getBoundingClientRect()
3037
+ // Fails unpredictably on IE[67] when mouse is dragged around quickly.
3038
+ try { x = e.clientX - space.left; y = e.clientY - space.top }
3039
+ catch (e) { return null }
3040
+ var coords = coordsChar(cm, x, y), line
3041
+ if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {
3042
+ var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length
3043
+ coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff))
3044
+ }
3045
+ return coords
3046
+ }
3047
+
3048
+ // Find the view element corresponding to a given line. Return null
3049
+ // when the line isn't visible.
3050
+ function findViewIndex(cm, n) {
3051
+ if (n >= cm.display.viewTo) { return null }
3052
+ n -= cm.display.viewFrom
3053
+ if (n < 0) { return null }
3054
+ var view = cm.display.view
3055
+ for (var i = 0; i < view.length; i++) {
3056
+ n -= view[i].size
3057
+ if (n < 0) { return i }
3058
+ }
3059
+ }
3060
+
3061
+ function updateSelection(cm) {
3062
+ cm.display.input.showSelection(cm.display.input.prepareSelection())
3063
+ }
3064
+
3065
+ function prepareSelection(cm, primary) {
3066
+ if ( primary === void 0 ) primary = true;
3067
+
3068
+ var doc = cm.doc, result = {}
3069
+ var curFragment = result.cursors = document.createDocumentFragment()
3070
+ var selFragment = result.selection = document.createDocumentFragment()
3071
+
3072
+ for (var i = 0; i < doc.sel.ranges.length; i++) {
3073
+ if (!primary && i == doc.sel.primIndex) { continue }
3074
+ var range = doc.sel.ranges[i]
3075
+ if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) { continue }
3076
+ var collapsed = range.empty()
3077
+ if (collapsed || cm.options.showCursorWhenSelecting)
3078
+ { drawSelectionCursor(cm, range.head, curFragment) }
3079
+ if (!collapsed)
3080
+ { drawSelectionRange(cm, range, selFragment) }
3081
+ }
3082
+ return result
3083
+ }
3084
+
3085
+ // Draws a cursor for the given range
3086
+ function drawSelectionCursor(cm, head, output) {
3087
+ var pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine)
3088
+
3089
+ var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"))
3090
+ cursor.style.left = pos.left + "px"
3091
+ cursor.style.top = pos.top + "px"
3092
+ cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px"
3093
+
3094
+ if (pos.other) {
3095
+ // Secondary cursor, shown when on a 'jump' in bi-directional text
3096
+ var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"))
3097
+ otherCursor.style.display = ""
3098
+ otherCursor.style.left = pos.other.left + "px"
3099
+ otherCursor.style.top = pos.other.top + "px"
3100
+ otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px"
3101
+ }
3102
+ }
3103
+
3104
+ function cmpCoords(a, b) { return a.top - b.top || a.left - b.left }
3105
+
3106
+ // Draws the given range as a highlighted selection
3107
+ function drawSelectionRange(cm, range, output) {
3108
+ var display = cm.display, doc = cm.doc
3109
+ var fragment = document.createDocumentFragment()
3110
+ var padding = paddingH(cm.display), leftSide = padding.left
3111
+ var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right
3112
+ var docLTR = doc.direction == "ltr"
3113
+
3114
+ function add(left, top, width, bottom) {
3115
+ if (top < 0) { top = 0 }
3116
+ top = Math.round(top)
3117
+ bottom = Math.round(bottom)
3118
+ fragment.appendChild(elt("div", null, "CodeMirror-selected", ("position: absolute; left: " + left + "px;\n top: " + top + "px; width: " + (width == null ? rightSide - left : width) + "px;\n height: " + (bottom - top) + "px")))
3119
+ }
3120
+
3121
+ function drawForLine(line, fromArg, toArg) {
3122
+ var lineObj = getLine(doc, line)
3123
+ var lineLen = lineObj.text.length
3124
+ var start, end
3125
+ function coords(ch, bias) {
3126
+ return charCoords(cm, Pos(line, ch), "div", lineObj, bias)
3127
+ }
3128
+
3129
+ function wrapX(pos, dir, side) {
3130
+ var extent = wrappedLineExtentChar(cm, lineObj, null, pos)
3131
+ var prop = (dir == "ltr") == (side == "after") ? "left" : "right"
3132
+ var ch = side == "after" ? extent.begin : extent.end - (/\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1)
3133
+ return coords(ch, prop)[prop]
3134
+ }
3135
+
3136
+ var order = getOrder(lineObj, doc.direction)
3137
+ iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir, i) {
3138
+ var ltr = dir == "ltr"
3139
+ var fromPos = coords(from, ltr ? "left" : "right")
3140
+ var toPos = coords(to - 1, ltr ? "right" : "left")
3141
+
3142
+ var openStart = fromArg == null && from == 0, openEnd = toArg == null && to == lineLen
3143
+ var first = i == 0, last = !order || i == order.length - 1
3144
+ if (toPos.top - fromPos.top <= 3) { // Single line
3145
+ var openLeft = (docLTR ? openStart : openEnd) && first
3146
+ var openRight = (docLTR ? openEnd : openStart) && last
3147
+ var left = openLeft ? leftSide : (ltr ? fromPos : toPos).left
3148
+ var right = openRight ? rightSide : (ltr ? toPos : fromPos).right
3149
+ add(left, fromPos.top, right - left, fromPos.bottom)
3150
+ } else { // Multiple lines
3151
+ var topLeft, topRight, botLeft, botRight
3152
+ if (ltr) {
3153
+ topLeft = docLTR && openStart && first ? leftSide : fromPos.left
3154
+ topRight = docLTR ? rightSide : wrapX(from, dir, "before")
3155
+ botLeft = docLTR ? leftSide : wrapX(to, dir, "after")
3156
+ botRight = docLTR && openEnd && last ? rightSide : toPos.right
3157
+ } else {
3158
+ topLeft = !docLTR ? leftSide : wrapX(from, dir, "before")
3159
+ topRight = !docLTR && openStart && first ? rightSide : fromPos.right
3160
+ botLeft = !docLTR && openEnd && last ? leftSide : toPos.left
3161
+ botRight = !docLTR ? rightSide : wrapX(to, dir, "after")
3162
+ }
3163
+ add(topLeft, fromPos.top, topRight - topLeft, fromPos.bottom)
3164
+ if (fromPos.bottom < toPos.top) { add(leftSide, fromPos.bottom, null, toPos.top) }
3165
+ add(botLeft, toPos.top, botRight - botLeft, toPos.bottom)
3166
+ }
3167
+
3168
+ if (!start || cmpCoords(fromPos, start) < 0) { start = fromPos }
3169
+ if (cmpCoords(toPos, start) < 0) { start = toPos }
3170
+ if (!end || cmpCoords(fromPos, end) < 0) { end = fromPos }
3171
+ if (cmpCoords(toPos, end) < 0) { end = toPos }
3172
+ })
3173
+ return {start: start, end: end}
3174
+ }
3175
+
3176
+ var sFrom = range.from(), sTo = range.to()
3177
+ if (sFrom.line == sTo.line) {
3178
+ drawForLine(sFrom.line, sFrom.ch, sTo.ch)
3179
+ } else {
3180
+ var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line)
3181
+ var singleVLine = visualLine(fromLine) == visualLine(toLine)
3182
+ var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end
3183
+ var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start
3184
+ if (singleVLine) {
3185
+ if (leftEnd.top < rightStart.top - 2) {
3186
+ add(leftEnd.right, leftEnd.top, null, leftEnd.bottom)
3187
+ add(leftSide, rightStart.top, rightStart.left, rightStart.bottom)
3188
+ } else {
3189
+ add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom)
3190
+ }
3191
+ }
3192
+ if (leftEnd.bottom < rightStart.top)
3193
+ { add(leftSide, leftEnd.bottom, null, rightStart.top) }
3194
+ }
3195
+
3196
+ output.appendChild(fragment)
3197
+ }
3198
+
3199
+ // Cursor-blinking
3200
+ function restartBlink(cm) {
3201
+ if (!cm.state.focused) { return }
3202
+ var display = cm.display
3203
+ clearInterval(display.blinker)
3204
+ var on = true
3205
+ display.cursorDiv.style.visibility = ""
3206
+ if (cm.options.cursorBlinkRate > 0)
3207
+ { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden"; },
3208
+ cm.options.cursorBlinkRate) }
3209
+ else if (cm.options.cursorBlinkRate < 0)
3210
+ { display.cursorDiv.style.visibility = "hidden" }
3211
+ }
3212
+
3213
+ function ensureFocus(cm) {
3214
+ if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm) }
3215
+ }
3216
+
3217
+ function delayBlurEvent(cm) {
3218
+ cm.state.delayingBlurEvent = true
3219
+ setTimeout(function () { if (cm.state.delayingBlurEvent) {
3220
+ cm.state.delayingBlurEvent = false
3221
+ onBlur(cm)
3222
+ } }, 100)
3223
+ }
3224
+
3225
+ function onFocus(cm, e) {
3226
+ if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false }
3227
+
3228
+ if (cm.options.readOnly == "nocursor") { return }
3229
+ if (!cm.state.focused) {
3230
+ signal(cm, "focus", cm, e)
3231
+ cm.state.focused = true
3232
+ addClass(cm.display.wrapper, "CodeMirror-focused")
3233
+ // This test prevents this from firing when a context
3234
+ // menu is closed (since the input reset would kill the
3235
+ // select-all detection hack)
3236
+ if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
3237
+ cm.display.input.reset()
3238
+ if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20) } // Issue #1730
3239
+ }
3240
+ cm.display.input.receivedFocus()
3241
+ }
3242
+ restartBlink(cm)
3243
+ }
3244
+ function onBlur(cm, e) {
3245
+ if (cm.state.delayingBlurEvent) { return }
3246
+
3247
+ if (cm.state.focused) {
3248
+ signal(cm, "blur", cm, e)
3249
+ cm.state.focused = false
3250
+ rmClass(cm.display.wrapper, "CodeMirror-focused")
3251
+ }
3252
+ clearInterval(cm.display.blinker)
3253
+ setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false } }, 150)
3254
+ }
3255
+
3256
+ // Read the actual heights of the rendered lines, and update their
3257
+ // stored heights to match.
3258
+ function updateHeightsInViewport(cm) {
3259
+ var display = cm.display
3260
+ var prevBottom = display.lineDiv.offsetTop
3261
+ for (var i = 0; i < display.view.length; i++) {
3262
+ var cur = display.view[i], height = (void 0)
3263
+ if (cur.hidden) { continue }
3264
+ if (ie && ie_version < 8) {
3265
+ var bot = cur.node.offsetTop + cur.node.offsetHeight
3266
+ height = bot - prevBottom
3267
+ prevBottom = bot
3268
+ } else {
3269
+ var box = cur.node.getBoundingClientRect()
3270
+ height = box.bottom - box.top
3271
+ }
3272
+ var diff = cur.line.height - height
3273
+ if (height < 2) { height = textHeight(display) }
3274
+ if (diff > .005 || diff < -.005) {
3275
+ updateLineHeight(cur.line, height)
3276
+ updateWidgetHeight(cur.line)
3277
+ if (cur.rest) { for (var j = 0; j < cur.rest.length; j++)
3278
+ { updateWidgetHeight(cur.rest[j]) } }
3279
+ }
3280
+ }
3281
+ }
3282
+
3283
+ // Read and store the height of line widgets associated with the
3284
+ // given line.
3285
+ function updateWidgetHeight(line) {
3286
+ if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i) {
3287
+ var w = line.widgets[i], parent = w.node.parentNode
3288
+ if (parent) { w.height = parent.offsetHeight }
3289
+ } }
3290
+ }
3291
+
3292
+ // Compute the lines that are visible in a given viewport (defaults
3293
+ // the the current scroll position). viewport may contain top,
3294
+ // height, and ensure (see op.scrollToPos) properties.
3295
+ function visibleLines(display, doc, viewport) {
3296
+ var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop
3297
+ top = Math.floor(top - paddingTop(display))
3298
+ var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight
3299
+
3300
+ var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom)
3301
+ // Ensure is a {from: {line, ch}, to: {line, ch}} object, and
3302
+ // forces those lines into the viewport (if possible).
3303
+ if (viewport && viewport.ensure) {
3304
+ var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line
3305
+ if (ensureFrom < from) {
3306
+ from = ensureFrom
3307
+ to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight)
3308
+ } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
3309
+ from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight)
3310
+ to = ensureTo
3311
+ }
3312
+ }
3313
+ return {from: from, to: Math.max(to, from + 1)}
3314
+ }
3315
+
3316
+ // Re-align line numbers and gutter marks to compensate for
3317
+ // horizontal scrolling.
3318
+ function alignHorizontally(cm) {
3319
+ var display = cm.display, view = display.view
3320
+ if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return }
3321
+ var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft
3322
+ var gutterW = display.gutters.offsetWidth, left = comp + "px"
3323
+ for (var i = 0; i < view.length; i++) { if (!view[i].hidden) {
3324
+ if (cm.options.fixedGutter) {
3325
+ if (view[i].gutter)
3326
+ { view[i].gutter.style.left = left }
3327
+ if (view[i].gutterBackground)
3328
+ { view[i].gutterBackground.style.left = left }
3329
+ }
3330
+ var align = view[i].alignable
3331
+ if (align) { for (var j = 0; j < align.length; j++)
3332
+ { align[j].style.left = left } }
3333
+ } }
3334
+ if (cm.options.fixedGutter)
3335
+ { display.gutters.style.left = (comp + gutterW) + "px" }
3336
+ }
3337
+
3338
+ // Used to ensure that the line number gutter is still the right
3339
+ // size for the current document size. Returns true when an update
3340
+ // is needed.
3341
+ function maybeUpdateLineNumberWidth(cm) {
3342
+ if (!cm.options.lineNumbers) { return false }
3343
+ var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display
3344
+ if (last.length != display.lineNumChars) {
3345
+ var test = display.measure.appendChild(elt("div", [elt("div", last)],
3346
+ "CodeMirror-linenumber CodeMirror-gutter-elt"))
3347
+ var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW
3348
+ display.lineGutter.style.width = ""
3349
+ display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1
3350
+ display.lineNumWidth = display.lineNumInnerWidth + padding
3351
+ display.lineNumChars = display.lineNumInnerWidth ? last.length : -1
3352
+ display.lineGutter.style.width = display.lineNumWidth + "px"
3353
+ updateGutterSpace(cm)
3354
+ return true
3355
+ }
3356
+ return false
3357
+ }
3358
+
3359
+ // SCROLLING THINGS INTO VIEW
3360
+
3361
+ // If an editor sits on the top or bottom of the window, partially
3362
+ // scrolled out of view, this ensures that the cursor is visible.
3363
+ function maybeScrollWindow(cm, rect) {
3364
+ if (signalDOMEvent(cm, "scrollCursorIntoView")) { return }
3365
+
3366
+ var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null
3367
+ if (rect.top + box.top < 0) { doScroll = true }
3368
+ else if (rect.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false }
3369
+ if (doScroll != null && !phantom) {
3370
+ var scrollNode = elt("div", "\u200b", null, ("position: absolute;\n top: " + (rect.top - display.viewOffset - paddingTop(cm.display)) + "px;\n height: " + (rect.bottom - rect.top + scrollGap(cm) + display.barHeight) + "px;\n left: " + (rect.left) + "px; width: " + (Math.max(2, rect.right - rect.left)) + "px;"))
3371
+ cm.display.lineSpace.appendChild(scrollNode)
3372
+ scrollNode.scrollIntoView(doScroll)
3373
+ cm.display.lineSpace.removeChild(scrollNode)
3374
+ }
3375
+ }
3376
+
3377
+ // Scroll a given position into view (immediately), verifying that
3378
+ // it actually became visible (as line heights are accurately
3379
+ // measured, the position of something may 'drift' during drawing).
3380
+ function scrollPosIntoView(cm, pos, end, margin) {
3381
+ if (margin == null) { margin = 0 }
3382
+ var rect
3383
+ if (!cm.options.lineWrapping && pos == end) {
3384
+ // Set pos and end to the cursor positions around the character pos sticks to
3385
+ // If pos.sticky == "before", that is around pos.ch - 1, otherwise around pos.ch
3386
+ // If pos == Pos(_, 0, "before"), pos and end are unchanged
3387
+ pos = pos.ch ? Pos(pos.line, pos.sticky == "before" ? pos.ch - 1 : pos.ch, "after") : pos
3388
+ end = pos.sticky == "before" ? Pos(pos.line, pos.ch + 1, "before") : pos
3389
+ }
3390
+ for (var limit = 0; limit < 5; limit++) {
3391
+ var changed = false
3392
+ var coords = cursorCoords(cm, pos)
3393
+ var endCoords = !end || end == pos ? coords : cursorCoords(cm, end)
3394
+ rect = {left: Math.min(coords.left, endCoords.left),
3395
+ top: Math.min(coords.top, endCoords.top) - margin,
3396
+ right: Math.max(coords.left, endCoords.left),
3397
+ bottom: Math.max(coords.bottom, endCoords.bottom) + margin}
3398
+ var scrollPos = calculateScrollPos(cm, rect)
3399
+ var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft
3400
+ if (scrollPos.scrollTop != null) {
3401
+ updateScrollTop(cm, scrollPos.scrollTop)
3402
+ if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true }
3403
+ }
3404
+ if (scrollPos.scrollLeft != null) {
3405
+ setScrollLeft(cm, scrollPos.scrollLeft)
3406
+ if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true }
3407
+ }
3408
+ if (!changed) { break }
3409
+ }
3410
+ return rect
3411
+ }
3412
+
3413
+ // Scroll a given set of coordinates into view (immediately).
3414
+ function scrollIntoView(cm, rect) {
3415
+ var scrollPos = calculateScrollPos(cm, rect)
3416
+ if (scrollPos.scrollTop != null) { updateScrollTop(cm, scrollPos.scrollTop) }
3417
+ if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft) }
3418
+ }
3419
+
3420
+ // Calculate a new scroll position needed to scroll the given
3421
+ // rectangle into view. Returns an object with scrollTop and
3422
+ // scrollLeft properties. When these are undefined, the
3423
+ // vertical/horizontal position does not need to be adjusted.
3424
+ function calculateScrollPos(cm, rect) {
3425
+ var display = cm.display, snapMargin = textHeight(cm.display)
3426
+ if (rect.top < 0) { rect.top = 0 }
3427
+ var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop
3428
+ var screen = displayHeight(cm), result = {}
3429
+ if (rect.bottom - rect.top > screen) { rect.bottom = rect.top + screen }
3430
+ var docBottom = cm.doc.height + paddingVert(display)
3431
+ var atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin
3432
+ if (rect.top < screentop) {
3433
+ result.scrollTop = atTop ? 0 : rect.top
3434
+ } else if (rect.bottom > screentop + screen) {
3435
+ var newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen)
3436
+ if (newTop != screentop) { result.scrollTop = newTop }
3437
+ }
3438
+
3439
+ var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft
3440
+ var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0)
3441
+ var tooWide = rect.right - rect.left > screenw
3442
+ if (tooWide) { rect.right = rect.left + screenw }
3443
+ if (rect.left < 10)
3444
+ { result.scrollLeft = 0 }
3445
+ else if (rect.left < screenleft)
3446
+ { result.scrollLeft = Math.max(0, rect.left - (tooWide ? 0 : 10)) }
3447
+ else if (rect.right > screenw + screenleft - 3)
3448
+ { result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw }
3449
+ return result
3450
+ }
3451
+
3452
+ // Store a relative adjustment to the scroll position in the current
3453
+ // operation (to be applied when the operation finishes).
3454
+ function addToScrollTop(cm, top) {
3455
+ if (top == null) { return }
3456
+ resolveScrollToPos(cm)
3457
+ cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top
3458
+ }
3459
+
3460
+ // Make sure that at the end of the operation the current cursor is
3461
+ // shown.
3462
+ function ensureCursorVisible(cm) {
3463
+ resolveScrollToPos(cm)
3464
+ var cur = cm.getCursor()
3465
+ cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin}
3466
+ }
3467
+
3468
+ function scrollToCoords(cm, x, y) {
3469
+ if (x != null || y != null) { resolveScrollToPos(cm) }
3470
+ if (x != null) { cm.curOp.scrollLeft = x }
3471
+ if (y != null) { cm.curOp.scrollTop = y }
3472
+ }
3473
+
3474
+ function scrollToRange(cm, range) {
3475
+ resolveScrollToPos(cm)
3476
+ cm.curOp.scrollToPos = range
3477
+ }
3478
+
3479
+ // When an operation has its scrollToPos property set, and another
3480
+ // scroll action is applied before the end of the operation, this
3481
+ // 'simulates' scrolling that position into view in a cheap way, so
3482
+ // that the effect of intermediate scroll commands is not ignored.
3483
+ function resolveScrollToPos(cm) {
3484
+ var range = cm.curOp.scrollToPos
3485
+ if (range) {
3486
+ cm.curOp.scrollToPos = null
3487
+ var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to)
3488
+ scrollToCoordsRange(cm, from, to, range.margin)
3489
+ }
3490
+ }
3491
+
3492
+ function scrollToCoordsRange(cm, from, to, margin) {
3493
+ var sPos = calculateScrollPos(cm, {
3494
+ left: Math.min(from.left, to.left),
3495
+ top: Math.min(from.top, to.top) - margin,
3496
+ right: Math.max(from.right, to.right),
3497
+ bottom: Math.max(from.bottom, to.bottom) + margin
3498
+ })
3499
+ scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop)
3500
+ }
3501
+
3502
+ // Sync the scrollable area and scrollbars, ensure the viewport
3503
+ // covers the visible area.
3504
+ function updateScrollTop(cm, val) {
3505
+ if (Math.abs(cm.doc.scrollTop - val) < 2) { return }
3506
+ if (!gecko) { updateDisplaySimple(cm, {top: val}) }
3507
+ setScrollTop(cm, val, true)
3508
+ if (gecko) { updateDisplaySimple(cm) }
3509
+ startWorker(cm, 100)
3510
+ }
3511
+
3512
+ function setScrollTop(cm, val, forceScroll) {
3513
+ val = Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val)
3514
+ if (cm.display.scroller.scrollTop == val && !forceScroll) { return }
3515
+ cm.doc.scrollTop = val
3516
+ cm.display.scrollbars.setScrollTop(val)
3517
+ if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val }
3518
+ }
3519
+
3520
+ // Sync scroller and scrollbar, ensure the gutter elements are
3521
+ // aligned.
3522
+ function setScrollLeft(cm, val, isScroller, forceScroll) {
3523
+ val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth)
3524
+ if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) { return }
3525
+ cm.doc.scrollLeft = val
3526
+ alignHorizontally(cm)
3527
+ if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val }
3528
+ cm.display.scrollbars.setScrollLeft(val)
3529
+ }
3530
+
3531
+ // SCROLLBARS
3532
+
3533
+ // Prepare DOM reads needed to update the scrollbars. Done in one
3534
+ // shot to minimize update/measure roundtrips.
3535
+ function measureForScrollbars(cm) {
3536
+ var d = cm.display, gutterW = d.gutters.offsetWidth
3537
+ var docH = Math.round(cm.doc.height + paddingVert(cm.display))
3538
+ return {
3539
+ clientHeight: d.scroller.clientHeight,
3540
+ viewHeight: d.wrapper.clientHeight,
3541
+ scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
3542
+ viewWidth: d.wrapper.clientWidth,
3543
+ barLeft: cm.options.fixedGutter ? gutterW : 0,
3544
+ docHeight: docH,
3545
+ scrollHeight: docH + scrollGap(cm) + d.barHeight,
3546
+ nativeBarWidth: d.nativeBarWidth,
3547
+ gutterWidth: gutterW
3548
+ }
3549
+ }
3550
+
3551
+ var NativeScrollbars = function(place, scroll, cm) {
3552
+ this.cm = cm
3553
+ var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar")
3554
+ var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar")
3555
+ vert.tabIndex = horiz.tabIndex = -1
3556
+ place(vert); place(horiz)
3557
+
3558
+ on(vert, "scroll", function () {
3559
+ if (vert.clientHeight) { scroll(vert.scrollTop, "vertical") }
3560
+ })
3561
+ on(horiz, "scroll", function () {
3562
+ if (horiz.clientWidth) { scroll(horiz.scrollLeft, "horizontal") }
3563
+ })
3564
+
3565
+ this.checkedZeroWidth = false
3566
+ // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
3567
+ if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = "18px" }
3568
+ };
3569
+
3570
+ NativeScrollbars.prototype.update = function (measure) {
3571
+ var needsH = measure.scrollWidth > measure.clientWidth + 1
3572
+ var needsV = measure.scrollHeight > measure.clientHeight + 1
3573
+ var sWidth = measure.nativeBarWidth
3574
+
3575
+ if (needsV) {
3576
+ this.vert.style.display = "block"
3577
+ this.vert.style.bottom = needsH ? sWidth + "px" : "0"
3578
+ var totalHeight = measure.viewHeight - (needsH ? sWidth : 0)
3579
+ // A bug in IE8 can cause this value to be negative, so guard it.
3580
+ this.vert.firstChild.style.height =
3581
+ Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px"
3582
+ } else {
3583
+ this.vert.style.display = ""
3584
+ this.vert.firstChild.style.height = "0"
3585
+ }
3586
+
3587
+ if (needsH) {
3588
+ this.horiz.style.display = "block"
3589
+ this.horiz.style.right = needsV ? sWidth + "px" : "0"
3590
+ this.horiz.style.left = measure.barLeft + "px"
3591
+ var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0)
3592
+ this.horiz.firstChild.style.width =
3593
+ Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + "px"
3594
+ } else {
3595
+ this.horiz.style.display = ""
3596
+ this.horiz.firstChild.style.width = "0"
3597
+ }
3598
+
3599
+ if (!this.checkedZeroWidth && measure.clientHeight > 0) {
3600
+ if (sWidth == 0) { this.zeroWidthHack() }
3601
+ this.checkedZeroWidth = true
3602
+ }
3603
+
3604
+ return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}
3605
+ };
3606
+
3607
+ NativeScrollbars.prototype.setScrollLeft = function (pos) {
3608
+ if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos }
3609
+ if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz, "horiz") }
3610
+ };
3611
+
3612
+ NativeScrollbars.prototype.setScrollTop = function (pos) {
3613
+ if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos }
3614
+ if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert, "vert") }
3615
+ };
3616
+
3617
+ NativeScrollbars.prototype.zeroWidthHack = function () {
3618
+ var w = mac && !mac_geMountainLion ? "12px" : "18px"
3619
+ this.horiz.style.height = this.vert.style.width = w
3620
+ this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none"
3621
+ this.disableHoriz = new Delayed
3622
+ this.disableVert = new Delayed
3623
+ };
3624
+
3625
+ NativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay, type) {
3626
+ bar.style.pointerEvents = "auto"
3627
+ function maybeDisable() {
3628
+ // To find out whether the scrollbar is still visible, we
3629
+ // check whether the element under the pixel in the bottom
3630
+ // right corner of the scrollbar box is the scrollbar box
3631
+ // itself (when the bar is still visible) or its filler child
3632
+ // (when the bar is hidden). If it is still visible, we keep
3633
+ // it enabled, if it's hidden, we disable pointer events.
3634
+ var box = bar.getBoundingClientRect()
3635
+ var elt = type == "vert" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2)
3636
+ : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1)
3637
+ if (elt != bar) { bar.style.pointerEvents = "none" }
3638
+ else { delay.set(1000, maybeDisable) }
3639
+ }
3640
+ delay.set(1000, maybeDisable)
3641
+ };
3642
+
3643
+ NativeScrollbars.prototype.clear = function () {
3644
+ var parent = this.horiz.parentNode
3645
+ parent.removeChild(this.horiz)
3646
+ parent.removeChild(this.vert)
3647
+ };
3648
+
3649
+ var NullScrollbars = function () {};
3650
+
3651
+ NullScrollbars.prototype.update = function () { return {bottom: 0, right: 0} };
3652
+ NullScrollbars.prototype.setScrollLeft = function () {};
3653
+ NullScrollbars.prototype.setScrollTop = function () {};
3654
+ NullScrollbars.prototype.clear = function () {};
3655
+
3656
+ function updateScrollbars(cm, measure) {
3657
+ if (!measure) { measure = measureForScrollbars(cm) }
3658
+ var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight
3659
+ updateScrollbarsInner(cm, measure)
3660
+ for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {
3661
+ if (startWidth != cm.display.barWidth && cm.options.lineWrapping)
3662
+ { updateHeightsInViewport(cm) }
3663
+ updateScrollbarsInner(cm, measureForScrollbars(cm))
3664
+ startWidth = cm.display.barWidth; startHeight = cm.display.barHeight
3665
+ }
3666
+ }
3667
+
3668
+ // Re-synchronize the fake scrollbars with the actual size of the
3669
+ // content.
3670
+ function updateScrollbarsInner(cm, measure) {
3671
+ var d = cm.display
3672
+ var sizes = d.scrollbars.update(measure)
3673
+
3674
+ d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px"
3675
+ d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px"
3676
+ d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent"
3677
+
3678
+ if (sizes.right && sizes.bottom) {
3679
+ d.scrollbarFiller.style.display = "block"
3680
+ d.scrollbarFiller.style.height = sizes.bottom + "px"
3681
+ d.scrollbarFiller.style.width = sizes.right + "px"
3682
+ } else { d.scrollbarFiller.style.display = "" }
3683
+ if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
3684
+ d.gutterFiller.style.display = "block"
3685
+ d.gutterFiller.style.height = sizes.bottom + "px"
3686
+ d.gutterFiller.style.width = measure.gutterWidth + "px"
3687
+ } else { d.gutterFiller.style.display = "" }
3688
+ }
3689
+
3690
+ var scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars}
3691
+
3692
+ function initScrollbars(cm) {
3693
+ if (cm.display.scrollbars) {
3694
+ cm.display.scrollbars.clear()
3695
+ if (cm.display.scrollbars.addClass)
3696
+ { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass) }
3697
+ }
3698
+
3699
+ cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {
3700
+ cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller)
3701
+ // Prevent clicks in the scrollbars from killing focus
3702
+ on(node, "mousedown", function () {
3703
+ if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0) }
3704
+ })
3705
+ node.setAttribute("cm-not-content", "true")
3706
+ }, function (pos, axis) {
3707
+ if (axis == "horizontal") { setScrollLeft(cm, pos) }
3708
+ else { updateScrollTop(cm, pos) }
3709
+ }, cm)
3710
+ if (cm.display.scrollbars.addClass)
3711
+ { addClass(cm.display.wrapper, cm.display.scrollbars.addClass) }
3712
+ }
3713
+
3714
+ // Operations are used to wrap a series of changes to the editor
3715
+ // state in such a way that each change won't have to update the
3716
+ // cursor and display (which would be awkward, slow, and
3717
+ // error-prone). Instead, display updates are batched and then all
3718
+ // combined and executed at once.
3719
+
3720
+ var nextOpId = 0
3721
+ // Start a new operation.
3722
+ function startOperation(cm) {
3723
+ cm.curOp = {
3724
+ cm: cm,
3725
+ viewChanged: false, // Flag that indicates that lines might need to be redrawn
3726
+ startHeight: cm.doc.height, // Used to detect need to update scrollbar
3727
+ forceUpdate: false, // Used to force a redraw
3728
+ updateInput: null, // Whether to reset the input textarea
3729
+ typing: false, // Whether this reset should be careful to leave existing text (for compositing)
3730
+ changeObjs: null, // Accumulated changes, for firing change events
3731
+ cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
3732
+ cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
3733
+ selectionChanged: false, // Whether the selection needs to be redrawn
3734
+ updateMaxLine: false, // Set when the widest line needs to be determined anew
3735
+ scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
3736
+ scrollToPos: null, // Used to scroll to a specific position
3737
+ focus: false,
3738
+ id: ++nextOpId // Unique ID
3739
+ }
3740
+ pushOperation(cm.curOp)
3741
+ }
3742
+
3743
+ // Finish an operation, updating the display and signalling delayed events
3744
+ function endOperation(cm) {
3745
+ var op = cm.curOp
3746
+ finishOperation(op, function (group) {
3747
+ for (var i = 0; i < group.ops.length; i++)
3748
+ { group.ops[i].cm.curOp = null }
3749
+ endOperations(group)
3750
+ })
3751
+ }
3752
+
3753
+ // The DOM updates done when an operation finishes are batched so
3754
+ // that the minimum number of relayouts are required.
3755
+ function endOperations(group) {
3756
+ var ops = group.ops
3757
+ for (var i = 0; i < ops.length; i++) // Read DOM
3758
+ { endOperation_R1(ops[i]) }
3759
+ for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)
3760
+ { endOperation_W1(ops[i$1]) }
3761
+ for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM
3762
+ { endOperation_R2(ops[i$2]) }
3763
+ for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)
3764
+ { endOperation_W2(ops[i$3]) }
3765
+ for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM
3766
+ { endOperation_finish(ops[i$4]) }
3767
+ }
3768
+
3769
+ function endOperation_R1(op) {
3770
+ var cm = op.cm, display = cm.display
3771
+ maybeClipScrollbars(cm)
3772
+ if (op.updateMaxLine) { findMaxLine(cm) }
3773
+
3774
+ op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
3775
+ op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
3776
+ op.scrollToPos.to.line >= display.viewTo) ||
3777
+ display.maxLineChanged && cm.options.lineWrapping
3778
+ op.update = op.mustUpdate &&
3779
+ new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate)
3780
+ }
3781
+
3782
+ function endOperation_W1(op) {
3783
+ op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update)
3784
+ }
3785
+
3786
+ function endOperation_R2(op) {
3787
+ var cm = op.cm, display = cm.display
3788
+ if (op.updatedDisplay) { updateHeightsInViewport(cm) }
3789
+
3790
+ op.barMeasure = measureForScrollbars(cm)
3791
+
3792
+ // If the max line changed since it was last measured, measure it,
3793
+ // and ensure the document's width matches it.
3794
+ // updateDisplay_W2 will use these properties to do the actual resizing
3795
+ if (display.maxLineChanged && !cm.options.lineWrapping) {
3796
+ op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3
3797
+ cm.display.sizerWidth = op.adjustWidthTo
3798
+ op.barMeasure.scrollWidth =
3799
+ Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth)
3800
+ op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm))
3801
+ }
3802
+
3803
+ if (op.updatedDisplay || op.selectionChanged)
3804
+ { op.preparedSelection = display.input.prepareSelection() }
3805
+ }
3806
+
3807
+ function endOperation_W2(op) {
3808
+ var cm = op.cm
3809
+
3810
+ if (op.adjustWidthTo != null) {
3811
+ cm.display.sizer.style.minWidth = op.adjustWidthTo + "px"
3812
+ if (op.maxScrollLeft < cm.doc.scrollLeft)
3813
+ { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true) }
3814
+ cm.display.maxLineChanged = false
3815
+ }
3816
+
3817
+ var takeFocus = op.focus && op.focus == activeElt()
3818
+ if (op.preparedSelection)
3819
+ { cm.display.input.showSelection(op.preparedSelection, takeFocus) }
3820
+ if (op.updatedDisplay || op.startHeight != cm.doc.height)
3821
+ { updateScrollbars(cm, op.barMeasure) }
3822
+ if (op.updatedDisplay)
3823
+ { setDocumentHeight(cm, op.barMeasure) }
3824
+
3825
+ if (op.selectionChanged) { restartBlink(cm) }
3826
+
3827
+ if (cm.state.focused && op.updateInput)
3828
+ { cm.display.input.reset(op.typing) }
3829
+ if (takeFocus) { ensureFocus(op.cm) }
3830
+ }
3831
+
3832
+ function endOperation_finish(op) {
3833
+ var cm = op.cm, display = cm.display, doc = cm.doc
3834
+
3835
+ if (op.updatedDisplay) { postUpdateDisplay(cm, op.update) }
3836
+
3837
+ // Abort mouse wheel delta measurement, when scrolling explicitly
3838
+ if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
3839
+ { display.wheelStartX = display.wheelStartY = null }
3840
+
3841
+ // Propagate the scroll position to the actual DOM scroller
3842
+ if (op.scrollTop != null) { setScrollTop(cm, op.scrollTop, op.forceScroll) }
3843
+
3844
+ if (op.scrollLeft != null) { setScrollLeft(cm, op.scrollLeft, true, true) }
3845
+ // If we need to scroll a specific position into view, do so.
3846
+ if (op.scrollToPos) {
3847
+ var rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
3848
+ clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin)
3849
+ maybeScrollWindow(cm, rect)
3850
+ }
3851
+
3852
+ // Fire events for markers that are hidden/unidden by editing or
3853
+ // undoing
3854
+ var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers
3855
+ if (hidden) { for (var i = 0; i < hidden.length; ++i)
3856
+ { if (!hidden[i].lines.length) { signal(hidden[i], "hide") } } }
3857
+ if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1)
3858
+ { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], "unhide") } } }
3859
+
3860
+ if (display.wrapper.offsetHeight)
3861
+ { doc.scrollTop = cm.display.scroller.scrollTop }
3862
+
3863
+ // Fire change events, and delayed event handlers
3864
+ if (op.changeObjs)
3865
+ { signal(cm, "changes", cm, op.changeObjs) }
3866
+ if (op.update)
3867
+ { op.update.finish() }
3868
+ }
3869
+
3870
+ // Run the given function in an operation
3871
+ function runInOp(cm, f) {
3872
+ if (cm.curOp) { return f() }
3873
+ startOperation(cm)
3874
+ try { return f() }
3875
+ finally { endOperation(cm) }
3876
+ }
3877
+ // Wraps a function in an operation. Returns the wrapped function.
3878
+ function operation(cm, f) {
3879
+ return function() {
3880
+ if (cm.curOp) { return f.apply(cm, arguments) }
3881
+ startOperation(cm)
3882
+ try { return f.apply(cm, arguments) }
3883
+ finally { endOperation(cm) }
3884
+ }
3885
+ }
3886
+ // Used to add methods to editor and doc instances, wrapping them in
3887
+ // operations.
3888
+ function methodOp(f) {
3889
+ return function() {
3890
+ if (this.curOp) { return f.apply(this, arguments) }
3891
+ startOperation(this)
3892
+ try { return f.apply(this, arguments) }
3893
+ finally { endOperation(this) }
3894
+ }
3895
+ }
3896
+ function docMethodOp(f) {
3897
+ return function() {
3898
+ var cm = this.cm
3899
+ if (!cm || cm.curOp) { return f.apply(this, arguments) }
3900
+ startOperation(cm)
3901
+ try { return f.apply(this, arguments) }
3902
+ finally { endOperation(cm) }
3903
+ }
3904
+ }
3905
+
3906
+ // Updates the display.view data structure for a given change to the
3907
+ // document. From and to are in pre-change coordinates. Lendiff is
3908
+ // the amount of lines added or subtracted by the change. This is
3909
+ // used for changes that span multiple lines, or change the way
3910
+ // lines are divided into visual lines. regLineChange (below)
3911
+ // registers single-line changes.
3912
+ function regChange(cm, from, to, lendiff) {
3913
+ if (from == null) { from = cm.doc.first }
3914
+ if (to == null) { to = cm.doc.first + cm.doc.size }
3915
+ if (!lendiff) { lendiff = 0 }
3916
+
3917
+ var display = cm.display
3918
+ if (lendiff && to < display.viewTo &&
3919
+ (display.updateLineNumbers == null || display.updateLineNumbers > from))
3920
+ { display.updateLineNumbers = from }
3921
+
3922
+ cm.curOp.viewChanged = true
3923
+
3924
+ if (from >= display.viewTo) { // Change after
3925
+ if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
3926
+ { resetView(cm) }
3927
+ } else if (to <= display.viewFrom) { // Change before
3928
+ if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
3929
+ resetView(cm)
3930
+ } else {
3931
+ display.viewFrom += lendiff
3932
+ display.viewTo += lendiff
3933
+ }
3934
+ } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
3935
+ resetView(cm)
3936
+ } else if (from <= display.viewFrom) { // Top overlap
3937
+ var cut = viewCuttingPoint(cm, to, to + lendiff, 1)
3938
+ if (cut) {
3939
+ display.view = display.view.slice(cut.index)
3940
+ display.viewFrom = cut.lineN
3941
+ display.viewTo += lendiff
3942
+ } else {
3943
+ resetView(cm)
3944
+ }
3945
+ } else if (to >= display.viewTo) { // Bottom overlap
3946
+ var cut$1 = viewCuttingPoint(cm, from, from, -1)
3947
+ if (cut$1) {
3948
+ display.view = display.view.slice(0, cut$1.index)
3949
+ display.viewTo = cut$1.lineN
3950
+ } else {
3951
+ resetView(cm)
3952
+ }
3953
+ } else { // Gap in the middle
3954
+ var cutTop = viewCuttingPoint(cm, from, from, -1)
3955
+ var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1)
3956
+ if (cutTop && cutBot) {
3957
+ display.view = display.view.slice(0, cutTop.index)
3958
+ .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
3959
+ .concat(display.view.slice(cutBot.index))
3960
+ display.viewTo += lendiff
3961
+ } else {
3962
+ resetView(cm)
3963
+ }
3964
+ }
3965
+
3966
+ var ext = display.externalMeasured
3967
+ if (ext) {
3968
+ if (to < ext.lineN)
3969
+ { ext.lineN += lendiff }
3970
+ else if (from < ext.lineN + ext.size)
3971
+ { display.externalMeasured = null }
3972
+ }
3973
+ }
3974
+
3975
+ // Register a change to a single line. Type must be one of "text",
3976
+ // "gutter", "class", "widget"
3977
+ function regLineChange(cm, line, type) {
3978
+ cm.curOp.viewChanged = true
3979
+ var display = cm.display, ext = cm.display.externalMeasured
3980
+ if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
3981
+ { display.externalMeasured = null }
3982
+
3983
+ if (line < display.viewFrom || line >= display.viewTo) { return }
3984
+ var lineView = display.view[findViewIndex(cm, line)]
3985
+ if (lineView.node == null) { return }
3986
+ var arr = lineView.changes || (lineView.changes = [])
3987
+ if (indexOf(arr, type) == -1) { arr.push(type) }
3988
+ }
3989
+
3990
+ // Clear the view.
3991
+ function resetView(cm) {
3992
+ cm.display.viewFrom = cm.display.viewTo = cm.doc.first
3993
+ cm.display.view = []
3994
+ cm.display.viewOffset = 0
3995
+ }
3996
+
3997
+ function viewCuttingPoint(cm, oldN, newN, dir) {
3998
+ var index = findViewIndex(cm, oldN), diff, view = cm.display.view
3999
+ if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)
4000
+ { return {index: index, lineN: newN} }
4001
+ var n = cm.display.viewFrom
4002
+ for (var i = 0; i < index; i++)
4003
+ { n += view[i].size }
4004
+ if (n != oldN) {
4005
+ if (dir > 0) {
4006
+ if (index == view.length - 1) { return null }
4007
+ diff = (n + view[index].size) - oldN
4008
+ index++
4009
+ } else {
4010
+ diff = n - oldN
4011
+ }
4012
+ oldN += diff; newN += diff
4013
+ }
4014
+ while (visualLineNo(cm.doc, newN) != newN) {
4015
+ if (index == (dir < 0 ? 0 : view.length - 1)) { return null }
4016
+ newN += dir * view[index - (dir < 0 ? 1 : 0)].size
4017
+ index += dir
4018
+ }
4019
+ return {index: index, lineN: newN}
4020
+ }
4021
+
4022
+ // Force the view to cover a given range, adding empty view element
4023
+ // or clipping off existing ones as needed.
4024
+ function adjustView(cm, from, to) {
4025
+ var display = cm.display, view = display.view
4026
+ if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
4027
+ display.view = buildViewArray(cm, from, to)
4028
+ display.viewFrom = from
4029
+ } else {
4030
+ if (display.viewFrom > from)
4031
+ { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view) }
4032
+ else if (display.viewFrom < from)
4033
+ { display.view = display.view.slice(findViewIndex(cm, from)) }
4034
+ display.viewFrom = from
4035
+ if (display.viewTo < to)
4036
+ { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)) }
4037
+ else if (display.viewTo > to)
4038
+ { display.view = display.view.slice(0, findViewIndex(cm, to)) }
4039
+ }
4040
+ display.viewTo = to
4041
+ }
4042
+
4043
+ // Count the number of lines in the view whose DOM representation is
4044
+ // out of date (or nonexistent).
4045
+ function countDirtyView(cm) {
4046
+ var view = cm.display.view, dirty = 0
4047
+ for (var i = 0; i < view.length; i++) {
4048
+ var lineView = view[i]
4049
+ if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty }
4050
+ }
4051
+ return dirty
4052
+ }
4053
+
4054
+ // HIGHLIGHT WORKER
4055
+
4056
+ function startWorker(cm, time) {
4057
+ if (cm.doc.highlightFrontier < cm.display.viewTo)
4058
+ { cm.state.highlight.set(time, bind(highlightWorker, cm)) }
4059
+ }
4060
+
4061
+ function highlightWorker(cm) {
4062
+ var doc = cm.doc
4063
+ if (doc.highlightFrontier >= cm.display.viewTo) { return }
4064
+ var end = +new Date + cm.options.workTime
4065
+ var context = getContextBefore(cm, doc.highlightFrontier)
4066
+ var changedLines = []
4067
+
4068
+ doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {
4069
+ if (context.line >= cm.display.viewFrom) { // Visible
4070
+ var oldStyles = line.styles
4071
+ var resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null
4072
+ var highlighted = highlightLine(cm, line, context, true)
4073
+ if (resetState) { context.state = resetState }
4074
+ line.styles = highlighted.styles
4075
+ var oldCls = line.styleClasses, newCls = highlighted.classes
4076
+ if (newCls) { line.styleClasses = newCls }
4077
+ else if (oldCls) { line.styleClasses = null }
4078
+ var ischange = !oldStyles || oldStyles.length != line.styles.length ||
4079
+ oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass)
4080
+ for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i] }
4081
+ if (ischange) { changedLines.push(context.line) }
4082
+ line.stateAfter = context.save()
4083
+ context.nextLine()
4084
+ } else {
4085
+ if (line.text.length <= cm.options.maxHighlightLength)
4086
+ { processLine(cm, line.text, context) }
4087
+ line.stateAfter = context.line % 5 == 0 ? context.save() : null
4088
+ context.nextLine()
4089
+ }
4090
+ if (+new Date > end) {
4091
+ startWorker(cm, cm.options.workDelay)
4092
+ return true
4093
+ }
4094
+ })
4095
+ doc.highlightFrontier = context.line
4096
+ doc.modeFrontier = Math.max(doc.modeFrontier, context.line)
4097
+ if (changedLines.length) { runInOp(cm, function () {
4098
+ for (var i = 0; i < changedLines.length; i++)
4099
+ { regLineChange(cm, changedLines[i], "text") }
4100
+ }) }
4101
+ }
4102
+
4103
+ // DISPLAY DRAWING
4104
+
4105
+ var DisplayUpdate = function(cm, viewport, force) {
4106
+ var display = cm.display
4107
+
4108
+ this.viewport = viewport
4109
+ // Store some values that we'll need later (but don't want to force a relayout for)
4110
+ this.visible = visibleLines(display, cm.doc, viewport)
4111
+ this.editorIsHidden = !display.wrapper.offsetWidth
4112
+ this.wrapperHeight = display.wrapper.clientHeight
4113
+ this.wrapperWidth = display.wrapper.clientWidth
4114
+ this.oldDisplayWidth = displayWidth(cm)
4115
+ this.force = force
4116
+ this.dims = getDimensions(cm)
4117
+ this.events = []
4118
+ };
4119
+
4120
+ DisplayUpdate.prototype.signal = function (emitter, type) {
4121
+ if (hasHandler(emitter, type))
4122
+ { this.events.push(arguments) }
4123
+ };
4124
+ DisplayUpdate.prototype.finish = function () {
4125
+ var this$1 = this;
4126
+
4127
+ for (var i = 0; i < this.events.length; i++)
4128
+ { signal.apply(null, this$1.events[i]) }
4129
+ };
4130
+
4131
+ function maybeClipScrollbars(cm) {
4132
+ var display = cm.display
4133
+ if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
4134
+ display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth
4135
+ display.heightForcer.style.height = scrollGap(cm) + "px"
4136
+ display.sizer.style.marginBottom = -display.nativeBarWidth + "px"
4137
+ display.sizer.style.borderRightWidth = scrollGap(cm) + "px"
4138
+ display.scrollbarsClipped = true
4139
+ }
4140
+ }
4141
+
4142
+ function selectionSnapshot(cm) {
4143
+ if (cm.hasFocus()) { return null }
4144
+ var active = activeElt()
4145
+ if (!active || !contains(cm.display.lineDiv, active)) { return null }
4146
+ var result = {activeElt: active}
4147
+ if (window.getSelection) {
4148
+ var sel = window.getSelection()
4149
+ if (sel.anchorNode && sel.extend && contains(cm.display.lineDiv, sel.anchorNode)) {
4150
+ result.anchorNode = sel.anchorNode
4151
+ result.anchorOffset = sel.anchorOffset
4152
+ result.focusNode = sel.focusNode
4153
+ result.focusOffset = sel.focusOffset
4154
+ }
4155
+ }
4156
+ return result
4157
+ }
4158
+
4159
+ function restoreSelection(snapshot) {
4160
+ if (!snapshot || !snapshot.activeElt || snapshot.activeElt == activeElt()) { return }
4161
+ snapshot.activeElt.focus()
4162
+ if (snapshot.anchorNode && contains(document.body, snapshot.anchorNode) && contains(document.body, snapshot.focusNode)) {
4163
+ var sel = window.getSelection(), range = document.createRange()
4164
+ range.setEnd(snapshot.anchorNode, snapshot.anchorOffset)
4165
+ range.collapse(false)
4166
+ sel.removeAllRanges()
4167
+ sel.addRange(range)
4168
+ sel.extend(snapshot.focusNode, snapshot.focusOffset)
4169
+ }
4170
+ }
4171
+
4172
+ // Does the actual updating of the line display. Bails out
4173
+ // (returning false) when there is nothing to be done and forced is
4174
+ // false.
4175
+ function updateDisplayIfNeeded(cm, update) {
4176
+ var display = cm.display, doc = cm.doc
4177
+
4178
+ if (update.editorIsHidden) {
4179
+ resetView(cm)
4180
+ return false
4181
+ }
4182
+
4183
+ // Bail out if the visible area is already rendered and nothing changed.
4184
+ if (!update.force &&
4185
+ update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
4186
+ (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
4187
+ display.renderedView == display.view && countDirtyView(cm) == 0)
4188
+ { return false }
4189
+
4190
+ if (maybeUpdateLineNumberWidth(cm)) {
4191
+ resetView(cm)
4192
+ update.dims = getDimensions(cm)
4193
+ }
4194
+
4195
+ // Compute a suitable new viewport (from & to)
4196
+ var end = doc.first + doc.size
4197
+ var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first)
4198
+ var to = Math.min(end, update.visible.to + cm.options.viewportMargin)
4199
+ if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom) }
4200
+ if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo) }
4201
+ if (sawCollapsedSpans) {
4202
+ from = visualLineNo(cm.doc, from)
4203
+ to = visualLineEndNo(cm.doc, to)
4204
+ }
4205
+
4206
+ var different = from != display.viewFrom || to != display.viewTo ||
4207
+ display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth
4208
+ adjustView(cm, from, to)
4209
+
4210
+ display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom))
4211
+ // Position the mover div to align with the current scroll position
4212
+ cm.display.mover.style.top = display.viewOffset + "px"
4213
+
4214
+ var toUpdate = countDirtyView(cm)
4215
+ if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
4216
+ (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
4217
+ { return false }
4218
+
4219
+ // For big changes, we hide the enclosing element during the
4220
+ // update, since that speeds up the operations on most browsers.
4221
+ var selSnapshot = selectionSnapshot(cm)
4222
+ if (toUpdate > 4) { display.lineDiv.style.display = "none" }
4223
+ patchDisplay(cm, display.updateLineNumbers, update.dims)
4224
+ if (toUpdate > 4) { display.lineDiv.style.display = "" }
4225
+ display.renderedView = display.view
4226
+ // There might have been a widget with a focused element that got
4227
+ // hidden or updated, if so re-focus it.
4228
+ restoreSelection(selSnapshot)
4229
+
4230
+ // Prevent selection and cursors from interfering with the scroll
4231
+ // width and height.
4232
+ removeChildren(display.cursorDiv)
4233
+ removeChildren(display.selectionDiv)
4234
+ display.gutters.style.height = display.sizer.style.minHeight = 0
4235
+
4236
+ if (different) {
4237
+ display.lastWrapHeight = update.wrapperHeight
4238
+ display.lastWrapWidth = update.wrapperWidth
4239
+ startWorker(cm, 400)
4240
+ }
4241
+
4242
+ display.updateLineNumbers = null
4243
+
4244
+ return true
4245
+ }
4246
+
4247
+ function postUpdateDisplay(cm, update) {
4248
+ var viewport = update.viewport
4249
+
4250
+ for (var first = true;; first = false) {
4251
+ if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {
4252
+ // Clip forced viewport to actual scrollable area.
4253
+ if (viewport && viewport.top != null)
4254
+ { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)} }
4255
+ // Updated line heights might result in the drawn area not
4256
+ // actually covering the viewport. Keep looping until it does.
4257
+ update.visible = visibleLines(cm.display, cm.doc, viewport)
4258
+ if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
4259
+ { break }
4260
+ }
4261
+ if (!updateDisplayIfNeeded(cm, update)) { break }
4262
+ updateHeightsInViewport(cm)
4263
+ var barMeasure = measureForScrollbars(cm)
4264
+ updateSelection(cm)
4265
+ updateScrollbars(cm, barMeasure)
4266
+ setDocumentHeight(cm, barMeasure)
4267
+ update.force = false
4268
+ }
4269
+
4270
+ update.signal(cm, "update", cm)
4271
+ if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
4272
+ update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo)
4273
+ cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo
4274
+ }
4275
+ }
4276
+
4277
+ function updateDisplaySimple(cm, viewport) {
4278
+ var update = new DisplayUpdate(cm, viewport)
4279
+ if (updateDisplayIfNeeded(cm, update)) {
4280
+ updateHeightsInViewport(cm)
4281
+ postUpdateDisplay(cm, update)
4282
+ var barMeasure = measureForScrollbars(cm)
4283
+ updateSelection(cm)
4284
+ updateScrollbars(cm, barMeasure)
4285
+ setDocumentHeight(cm, barMeasure)
4286
+ update.finish()
4287
+ }
4288
+ }
4289
+
4290
+ // Sync the actual display DOM structure with display.view, removing
4291
+ // nodes for lines that are no longer in view, and creating the ones
4292
+ // that are not there yet, and updating the ones that are out of
4293
+ // date.
4294
+ function patchDisplay(cm, updateNumbersFrom, dims) {
4295
+ var display = cm.display, lineNumbers = cm.options.lineNumbers
4296
+ var container = display.lineDiv, cur = container.firstChild
4297
+
4298
+ function rm(node) {
4299
+ var next = node.nextSibling
4300
+ // Works around a throw-scroll bug in OS X Webkit
4301
+ if (webkit && mac && cm.display.currentWheelTarget == node)
4302
+ { node.style.display = "none" }
4303
+ else
4304
+ { node.parentNode.removeChild(node) }
4305
+ return next
4306
+ }
4307
+
4308
+ var view = display.view, lineN = display.viewFrom
4309
+ // Loop over the elements in the view, syncing cur (the DOM nodes
4310
+ // in display.lineDiv) with the view as we go.
4311
+ for (var i = 0; i < view.length; i++) {
4312
+ var lineView = view[i]
4313
+ if (lineView.hidden) {
4314
+ } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet
4315
+ var node = buildLineElement(cm, lineView, lineN, dims)
4316
+ container.insertBefore(node, cur)
4317
+ } else { // Already drawn
4318
+ while (cur != lineView.node) { cur = rm(cur) }
4319
+ var updateNumber = lineNumbers && updateNumbersFrom != null &&
4320
+ updateNumbersFrom <= lineN && lineView.lineNumber
4321
+ if (lineView.changes) {
4322
+ if (indexOf(lineView.changes, "gutter") > -1) { updateNumber = false }
4323
+ updateLineForChanges(cm, lineView, lineN, dims)
4324
+ }
4325
+ if (updateNumber) {
4326
+ removeChildren(lineView.lineNumber)
4327
+ lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)))
4328
+ }
4329
+ cur = lineView.node.nextSibling
4330
+ }
4331
+ lineN += lineView.size
4332
+ }
4333
+ while (cur) { cur = rm(cur) }
4334
+ }
4335
+
4336
+ function updateGutterSpace(cm) {
4337
+ var width = cm.display.gutters.offsetWidth
4338
+ cm.display.sizer.style.marginLeft = width + "px"
4339
+ }
4340
+
4341
+ function setDocumentHeight(cm, measure) {
4342
+ cm.display.sizer.style.minHeight = measure.docHeight + "px"
4343
+ cm.display.heightForcer.style.top = measure.docHeight + "px"
4344
+ cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px"
4345
+ }
4346
+
4347
+ // Rebuild the gutter elements, ensure the margin to the left of the
4348
+ // code matches their width.
4349
+ function updateGutters(cm) {
4350
+ var gutters = cm.display.gutters, specs = cm.options.gutters
4351
+ removeChildren(gutters)
4352
+ var i = 0
4353
+ for (; i < specs.length; ++i) {
4354
+ var gutterClass = specs[i]
4355
+ var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass))
4356
+ if (gutterClass == "CodeMirror-linenumbers") {
4357
+ cm.display.lineGutter = gElt
4358
+ gElt.style.width = (cm.display.lineNumWidth || 1) + "px"
4359
+ }
4360
+ }
4361
+ gutters.style.display = i ? "" : "none"
4362
+ updateGutterSpace(cm)
4363
+ }
4364
+
4365
+ // Make sure the gutters options contains the element
4366
+ // "CodeMirror-linenumbers" when the lineNumbers option is true.
4367
+ function setGuttersForLineNumbers(options) {
4368
+ var found = indexOf(options.gutters, "CodeMirror-linenumbers")
4369
+ if (found == -1 && options.lineNumbers) {
4370
+ options.gutters = options.gutters.concat(["CodeMirror-linenumbers"])
4371
+ } else if (found > -1 && !options.lineNumbers) {
4372
+ options.gutters = options.gutters.slice(0)
4373
+ options.gutters.splice(found, 1)
4374
+ }
4375
+ }
4376
+
4377
+ var wheelSamples = 0;
4378
+ var wheelPixelsPerUnit = null;
4379
+ // Fill in a browser-detected starting value on browsers where we
4380
+ // know one. These don't have to be accurate -- the result of them
4381
+ // being wrong would just be a slight flicker on the first wheel
4382
+ // scroll (if it is large enough).
4383
+ if (ie) { wheelPixelsPerUnit = -.53 }
4384
+ else if (gecko) { wheelPixelsPerUnit = 15 }
4385
+ else if (chrome) { wheelPixelsPerUnit = -.7 }
4386
+ else if (safari) { wheelPixelsPerUnit = -1/3 }
4387
+
4388
+ function wheelEventDelta(e) {
4389
+ var dx = e.wheelDeltaX, dy = e.wheelDeltaY
4390
+ if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail }
4391
+ if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail }
4392
+ else if (dy == null) { dy = e.wheelDelta }
4393
+ return {x: dx, y: dy}
4394
+ }
4395
+ function wheelEventPixels(e) {
4396
+ var delta = wheelEventDelta(e)
4397
+ delta.x *= wheelPixelsPerUnit
4398
+ delta.y *= wheelPixelsPerUnit
4399
+ return delta
4400
+ }
4401
+
4402
+ function onScrollWheel(cm, e) {
4403
+ var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y
4404
+
4405
+ var display = cm.display, scroll = display.scroller
4406
+ // Quit if there's nothing to scroll here
4407
+ var canScrollX = scroll.scrollWidth > scroll.clientWidth
4408
+ var canScrollY = scroll.scrollHeight > scroll.clientHeight
4409
+ if (!(dx && canScrollX || dy && canScrollY)) { return }
4410
+
4411
+ // Webkit browsers on OS X abort momentum scrolls when the target
4412
+ // of the scroll event is removed from the scrollable element.
4413
+ // This hack (see related code in patchDisplay) makes sure the
4414
+ // element is kept around.
4415
+ if (dy && mac && webkit) {
4416
+ outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
4417
+ for (var i = 0; i < view.length; i++) {
4418
+ if (view[i].node == cur) {
4419
+ cm.display.currentWheelTarget = cur
4420
+ break outer
4421
+ }
4422
+ }
4423
+ }
4424
+ }
4425
+
4426
+ // On some browsers, horizontal scrolling will cause redraws to
4427
+ // happen before the gutter has been realigned, causing it to
4428
+ // wriggle around in a most unseemly way. When we have an
4429
+ // estimated pixels/delta value, we just handle horizontal
4430
+ // scrolling entirely here. It'll be slightly off from native, but
4431
+ // better than glitching out.
4432
+ if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {
4433
+ if (dy && canScrollY)
4434
+ { updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * wheelPixelsPerUnit)) }
4435
+ setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * wheelPixelsPerUnit))
4436
+ // Only prevent default scrolling if vertical scrolling is
4437
+ // actually possible. Otherwise, it causes vertical scroll
4438
+ // jitter on OSX trackpads when deltaX is small and deltaY
4439
+ // is large (issue #3579)
4440
+ if (!dy || (dy && canScrollY))
4441
+ { e_preventDefault(e) }
4442
+ display.wheelStartX = null // Abort measurement, if in progress
4443
+ return
4444
+ }
4445
+
4446
+ // 'Project' the visible viewport to cover the area that is being
4447
+ // scrolled into view (if we know enough to estimate it).
4448
+ if (dy && wheelPixelsPerUnit != null) {
4449
+ var pixels = dy * wheelPixelsPerUnit
4450
+ var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight
4451
+ if (pixels < 0) { top = Math.max(0, top + pixels - 50) }
4452
+ else { bot = Math.min(cm.doc.height, bot + pixels + 50) }
4453
+ updateDisplaySimple(cm, {top: top, bottom: bot})
4454
+ }
4455
+
4456
+ if (wheelSamples < 20) {
4457
+ if (display.wheelStartX == null) {
4458
+ display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop
4459
+ display.wheelDX = dx; display.wheelDY = dy
4460
+ setTimeout(function () {
4461
+ if (display.wheelStartX == null) { return }
4462
+ var movedX = scroll.scrollLeft - display.wheelStartX
4463
+ var movedY = scroll.scrollTop - display.wheelStartY
4464
+ var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
4465
+ (movedX && display.wheelDX && movedX / display.wheelDX)
4466
+ display.wheelStartX = display.wheelStartY = null
4467
+ if (!sample) { return }
4468
+ wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1)
4469
+ ++wheelSamples
4470
+ }, 200)
4471
+ } else {
4472
+ display.wheelDX += dx; display.wheelDY += dy
4473
+ }
4474
+ }
4475
+ }
4476
+
4477
+ // Selection objects are immutable. A new one is created every time
4478
+ // the selection changes. A selection is one or more non-overlapping
4479
+ // (and non-touching) ranges, sorted, and an integer that indicates
4480
+ // which one is the primary selection (the one that's scrolled into
4481
+ // view, that getCursor returns, etc).
4482
+ var Selection = function(ranges, primIndex) {
4483
+ this.ranges = ranges
4484
+ this.primIndex = primIndex
4485
+ };
4486
+
4487
+ Selection.prototype.primary = function () { return this.ranges[this.primIndex] };
4488
+
4489
+ Selection.prototype.equals = function (other) {
4490
+ var this$1 = this;
4491
+
4492
+ if (other == this) { return true }
4493
+ if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false }
4494
+ for (var i = 0; i < this.ranges.length; i++) {
4495
+ var here = this$1.ranges[i], there = other.ranges[i]
4496
+ if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) { return false }
4497
+ }
4498
+ return true
4499
+ };
4500
+
4501
+ Selection.prototype.deepCopy = function () {
4502
+ var this$1 = this;
4503
+
4504
+ var out = []
4505
+ for (var i = 0; i < this.ranges.length; i++)
4506
+ { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)) }
4507
+ return new Selection(out, this.primIndex)
4508
+ };
4509
+
4510
+ Selection.prototype.somethingSelected = function () {
4511
+ var this$1 = this;
4512
+
4513
+ for (var i = 0; i < this.ranges.length; i++)
4514
+ { if (!this$1.ranges[i].empty()) { return true } }
4515
+ return false
4516
+ };
4517
+
4518
+ Selection.prototype.contains = function (pos, end) {
4519
+ var this$1 = this;
4520
+
4521
+ if (!end) { end = pos }
4522
+ for (var i = 0; i < this.ranges.length; i++) {
4523
+ var range = this$1.ranges[i]
4524
+ if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
4525
+ { return i }
4526
+ }
4527
+ return -1
4528
+ };
4529
+
4530
+ var Range = function(anchor, head) {
4531
+ this.anchor = anchor; this.head = head
4532
+ };
4533
+
4534
+ Range.prototype.from = function () { return minPos(this.anchor, this.head) };
4535
+ Range.prototype.to = function () { return maxPos(this.anchor, this.head) };
4536
+ Range.prototype.empty = function () { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch };
4537
+
4538
+ // Take an unsorted, potentially overlapping set of ranges, and
4539
+ // build a selection out of it. 'Consumes' ranges array (modifying
4540
+ // it).
4541
+ function normalizeSelection(ranges, primIndex) {
4542
+ var prim = ranges[primIndex]
4543
+ ranges.sort(function (a, b) { return cmp(a.from(), b.from()); })
4544
+ primIndex = indexOf(ranges, prim)
4545
+ for (var i = 1; i < ranges.length; i++) {
4546
+ var cur = ranges[i], prev = ranges[i - 1]
4547
+ if (cmp(prev.to(), cur.from()) >= 0) {
4548
+ var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to())
4549
+ var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head
4550
+ if (i <= primIndex) { --primIndex }
4551
+ ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to))
4552
+ }
4553
+ }
4554
+ return new Selection(ranges, primIndex)
4555
+ }
4556
+
4557
+ function simpleSelection(anchor, head) {
4558
+ return new Selection([new Range(anchor, head || anchor)], 0)
4559
+ }
4560
+
4561
+ // Compute the position of the end of a change (its 'to' property
4562
+ // refers to the pre-change end).
4563
+ function changeEnd(change) {
4564
+ if (!change.text) { return change.to }
4565
+ return Pos(change.from.line + change.text.length - 1,
4566
+ lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))
4567
+ }
4568
+
4569
+ // Adjust a position to refer to the post-change position of the
4570
+ // same text, or the end of the change if the change covers it.
4571
+ function adjustForChange(pos, change) {
4572
+ if (cmp(pos, change.from) < 0) { return pos }
4573
+ if (cmp(pos, change.to) <= 0) { return changeEnd(change) }
4574
+
4575
+ var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch
4576
+ if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch }
4577
+ return Pos(line, ch)
4578
+ }
4579
+
4580
+ function computeSelAfterChange(doc, change) {
4581
+ var out = []
4582
+ for (var i = 0; i < doc.sel.ranges.length; i++) {
4583
+ var range = doc.sel.ranges[i]
4584
+ out.push(new Range(adjustForChange(range.anchor, change),
4585
+ adjustForChange(range.head, change)))
4586
+ }
4587
+ return normalizeSelection(out, doc.sel.primIndex)
4588
+ }
4589
+
4590
+ function offsetPos(pos, old, nw) {
4591
+ if (pos.line == old.line)
4592
+ { return Pos(nw.line, pos.ch - old.ch + nw.ch) }
4593
+ else
4594
+ { return Pos(nw.line + (pos.line - old.line), pos.ch) }
4595
+ }
4596
+
4597
+ // Used by replaceSelections to allow moving the selection to the
4598
+ // start or around the replaced test. Hint may be "start" or "around".
4599
+ function computeReplacedSel(doc, changes, hint) {
4600
+ var out = []
4601
+ var oldPrev = Pos(doc.first, 0), newPrev = oldPrev
4602
+ for (var i = 0; i < changes.length; i++) {
4603
+ var change = changes[i]
4604
+ var from = offsetPos(change.from, oldPrev, newPrev)
4605
+ var to = offsetPos(changeEnd(change), oldPrev, newPrev)
4606
+ oldPrev = change.to
4607
+ newPrev = to
4608
+ if (hint == "around") {
4609
+ var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0
4610
+ out[i] = new Range(inv ? to : from, inv ? from : to)
4611
+ } else {
4612
+ out[i] = new Range(from, from)
4613
+ }
4614
+ }
4615
+ return new Selection(out, doc.sel.primIndex)
4616
+ }
4617
+
4618
+ // Used to get the editor into a consistent state again when options change.
4619
+
4620
+ function loadMode(cm) {
4621
+ cm.doc.mode = getMode(cm.options, cm.doc.modeOption)
4622
+ resetModeState(cm)
4623
+ }
4624
+
4625
+ function resetModeState(cm) {
4626
+ cm.doc.iter(function (line) {
4627
+ if (line.stateAfter) { line.stateAfter = null }
4628
+ if (line.styles) { line.styles = null }
4629
+ })
4630
+ cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first
4631
+ startWorker(cm, 100)
4632
+ cm.state.modeGen++
4633
+ if (cm.curOp) { regChange(cm) }
4634
+ }
4635
+
4636
+ // DOCUMENT DATA STRUCTURE
4637
+
4638
+ // By default, updates that start and end at the beginning of a line
4639
+ // are treated specially, in order to make the association of line
4640
+ // widgets and marker elements with the text behave more intuitive.
4641
+ function isWholeLineUpdate(doc, change) {
4642
+ return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
4643
+ (!doc.cm || doc.cm.options.wholeLineUpdateBefore)
4644
+ }
4645
+
4646
+ // Perform a change on the document data structure.
4647
+ function updateDoc(doc, change, markedSpans, estimateHeight) {
4648
+ function spansFor(n) {return markedSpans ? markedSpans[n] : null}
4649
+ function update(line, text, spans) {
4650
+ updateLine(line, text, spans, estimateHeight)
4651
+ signalLater(line, "change", line, change)
4652
+ }
4653
+ function linesFor(start, end) {
4654
+ var result = []
4655
+ for (var i = start; i < end; ++i)
4656
+ { result.push(new Line(text[i], spansFor(i), estimateHeight)) }
4657
+ return result
4658
+ }
4659
+
4660
+ var from = change.from, to = change.to, text = change.text
4661
+ var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line)
4662
+ var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line
4663
+
4664
+ // Adjust the line structure
4665
+ if (change.full) {
4666
+ doc.insert(0, linesFor(0, text.length))
4667
+ doc.remove(text.length, doc.size - text.length)
4668
+ } else if (isWholeLineUpdate(doc, change)) {
4669
+ // This is a whole-line replace. Treated specially to make
4670
+ // sure line objects move the way they are supposed to.
4671
+ var added = linesFor(0, text.length - 1)
4672
+ update(lastLine, lastLine.text, lastSpans)
4673
+ if (nlines) { doc.remove(from.line, nlines) }
4674
+ if (added.length) { doc.insert(from.line, added) }
4675
+ } else if (firstLine == lastLine) {
4676
+ if (text.length == 1) {
4677
+ update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans)
4678
+ } else {
4679
+ var added$1 = linesFor(1, text.length - 1)
4680
+ added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight))
4681
+ update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
4682
+ doc.insert(from.line + 1, added$1)
4683
+ }
4684
+ } else if (text.length == 1) {
4685
+ update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0))
4686
+ doc.remove(from.line + 1, nlines)
4687
+ } else {
4688
+ update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
4689
+ update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans)
4690
+ var added$2 = linesFor(1, text.length - 1)
4691
+ if (nlines > 1) { doc.remove(from.line + 1, nlines - 1) }
4692
+ doc.insert(from.line + 1, added$2)
4693
+ }
4694
+
4695
+ signalLater(doc, "change", doc, change)
4696
+ }
4697
+
4698
+ // Call f for all linked documents.
4699
+ function linkedDocs(doc, f, sharedHistOnly) {
4700
+ function propagate(doc, skip, sharedHist) {
4701
+ if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) {
4702
+ var rel = doc.linked[i]
4703
+ if (rel.doc == skip) { continue }
4704
+ var shared = sharedHist && rel.sharedHist
4705
+ if (sharedHistOnly && !shared) { continue }
4706
+ f(rel.doc, shared)
4707
+ propagate(rel.doc, doc, shared)
4708
+ } }
4709
+ }
4710
+ propagate(doc, null, true)
4711
+ }
4712
+
4713
+ // Attach a document to an editor.
4714
+ function attachDoc(cm, doc) {
4715
+ if (doc.cm) { throw new Error("This document is already in use.") }
4716
+ cm.doc = doc
4717
+ doc.cm = cm
4718
+ estimateLineHeights(cm)
4719
+ loadMode(cm)
4720
+ setDirectionClass(cm)
4721
+ if (!cm.options.lineWrapping) { findMaxLine(cm) }
4722
+ cm.options.mode = doc.modeOption
4723
+ regChange(cm)
4724
+ }
4725
+
4726
+ function setDirectionClass(cm) {
4727
+ ;(cm.doc.direction == "rtl" ? addClass : rmClass)(cm.display.lineDiv, "CodeMirror-rtl")
4728
+ }
4729
+
4730
+ function directionChanged(cm) {
4731
+ runInOp(cm, function () {
4732
+ setDirectionClass(cm)
4733
+ regChange(cm)
4734
+ })
4735
+ }
4736
+
4737
+ function History(startGen) {
4738
+ // Arrays of change events and selections. Doing something adds an
4739
+ // event to done and clears undo. Undoing moves events from done
4740
+ // to undone, redoing moves them in the other direction.
4741
+ this.done = []; this.undone = []
4742
+ this.undoDepth = Infinity
4743
+ // Used to track when changes can be merged into a single undo
4744
+ // event
4745
+ this.lastModTime = this.lastSelTime = 0
4746
+ this.lastOp = this.lastSelOp = null
4747
+ this.lastOrigin = this.lastSelOrigin = null
4748
+ // Used by the isClean() method
4749
+ this.generation = this.maxGeneration = startGen || 1
4750
+ }
4751
+
4752
+ // Create a history change event from an updateDoc-style change
4753
+ // object.
4754
+ function historyChangeFromChange(doc, change) {
4755
+ var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}
4756
+ attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1)
4757
+ linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true)
4758
+ return histChange
4759
+ }
4760
+
4761
+ // Pop all selection events off the end of a history array. Stop at
4762
+ // a change event.
4763
+ function clearSelectionEvents(array) {
4764
+ while (array.length) {
4765
+ var last = lst(array)
4766
+ if (last.ranges) { array.pop() }
4767
+ else { break }
4768
+ }
4769
+ }
4770
+
4771
+ // Find the top change event in the history. Pop off selection
4772
+ // events that are in the way.
4773
+ function lastChangeEvent(hist, force) {
4774
+ if (force) {
4775
+ clearSelectionEvents(hist.done)
4776
+ return lst(hist.done)
4777
+ } else if (hist.done.length && !lst(hist.done).ranges) {
4778
+ return lst(hist.done)
4779
+ } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
4780
+ hist.done.pop()
4781
+ return lst(hist.done)
4782
+ }
4783
+ }
4784
+
4785
+ // Register a change in the history. Merges changes that are within
4786
+ // a single operation, or are close together with an origin that
4787
+ // allows merging (starting with "+") into a single event.
4788
+ function addChangeToHistory(doc, change, selAfter, opId) {
4789
+ var hist = doc.history
4790
+ hist.undone.length = 0
4791
+ var time = +new Date, cur
4792
+ var last
4793
+
4794
+ if ((hist.lastOp == opId ||
4795
+ hist.lastOrigin == change.origin && change.origin &&
4796
+ ((change.origin.charAt(0) == "+" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500)) ||
4797
+ change.origin.charAt(0) == "*")) &&
4798
+ (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
4799
+ // Merge this change into the last event
4800
+ last = lst(cur.changes)
4801
+ if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
4802
+ // Optimized case for simple insertion -- don't want to add
4803
+ // new changesets for every character typed
4804
+ last.to = changeEnd(change)
4805
+ } else {
4806
+ // Add new sub-event
4807
+ cur.changes.push(historyChangeFromChange(doc, change))
4808
+ }
4809
+ } else {
4810
+ // Can not be merged, start a new event.
4811
+ var before = lst(hist.done)
4812
+ if (!before || !before.ranges)
4813
+ { pushSelectionToHistory(doc.sel, hist.done) }
4814
+ cur = {changes: [historyChangeFromChange(doc, change)],
4815
+ generation: hist.generation}
4816
+ hist.done.push(cur)
4817
+ while (hist.done.length > hist.undoDepth) {
4818
+ hist.done.shift()
4819
+ if (!hist.done[0].ranges) { hist.done.shift() }
4820
+ }
4821
+ }
4822
+ hist.done.push(selAfter)
4823
+ hist.generation = ++hist.maxGeneration
4824
+ hist.lastModTime = hist.lastSelTime = time
4825
+ hist.lastOp = hist.lastSelOp = opId
4826
+ hist.lastOrigin = hist.lastSelOrigin = change.origin
4827
+
4828
+ if (!last) { signal(doc, "historyAdded") }
4829
+ }
4830
+
4831
+ function selectionEventCanBeMerged(doc, origin, prev, sel) {
4832
+ var ch = origin.charAt(0)
4833
+ return ch == "*" ||
4834
+ ch == "+" &&
4835
+ prev.ranges.length == sel.ranges.length &&
4836
+ prev.somethingSelected() == sel.somethingSelected() &&
4837
+ new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)
4838
+ }
4839
+
4840
+ // Called whenever the selection changes, sets the new selection as
4841
+ // the pending selection in the history, and pushes the old pending
4842
+ // selection into the 'done' array when it was significantly
4843
+ // different (in number of selected ranges, emptiness, or time).
4844
+ function addSelectionToHistory(doc, sel, opId, options) {
4845
+ var hist = doc.history, origin = options && options.origin
4846
+
4847
+ // A new event is started when the previous origin does not match
4848
+ // the current, or the origins don't allow matching. Origins
4849
+ // starting with * are always merged, those starting with + are
4850
+ // merged when similar and close together in time.
4851
+ if (opId == hist.lastSelOp ||
4852
+ (origin && hist.lastSelOrigin == origin &&
4853
+ (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
4854
+ selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
4855
+ { hist.done[hist.done.length - 1] = sel }
4856
+ else
4857
+ { pushSelectionToHistory(sel, hist.done) }
4858
+
4859
+ hist.lastSelTime = +new Date
4860
+ hist.lastSelOrigin = origin
4861
+ hist.lastSelOp = opId
4862
+ if (options && options.clearRedo !== false)
4863
+ { clearSelectionEvents(hist.undone) }
4864
+ }
4865
+
4866
+ function pushSelectionToHistory(sel, dest) {
4867
+ var top = lst(dest)
4868
+ if (!(top && top.ranges && top.equals(sel)))
4869
+ { dest.push(sel) }
4870
+ }
4871
+
4872
+ // Used to store marked span information in the history.
4873
+ function attachLocalSpans(doc, change, from, to) {
4874
+ var existing = change["spans_" + doc.id], n = 0
4875
+ doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {
4876
+ if (line.markedSpans)
4877
+ { (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans }
4878
+ ++n
4879
+ })
4880
+ }
4881
+
4882
+ // When un/re-doing restores text containing marked spans, those
4883
+ // that have been explicitly cleared should not be restored.
4884
+ function removeClearedSpans(spans) {
4885
+ if (!spans) { return null }
4886
+ var out
4887
+ for (var i = 0; i < spans.length; ++i) {
4888
+ if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i) } }
4889
+ else if (out) { out.push(spans[i]) }
4890
+ }
4891
+ return !out ? spans : out.length ? out : null
4892
+ }
4893
+
4894
+ // Retrieve and filter the old marked spans stored in a change event.
4895
+ function getOldSpans(doc, change) {
4896
+ var found = change["spans_" + doc.id]
4897
+ if (!found) { return null }
4898
+ var nw = []
4899
+ for (var i = 0; i < change.text.length; ++i)
4900
+ { nw.push(removeClearedSpans(found[i])) }
4901
+ return nw
4902
+ }
4903
+
4904
+ // Used for un/re-doing changes from the history. Combines the
4905
+ // result of computing the existing spans with the set of spans that
4906
+ // existed in the history (so that deleting around a span and then
4907
+ // undoing brings back the span).
4908
+ function mergeOldSpans(doc, change) {
4909
+ var old = getOldSpans(doc, change)
4910
+ var stretched = stretchSpansOverChange(doc, change)
4911
+ if (!old) { return stretched }
4912
+ if (!stretched) { return old }
4913
+
4914
+ for (var i = 0; i < old.length; ++i) {
4915
+ var oldCur = old[i], stretchCur = stretched[i]
4916
+ if (oldCur && stretchCur) {
4917
+ spans: for (var j = 0; j < stretchCur.length; ++j) {
4918
+ var span = stretchCur[j]
4919
+ for (var k = 0; k < oldCur.length; ++k)
4920
+ { if (oldCur[k].marker == span.marker) { continue spans } }
4921
+ oldCur.push(span)
4922
+ }
4923
+ } else if (stretchCur) {
4924
+ old[i] = stretchCur
4925
+ }
4926
+ }
4927
+ return old
4928
+ }
4929
+
4930
+ // Used both to provide a JSON-safe object in .getHistory, and, when
4931
+ // detaching a document, to split the history in two
4932
+ function copyHistoryArray(events, newGroup, instantiateSel) {
4933
+ var copy = []
4934
+ for (var i = 0; i < events.length; ++i) {
4935
+ var event = events[i]
4936
+ if (event.ranges) {
4937
+ copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event)
4938
+ continue
4939
+ }
4940
+ var changes = event.changes, newChanges = []
4941
+ copy.push({changes: newChanges})
4942
+ for (var j = 0; j < changes.length; ++j) {
4943
+ var change = changes[j], m = (void 0)
4944
+ newChanges.push({from: change.from, to: change.to, text: change.text})
4945
+ if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\d+)$/)) {
4946
+ if (indexOf(newGroup, Number(m[1])) > -1) {
4947
+ lst(newChanges)[prop] = change[prop]
4948
+ delete change[prop]
4949
+ }
4950
+ } } }
4951
+ }
4952
+ }
4953
+ return copy
4954
+ }
4955
+
4956
+ // The 'scroll' parameter given to many of these indicated whether
4957
+ // the new cursor position should be scrolled into view after
4958
+ // modifying the selection.
4959
+
4960
+ // If shift is held or the extend flag is set, extends a range to
4961
+ // include a given position (and optionally a second position).
4962
+ // Otherwise, simply returns the range between the given positions.
4963
+ // Used for cursor motion and such.
4964
+ function extendRange(range, head, other, extend) {
4965
+ if (extend) {
4966
+ var anchor = range.anchor
4967
+ if (other) {
4968
+ var posBefore = cmp(head, anchor) < 0
4969
+ if (posBefore != (cmp(other, anchor) < 0)) {
4970
+ anchor = head
4971
+ head = other
4972
+ } else if (posBefore != (cmp(head, other) < 0)) {
4973
+ head = other
4974
+ }
4975
+ }
4976
+ return new Range(anchor, head)
4977
+ } else {
4978
+ return new Range(other || head, head)
4979
+ }
4980
+ }
4981
+
4982
+ // Extend the primary selection range, discard the rest.
4983
+ function extendSelection(doc, head, other, options, extend) {
4984
+ if (extend == null) { extend = doc.cm && (doc.cm.display.shift || doc.extend) }
4985
+ setSelection(doc, new Selection([extendRange(doc.sel.primary(), head, other, extend)], 0), options)
4986
+ }
4987
+
4988
+ // Extend all selections (pos is an array of selections with length
4989
+ // equal the number of selections)
4990
+ function extendSelections(doc, heads, options) {
4991
+ var out = []
4992
+ var extend = doc.cm && (doc.cm.display.shift || doc.extend)
4993
+ for (var i = 0; i < doc.sel.ranges.length; i++)
4994
+ { out[i] = extendRange(doc.sel.ranges[i], heads[i], null, extend) }
4995
+ var newSel = normalizeSelection(out, doc.sel.primIndex)
4996
+ setSelection(doc, newSel, options)
4997
+ }
4998
+
4999
+ // Updates a single range in the selection.
5000
+ function replaceOneSelection(doc, i, range, options) {
5001
+ var ranges = doc.sel.ranges.slice(0)
5002
+ ranges[i] = range
5003
+ setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options)
5004
+ }
5005
+
5006
+ // Reset the selection to a single range.
5007
+ function setSimpleSelection(doc, anchor, head, options) {
5008
+ setSelection(doc, simpleSelection(anchor, head), options)
5009
+ }
5010
+
5011
+ // Give beforeSelectionChange handlers a change to influence a
5012
+ // selection update.
5013
+ function filterSelectionChange(doc, sel, options) {
5014
+ var obj = {
5015
+ ranges: sel.ranges,
5016
+ update: function(ranges) {
5017
+ var this$1 = this;
5018
+
5019
+ this.ranges = []
5020
+ for (var i = 0; i < ranges.length; i++)
5021
+ { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),
5022
+ clipPos(doc, ranges[i].head)) }
5023
+ },
5024
+ origin: options && options.origin
5025
+ }
5026
+ signal(doc, "beforeSelectionChange", doc, obj)
5027
+ if (doc.cm) { signal(doc.cm, "beforeSelectionChange", doc.cm, obj) }
5028
+ if (obj.ranges != sel.ranges) { return normalizeSelection(obj.ranges, obj.ranges.length - 1) }
5029
+ else { return sel }
5030
+ }
5031
+
5032
+ function setSelectionReplaceHistory(doc, sel, options) {
5033
+ var done = doc.history.done, last = lst(done)
5034
+ if (last && last.ranges) {
5035
+ done[done.length - 1] = sel
5036
+ setSelectionNoUndo(doc, sel, options)
5037
+ } else {
5038
+ setSelection(doc, sel, options)
5039
+ }
5040
+ }
5041
+
5042
+ // Set a new selection.
5043
+ function setSelection(doc, sel, options) {
5044
+ setSelectionNoUndo(doc, sel, options)
5045
+ addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options)
5046
+ }
5047
+
5048
+ function setSelectionNoUndo(doc, sel, options) {
5049
+ if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
5050
+ { sel = filterSelectionChange(doc, sel, options) }
5051
+
5052
+ var bias = options && options.bias ||
5053
+ (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1)
5054
+ setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true))
5055
+
5056
+ if (!(options && options.scroll === false) && doc.cm)
5057
+ { ensureCursorVisible(doc.cm) }
5058
+ }
5059
+
5060
+ function setSelectionInner(doc, sel) {
5061
+ if (sel.equals(doc.sel)) { return }
5062
+
5063
+ doc.sel = sel
5064
+
5065
+ if (doc.cm) {
5066
+ doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true
5067
+ signalCursorActivity(doc.cm)
5068
+ }
5069
+ signalLater(doc, "cursorActivity", doc)
5070
+ }
5071
+
5072
+ // Verify that the selection does not partially select any atomic
5073
+ // marked ranges.
5074
+ function reCheckSelection(doc) {
5075
+ setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false))
5076
+ }
5077
+
5078
+ // Return a selection that does not partially select any atomic
5079
+ // ranges.
5080
+ function skipAtomicInSelection(doc, sel, bias, mayClear) {
5081
+ var out
5082
+ for (var i = 0; i < sel.ranges.length; i++) {
5083
+ var range = sel.ranges[i]
5084
+ var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i]
5085
+ var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear)
5086
+ var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear)
5087
+ if (out || newAnchor != range.anchor || newHead != range.head) {
5088
+ if (!out) { out = sel.ranges.slice(0, i) }
5089
+ out[i] = new Range(newAnchor, newHead)
5090
+ }
5091
+ }
5092
+ return out ? normalizeSelection(out, sel.primIndex) : sel
5093
+ }
5094
+
5095
+ function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {
5096
+ var line = getLine(doc, pos.line)
5097
+ if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
5098
+ var sp = line.markedSpans[i], m = sp.marker
5099
+ if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) &&
5100
+ (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) {
5101
+ if (mayClear) {
5102
+ signal(m, "beforeCursorEnter")
5103
+ if (m.explicitlyCleared) {
5104
+ if (!line.markedSpans) { break }
5105
+ else {--i; continue}
5106
+ }
5107
+ }
5108
+ if (!m.atomic) { continue }
5109
+
5110
+ if (oldPos) {
5111
+ var near = m.find(dir < 0 ? 1 : -1), diff = (void 0)
5112
+ if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)
5113
+ { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null) }
5114
+ if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))
5115
+ { return skipAtomicInner(doc, near, pos, dir, mayClear) }
5116
+ }
5117
+
5118
+ var far = m.find(dir < 0 ? -1 : 1)
5119
+ if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)
5120
+ { far = movePos(doc, far, dir, far.line == pos.line ? line : null) }
5121
+ return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null
5122
+ }
5123
+ } }
5124
+ return pos
5125
+ }
5126
+
5127
+ // Ensure a given position is not inside an atomic range.
5128
+ function skipAtomic(doc, pos, oldPos, bias, mayClear) {
5129
+ var dir = bias || 1
5130
+ var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||
5131
+ (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||
5132
+ skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||
5133
+ (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true))
5134
+ if (!found) {
5135
+ doc.cantEdit = true
5136
+ return Pos(doc.first, 0)
5137
+ }
5138
+ return found
5139
+ }
5140
+
5141
+ function movePos(doc, pos, dir, line) {
5142
+ if (dir < 0 && pos.ch == 0) {
5143
+ if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) }
5144
+ else { return null }
5145
+ } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {
5146
+ if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) }
5147
+ else { return null }
5148
+ } else {
5149
+ return new Pos(pos.line, pos.ch + dir)
5150
+ }
5151
+ }
5152
+
5153
+ function selectAll(cm) {
5154
+ cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll)
5155
+ }
5156
+
5157
+ // UPDATING
5158
+
5159
+ // Allow "beforeChange" event handlers to influence a change
5160
+ function filterChange(doc, change, update) {
5161
+ var obj = {
5162
+ canceled: false,
5163
+ from: change.from,
5164
+ to: change.to,
5165
+ text: change.text,
5166
+ origin: change.origin,
5167
+ cancel: function () { return obj.canceled = true; }
5168
+ }
5169
+ if (update) { obj.update = function (from, to, text, origin) {
5170
+ if (from) { obj.from = clipPos(doc, from) }
5171
+ if (to) { obj.to = clipPos(doc, to) }
5172
+ if (text) { obj.text = text }
5173
+ if (origin !== undefined) { obj.origin = origin }
5174
+ } }
5175
+ signal(doc, "beforeChange", doc, obj)
5176
+ if (doc.cm) { signal(doc.cm, "beforeChange", doc.cm, obj) }
5177
+
5178
+ if (obj.canceled) { return null }
5179
+ return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}
5180
+ }
5181
+
5182
+ // Apply a change to a document, and add it to the document's
5183
+ // history, and propagating it to all linked documents.
5184
+ function makeChange(doc, change, ignoreReadOnly) {
5185
+ if (doc.cm) {
5186
+ if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) }
5187
+ if (doc.cm.state.suppressEdits) { return }
5188
+ }
5189
+
5190
+ if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
5191
+ change = filterChange(doc, change, true)
5192
+ if (!change) { return }
5193
+ }
5194
+
5195
+ // Possibly split or suppress the update based on the presence
5196
+ // of read-only spans in its range.
5197
+ var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to)
5198
+ if (split) {
5199
+ for (var i = split.length - 1; i >= 0; --i)
5200
+ { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text, origin: change.origin}) }
5201
+ } else {
5202
+ makeChangeInner(doc, change)
5203
+ }
5204
+ }
5205
+
5206
+ function makeChangeInner(doc, change) {
5207
+ if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) { return }
5208
+ var selAfter = computeSelAfterChange(doc, change)
5209
+ addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN)
5210
+
5211
+ makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change))
5212
+ var rebased = []
5213
+
5214
+ linkedDocs(doc, function (doc, sharedHist) {
5215
+ if (!sharedHist && indexOf(rebased, doc.history) == -1) {
5216
+ rebaseHist(doc.history, change)
5217
+ rebased.push(doc.history)
5218
+ }
5219
+ makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change))
5220
+ })
5221
+ }
5222
+
5223
+ // Revert a change stored in a document's history.
5224
+ function makeChangeFromHistory(doc, type, allowSelectionOnly) {
5225
+ var suppress = doc.cm && doc.cm.state.suppressEdits
5226
+ if (suppress && !allowSelectionOnly) { return }
5227
+
5228
+ var hist = doc.history, event, selAfter = doc.sel
5229
+ var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done
5230
+
5231
+ // Verify that there is a useable event (so that ctrl-z won't
5232
+ // needlessly clear selection events)
5233
+ var i = 0
5234
+ for (; i < source.length; i++) {
5235
+ event = source[i]
5236
+ if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
5237
+ { break }
5238
+ }
5239
+ if (i == source.length) { return }
5240
+ hist.lastOrigin = hist.lastSelOrigin = null
5241
+
5242
+ for (;;) {
5243
+ event = source.pop()
5244
+ if (event.ranges) {
5245
+ pushSelectionToHistory(event, dest)
5246
+ if (allowSelectionOnly && !event.equals(doc.sel)) {
5247
+ setSelection(doc, event, {clearRedo: false})
5248
+ return
5249
+ }
5250
+ selAfter = event
5251
+ } else if (suppress) {
5252
+ source.push(event)
5253
+ return
5254
+ } else { break }
5255
+ }
5256
+
5257
+ // Build up a reverse change object to add to the opposite history
5258
+ // stack (redo when undoing, and vice versa).
5259
+ var antiChanges = []
5260
+ pushSelectionToHistory(selAfter, dest)
5261
+ dest.push({changes: antiChanges, generation: hist.generation})
5262
+ hist.generation = event.generation || ++hist.maxGeneration
5263
+
5264
+ var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")
5265
+
5266
+ var loop = function ( i ) {
5267
+ var change = event.changes[i]
5268
+ change.origin = type
5269
+ if (filter && !filterChange(doc, change, false)) {
5270
+ source.length = 0
5271
+ return {}
5272
+ }
5273
+
5274
+ antiChanges.push(historyChangeFromChange(doc, change))
5275
+
5276
+ var after = i ? computeSelAfterChange(doc, change) : lst(source)
5277
+ makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change))
5278
+ if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}) }
5279
+ var rebased = []
5280
+
5281
+ // Propagate to the linked documents
5282
+ linkedDocs(doc, function (doc, sharedHist) {
5283
+ if (!sharedHist && indexOf(rebased, doc.history) == -1) {
5284
+ rebaseHist(doc.history, change)
5285
+ rebased.push(doc.history)
5286
+ }
5287
+ makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change))
5288
+ })
5289
+ };
5290
+
5291
+ for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {
5292
+ var returned = loop( i$1 );
5293
+
5294
+ if ( returned ) return returned.v;
5295
+ }
5296
+ }
5297
+
5298
+ // Sub-views need their line numbers shifted when text is added
5299
+ // above or below them in the parent document.
5300
+ function shiftDoc(doc, distance) {
5301
+ if (distance == 0) { return }
5302
+ doc.first += distance
5303
+ doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range(
5304
+ Pos(range.anchor.line + distance, range.anchor.ch),
5305
+ Pos(range.head.line + distance, range.head.ch)
5306
+ ); }), doc.sel.primIndex)
5307
+ if (doc.cm) {
5308
+ regChange(doc.cm, doc.first, doc.first - distance, distance)
5309
+ for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
5310
+ { regLineChange(doc.cm, l, "gutter") }
5311
+ }
5312
+ }
5313
+
5314
+ // More lower-level change function, handling only a single document
5315
+ // (not linked ones).
5316
+ function makeChangeSingleDoc(doc, change, selAfter, spans) {
5317
+ if (doc.cm && !doc.cm.curOp)
5318
+ { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) }
5319
+
5320
+ if (change.to.line < doc.first) {
5321
+ shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line))
5322
+ return
5323
+ }
5324
+ if (change.from.line > doc.lastLine()) { return }
5325
+
5326
+ // Clip the change to the size of this doc
5327
+ if (change.from.line < doc.first) {
5328
+ var shift = change.text.length - 1 - (doc.first - change.from.line)
5329
+ shiftDoc(doc, shift)
5330
+ change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
5331
+ text: [lst(change.text)], origin: change.origin}
5332
+ }
5333
+ var last = doc.lastLine()
5334
+ if (change.to.line > last) {
5335
+ change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
5336
+ text: [change.text[0]], origin: change.origin}
5337
+ }
5338
+
5339
+ change.removed = getBetween(doc, change.from, change.to)
5340
+
5341
+ if (!selAfter) { selAfter = computeSelAfterChange(doc, change) }
5342
+ if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans) }
5343
+ else { updateDoc(doc, change, spans) }
5344
+ setSelectionNoUndo(doc, selAfter, sel_dontScroll)
5345
+ }
5346
+
5347
+ // Handle the interaction of a change to a document with the editor
5348
+ // that this document is part of.
5349
+ function makeChangeSingleDocInEditor(cm, change, spans) {
5350
+ var doc = cm.doc, display = cm.display, from = change.from, to = change.to
5351
+
5352
+ var recomputeMaxLength = false, checkWidthStart = from.line
5353
+ if (!cm.options.lineWrapping) {
5354
+ checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))
5355
+ doc.iter(checkWidthStart, to.line + 1, function (line) {
5356
+ if (line == display.maxLine) {
5357
+ recomputeMaxLength = true
5358
+ return true
5359
+ }
5360
+ })
5361
+ }
5362
+
5363
+ if (doc.sel.contains(change.from, change.to) > -1)
5364
+ { signalCursorActivity(cm) }
5365
+
5366
+ updateDoc(doc, change, spans, estimateHeight(cm))
5367
+
5368
+ if (!cm.options.lineWrapping) {
5369
+ doc.iter(checkWidthStart, from.line + change.text.length, function (line) {
5370
+ var len = lineLength(line)
5371
+ if (len > display.maxLineLength) {
5372
+ display.maxLine = line
5373
+ display.maxLineLength = len
5374
+ display.maxLineChanged = true
5375
+ recomputeMaxLength = false
5376
+ }
5377
+ })
5378
+ if (recomputeMaxLength) { cm.curOp.updateMaxLine = true }
5379
+ }
5380
+
5381
+ retreatFrontier(doc, from.line)
5382
+ startWorker(cm, 400)
5383
+
5384
+ var lendiff = change.text.length - (to.line - from.line) - 1
5385
+ // Remember that these lines changed, for updating the display
5386
+ if (change.full)
5387
+ { regChange(cm) }
5388
+ else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
5389
+ { regLineChange(cm, from.line, "text") }
5390
+ else
5391
+ { regChange(cm, from.line, to.line + 1, lendiff) }
5392
+
5393
+ var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change")
5394
+ if (changeHandler || changesHandler) {
5395
+ var obj = {
5396
+ from: from, to: to,
5397
+ text: change.text,
5398
+ removed: change.removed,
5399
+ origin: change.origin
5400
+ }
5401
+ if (changeHandler) { signalLater(cm, "change", cm, obj) }
5402
+ if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj) }
5403
+ }
5404
+ cm.display.selForContextMenu = null
5405
+ }
5406
+
5407
+ function replaceRange(doc, code, from, to, origin) {
5408
+ if (!to) { to = from }
5409
+ if (cmp(to, from) < 0) { var assign;
5410
+ (assign = [to, from], from = assign[0], to = assign[1], assign) }
5411
+ if (typeof code == "string") { code = doc.splitLines(code) }
5412
+ makeChange(doc, {from: from, to: to, text: code, origin: origin})
5413
+ }
5414
+
5415
+ // Rebasing/resetting history to deal with externally-sourced changes
5416
+
5417
+ function rebaseHistSelSingle(pos, from, to, diff) {
5418
+ if (to < pos.line) {
5419
+ pos.line += diff
5420
+ } else if (from < pos.line) {
5421
+ pos.line = from
5422
+ pos.ch = 0
5423
+ }
5424
+ }
5425
+
5426
+ // Tries to rebase an array of history events given a change in the
5427
+ // document. If the change touches the same lines as the event, the
5428
+ // event, and everything 'behind' it, is discarded. If the change is
5429
+ // before the event, the event's positions are updated. Uses a
5430
+ // copy-on-write scheme for the positions, to avoid having to
5431
+ // reallocate them all on every rebase, but also avoid problems with
5432
+ // shared position objects being unsafely updated.
5433
+ function rebaseHistArray(array, from, to, diff) {
5434
+ for (var i = 0; i < array.length; ++i) {
5435
+ var sub = array[i], ok = true
5436
+ if (sub.ranges) {
5437
+ if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true }
5438
+ for (var j = 0; j < sub.ranges.length; j++) {
5439
+ rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff)
5440
+ rebaseHistSelSingle(sub.ranges[j].head, from, to, diff)
5441
+ }
5442
+ continue
5443
+ }
5444
+ for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {
5445
+ var cur = sub.changes[j$1]
5446
+ if (to < cur.from.line) {
5447
+ cur.from = Pos(cur.from.line + diff, cur.from.ch)
5448
+ cur.to = Pos(cur.to.line + diff, cur.to.ch)
5449
+ } else if (from <= cur.to.line) {
5450
+ ok = false
5451
+ break
5452
+ }
5453
+ }
5454
+ if (!ok) {
5455
+ array.splice(0, i + 1)
5456
+ i = 0
5457
+ }
5458
+ }
5459
+ }
5460
+
5461
+ function rebaseHist(hist, change) {
5462
+ var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1
5463
+ rebaseHistArray(hist.done, from, to, diff)
5464
+ rebaseHistArray(hist.undone, from, to, diff)
5465
+ }
5466
+
5467
+ // Utility for applying a change to a line by handle or number,
5468
+ // returning the number and optionally registering the line as
5469
+ // changed.
5470
+ function changeLine(doc, handle, changeType, op) {
5471
+ var no = handle, line = handle
5472
+ if (typeof handle == "number") { line = getLine(doc, clipLine(doc, handle)) }
5473
+ else { no = lineNo(handle) }
5474
+ if (no == null) { return null }
5475
+ if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType) }
5476
+ return line
5477
+ }
5478
+
5479
+ // The document is represented as a BTree consisting of leaves, with
5480
+ // chunk of lines in them, and branches, with up to ten leaves or
5481
+ // other branch nodes below them. The top node is always a branch
5482
+ // node, and is the document object itself (meaning it has
5483
+ // additional methods and properties).
5484
+ //
5485
+ // All nodes have parent links. The tree is used both to go from
5486
+ // line numbers to line objects, and to go from objects to numbers.
5487
+ // It also indexes by height, and is used to convert between height
5488
+ // and line object, and to find the total height of the document.
5489
+ //
5490
+ // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
5491
+
5492
+ function LeafChunk(lines) {
5493
+ var this$1 = this;
5494
+
5495
+ this.lines = lines
5496
+ this.parent = null
5497
+ var height = 0
5498
+ for (var i = 0; i < lines.length; ++i) {
5499
+ lines[i].parent = this$1
5500
+ height += lines[i].height
5501
+ }
5502
+ this.height = height
5503
+ }
5504
+
5505
+ LeafChunk.prototype = {
5506
+ chunkSize: function chunkSize() { return this.lines.length },
5507
+
5508
+ // Remove the n lines at offset 'at'.
5509
+ removeInner: function removeInner(at, n) {
5510
+ var this$1 = this;
5511
+
5512
+ for (var i = at, e = at + n; i < e; ++i) {
5513
+ var line = this$1.lines[i]
5514
+ this$1.height -= line.height
5515
+ cleanUpLine(line)
5516
+ signalLater(line, "delete")
5517
+ }
5518
+ this.lines.splice(at, n)
5519
+ },
5520
+
5521
+ // Helper used to collapse a small branch into a single leaf.
5522
+ collapse: function collapse(lines) {
5523
+ lines.push.apply(lines, this.lines)
5524
+ },
5525
+
5526
+ // Insert the given array of lines at offset 'at', count them as
5527
+ // having the given height.
5528
+ insertInner: function insertInner(at, lines, height) {
5529
+ var this$1 = this;
5530
+
5531
+ this.height += height
5532
+ this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at))
5533
+ for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1 }
5534
+ },
5535
+
5536
+ // Used to iterate over a part of the tree.
5537
+ iterN: function iterN(at, n, op) {
5538
+ var this$1 = this;
5539
+
5540
+ for (var e = at + n; at < e; ++at)
5541
+ { if (op(this$1.lines[at])) { return true } }
5542
+ }
5543
+ }
5544
+
5545
+ function BranchChunk(children) {
5546
+ var this$1 = this;
5547
+
5548
+ this.children = children
5549
+ var size = 0, height = 0
5550
+ for (var i = 0; i < children.length; ++i) {
5551
+ var ch = children[i]
5552
+ size += ch.chunkSize(); height += ch.height
5553
+ ch.parent = this$1
5554
+ }
5555
+ this.size = size
5556
+ this.height = height
5557
+ this.parent = null
5558
+ }
5559
+
5560
+ BranchChunk.prototype = {
5561
+ chunkSize: function chunkSize() { return this.size },
5562
+
5563
+ removeInner: function removeInner(at, n) {
5564
+ var this$1 = this;
5565
+
5566
+ this.size -= n
5567
+ for (var i = 0; i < this.children.length; ++i) {
5568
+ var child = this$1.children[i], sz = child.chunkSize()
5569
+ if (at < sz) {
5570
+ var rm = Math.min(n, sz - at), oldHeight = child.height
5571
+ child.removeInner(at, rm)
5572
+ this$1.height -= oldHeight - child.height
5573
+ if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null }
5574
+ if ((n -= rm) == 0) { break }
5575
+ at = 0
5576
+ } else { at -= sz }
5577
+ }
5578
+ // If the result is smaller than 25 lines, ensure that it is a
5579
+ // single leaf node.
5580
+ if (this.size - n < 25 &&
5581
+ (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
5582
+ var lines = []
5583
+ this.collapse(lines)
5584
+ this.children = [new LeafChunk(lines)]
5585
+ this.children[0].parent = this
5586
+ }
5587
+ },
5588
+
5589
+ collapse: function collapse(lines) {
5590
+ var this$1 = this;
5591
+
5592
+ for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines) }
5593
+ },
5594
+
5595
+ insertInner: function insertInner(at, lines, height) {
5596
+ var this$1 = this;
5597
+
5598
+ this.size += lines.length
5599
+ this.height += height
5600
+ for (var i = 0; i < this.children.length; ++i) {
5601
+ var child = this$1.children[i], sz = child.chunkSize()
5602
+ if (at <= sz) {
5603
+ child.insertInner(at, lines, height)
5604
+ if (child.lines && child.lines.length > 50) {
5605
+ // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.
5606
+ // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.
5607
+ var remaining = child.lines.length % 25 + 25
5608
+ for (var pos = remaining; pos < child.lines.length;) {
5609
+ var leaf = new LeafChunk(child.lines.slice(pos, pos += 25))
5610
+ child.height -= leaf.height
5611
+ this$1.children.splice(++i, 0, leaf)
5612
+ leaf.parent = this$1
5613
+ }
5614
+ child.lines = child.lines.slice(0, remaining)
5615
+ this$1.maybeSpill()
5616
+ }
5617
+ break
5618
+ }
5619
+ at -= sz
5620
+ }
5621
+ },
5622
+
5623
+ // When a node has grown, check whether it should be split.
5624
+ maybeSpill: function maybeSpill() {
5625
+ if (this.children.length <= 10) { return }
5626
+ var me = this
5627
+ do {
5628
+ var spilled = me.children.splice(me.children.length - 5, 5)
5629
+ var sibling = new BranchChunk(spilled)
5630
+ if (!me.parent) { // Become the parent node
5631
+ var copy = new BranchChunk(me.children)
5632
+ copy.parent = me
5633
+ me.children = [copy, sibling]
5634
+ me = copy
5635
+ } else {
5636
+ me.size -= sibling.size
5637
+ me.height -= sibling.height
5638
+ var myIndex = indexOf(me.parent.children, me)
5639
+ me.parent.children.splice(myIndex + 1, 0, sibling)
5640
+ }
5641
+ sibling.parent = me.parent
5642
+ } while (me.children.length > 10)
5643
+ me.parent.maybeSpill()
5644
+ },
5645
+
5646
+ iterN: function iterN(at, n, op) {
5647
+ var this$1 = this;
5648
+
5649
+ for (var i = 0; i < this.children.length; ++i) {
5650
+ var child = this$1.children[i], sz = child.chunkSize()
5651
+ if (at < sz) {
5652
+ var used = Math.min(n, sz - at)
5653
+ if (child.iterN(at, used, op)) { return true }
5654
+ if ((n -= used) == 0) { break }
5655
+ at = 0
5656
+ } else { at -= sz }
5657
+ }
5658
+ }
5659
+ }
5660
+
5661
+ // Line widgets are block elements displayed above or below a line.
5662
+
5663
+ var LineWidget = function(doc, node, options) {
5664
+ var this$1 = this;
5665
+
5666
+ if (options) { for (var opt in options) { if (options.hasOwnProperty(opt))
5667
+ { this$1[opt] = options[opt] } } }
5668
+ this.doc = doc
5669
+ this.node = node
5670
+ };
5671
+
5672
+ LineWidget.prototype.clear = function () {
5673
+ var this$1 = this;
5674
+
5675
+ var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line)
5676
+ if (no == null || !ws) { return }
5677
+ for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1) } }
5678
+ if (!ws.length) { line.widgets = null }
5679
+ var height = widgetHeight(this)
5680
+ updateLineHeight(line, Math.max(0, line.height - height))
5681
+ if (cm) {
5682
+ runInOp(cm, function () {
5683
+ adjustScrollWhenAboveVisible(cm, line, -height)
5684
+ regLineChange(cm, no, "widget")
5685
+ })
5686
+ signalLater(cm, "lineWidgetCleared", cm, this, no)
5687
+ }
5688
+ };
5689
+
5690
+ LineWidget.prototype.changed = function () {
5691
+ var this$1 = this;
5692
+
5693
+ var oldH = this.height, cm = this.doc.cm, line = this.line
5694
+ this.height = null
5695
+ var diff = widgetHeight(this) - oldH
5696
+ if (!diff) { return }
5697
+ updateLineHeight(line, line.height + diff)
5698
+ if (cm) {
5699
+ runInOp(cm, function () {
5700
+ cm.curOp.forceUpdate = true
5701
+ adjustScrollWhenAboveVisible(cm, line, diff)
5702
+ signalLater(cm, "lineWidgetChanged", cm, this$1, lineNo(line))
5703
+ })
5704
+ }
5705
+ };
5706
+ eventMixin(LineWidget)
5707
+
5708
+ function adjustScrollWhenAboveVisible(cm, line, diff) {
5709
+ if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
5710
+ { addToScrollTop(cm, diff) }
5711
+ }
5712
+
5713
+ function addLineWidget(doc, handle, node, options) {
5714
+ var widget = new LineWidget(doc, node, options)
5715
+ var cm = doc.cm
5716
+ if (cm && widget.noHScroll) { cm.display.alignWidgets = true }
5717
+ changeLine(doc, handle, "widget", function (line) {
5718
+ var widgets = line.widgets || (line.widgets = [])
5719
+ if (widget.insertAt == null) { widgets.push(widget) }
5720
+ else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget) }
5721
+ widget.line = line
5722
+ if (cm && !lineIsHidden(doc, line)) {
5723
+ var aboveVisible = heightAtLine(line) < doc.scrollTop
5724
+ updateLineHeight(line, line.height + widgetHeight(widget))
5725
+ if (aboveVisible) { addToScrollTop(cm, widget.height) }
5726
+ cm.curOp.forceUpdate = true
5727
+ }
5728
+ return true
5729
+ })
5730
+ if (cm) { signalLater(cm, "lineWidgetAdded", cm, widget, typeof handle == "number" ? handle : lineNo(handle)) }
5731
+ return widget
5732
+ }
5733
+
5734
+ // TEXTMARKERS
5735
+
5736
+ // Created with markText and setBookmark methods. A TextMarker is a
5737
+ // handle that can be used to clear or find a marked position in the
5738
+ // document. Line objects hold arrays (markedSpans) containing
5739
+ // {from, to, marker} object pointing to such marker objects, and
5740
+ // indicating that such a marker is present on that line. Multiple
5741
+ // lines may point to the same marker when it spans across lines.
5742
+ // The spans will have null for their from/to properties when the
5743
+ // marker continues beyond the start/end of the line. Markers have
5744
+ // links back to the lines they currently touch.
5745
+
5746
+ // Collapsed markers have unique ids, in order to be able to order
5747
+ // them, which is needed for uniquely determining an outer marker
5748
+ // when they overlap (they may nest, but not partially overlap).
5749
+ var nextMarkerId = 0
5750
+
5751
+ var TextMarker = function(doc, type) {
5752
+ this.lines = []
5753
+ this.type = type
5754
+ this.doc = doc
5755
+ this.id = ++nextMarkerId
5756
+ };
5757
+
5758
+ // Clear the marker.
5759
+ TextMarker.prototype.clear = function () {
5760
+ var this$1 = this;
5761
+
5762
+ if (this.explicitlyCleared) { return }
5763
+ var cm = this.doc.cm, withOp = cm && !cm.curOp
5764
+ if (withOp) { startOperation(cm) }
5765
+ if (hasHandler(this, "clear")) {
5766
+ var found = this.find()
5767
+ if (found) { signalLater(this, "clear", found.from, found.to) }
5768
+ }
5769
+ var min = null, max = null
5770
+ for (var i = 0; i < this.lines.length; ++i) {
5771
+ var line = this$1.lines[i]
5772
+ var span = getMarkedSpanFor(line.markedSpans, this$1)
5773
+ if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), "text") }
5774
+ else if (cm) {
5775
+ if (span.to != null) { max = lineNo(line) }
5776
+ if (span.from != null) { min = lineNo(line) }
5777
+ }
5778
+ line.markedSpans = removeMarkedSpan(line.markedSpans, span)
5779
+ if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm)
5780
+ { updateLineHeight(line, textHeight(cm.display)) }
5781
+ }
5782
+ if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {
5783
+ var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual)
5784
+ if (len > cm.display.maxLineLength) {
5785
+ cm.display.maxLine = visual
5786
+ cm.display.maxLineLength = len
5787
+ cm.display.maxLineChanged = true
5788
+ }
5789
+ } }
5790
+
5791
+ if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1) }
5792
+ this.lines.length = 0
5793
+ this.explicitlyCleared = true
5794
+ if (this.atomic && this.doc.cantEdit) {
5795
+ this.doc.cantEdit = false
5796
+ if (cm) { reCheckSelection(cm.doc) }
5797
+ }
5798
+ if (cm) { signalLater(cm, "markerCleared", cm, this, min, max) }
5799
+ if (withOp) { endOperation(cm) }
5800
+ if (this.parent) { this.parent.clear() }
5801
+ };
5802
+
5803
+ // Find the position of the marker in the document. Returns a {from,
5804
+ // to} object by default. Side can be passed to get a specific side
5805
+ // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
5806
+ // Pos objects returned contain a line object, rather than a line
5807
+ // number (used to prevent looking up the same line twice).
5808
+ TextMarker.prototype.find = function (side, lineObj) {
5809
+ var this$1 = this;
5810
+
5811
+ if (side == null && this.type == "bookmark") { side = 1 }
5812
+ var from, to
5813
+ for (var i = 0; i < this.lines.length; ++i) {
5814
+ var line = this$1.lines[i]
5815
+ var span = getMarkedSpanFor(line.markedSpans, this$1)
5816
+ if (span.from != null) {
5817
+ from = Pos(lineObj ? line : lineNo(line), span.from)
5818
+ if (side == -1) { return from }
5819
+ }
5820
+ if (span.to != null) {
5821
+ to = Pos(lineObj ? line : lineNo(line), span.to)
5822
+ if (side == 1) { return to }
5823
+ }
5824
+ }
5825
+ return from && {from: from, to: to}
5826
+ };
5827
+
5828
+ // Signals that the marker's widget changed, and surrounding layout
5829
+ // should be recomputed.
5830
+ TextMarker.prototype.changed = function () {
5831
+ var this$1 = this;
5832
+
5833
+ var pos = this.find(-1, true), widget = this, cm = this.doc.cm
5834
+ if (!pos || !cm) { return }
5835
+ runInOp(cm, function () {
5836
+ var line = pos.line, lineN = lineNo(pos.line)
5837
+ var view = findViewForLine(cm, lineN)
5838
+ if (view) {
5839
+ clearLineMeasurementCacheFor(view)
5840
+ cm.curOp.selectionChanged = cm.curOp.forceUpdate = true
5841
+ }
5842
+ cm.curOp.updateMaxLine = true
5843
+ if (!lineIsHidden(widget.doc, line) && widget.height != null) {
5844
+ var oldHeight = widget.height
5845
+ widget.height = null
5846
+ var dHeight = widgetHeight(widget) - oldHeight
5847
+ if (dHeight)
5848
+ { updateLineHeight(line, line.height + dHeight) }
5849
+ }
5850
+ signalLater(cm, "markerChanged", cm, this$1)
5851
+ })
5852
+ };
5853
+
5854
+ TextMarker.prototype.attachLine = function (line) {
5855
+ if (!this.lines.length && this.doc.cm) {
5856
+ var op = this.doc.cm.curOp
5857
+ if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
5858
+ { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this) }
5859
+ }
5860
+ this.lines.push(line)
5861
+ };
5862
+
5863
+ TextMarker.prototype.detachLine = function (line) {
5864
+ this.lines.splice(indexOf(this.lines, line), 1)
5865
+ if (!this.lines.length && this.doc.cm) {
5866
+ var op = this.doc.cm.curOp
5867
+ ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this)
5868
+ }
5869
+ };
5870
+ eventMixin(TextMarker)
5871
+
5872
+ // Create a marker, wire it up to the right lines, and
5873
+ function markText(doc, from, to, options, type) {
5874
+ // Shared markers (across linked documents) are handled separately
5875
+ // (markTextShared will call out to this again, once per
5876
+ // document).
5877
+ if (options && options.shared) { return markTextShared(doc, from, to, options, type) }
5878
+ // Ensure we are in an operation.
5879
+ if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) }
5880
+
5881
+ var marker = new TextMarker(doc, type), diff = cmp(from, to)
5882
+ if (options) { copyObj(options, marker, false) }
5883
+ // Don't connect empty markers unless clearWhenEmpty is false
5884
+ if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)
5885
+ { return marker }
5886
+ if (marker.replacedWith) {
5887
+ // Showing up as a widget implies collapsed (widget replaces text)
5888
+ marker.collapsed = true
5889
+ marker.widgetNode = eltP("span", [marker.replacedWith], "CodeMirror-widget")
5890
+ if (!options.handleMouseEvents) { marker.widgetNode.setAttribute("cm-ignore-events", "true") }
5891
+ if (options.insertLeft) { marker.widgetNode.insertLeft = true }
5892
+ }
5893
+ if (marker.collapsed) {
5894
+ if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||
5895
+ from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))
5896
+ { throw new Error("Inserting collapsed marker partially overlapping an existing one") }
5897
+ seeCollapsedSpans()
5898
+ }
5899
+
5900
+ if (marker.addToHistory)
5901
+ { addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN) }
5902
+
5903
+ var curLine = from.line, cm = doc.cm, updateMaxLine
5904
+ doc.iter(curLine, to.line + 1, function (line) {
5905
+ if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)
5906
+ { updateMaxLine = true }
5907
+ if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0) }
5908
+ addMarkedSpan(line, new MarkedSpan(marker,
5909
+ curLine == from.line ? from.ch : null,
5910
+ curLine == to.line ? to.ch : null))
5911
+ ++curLine
5912
+ })
5913
+ // lineIsHidden depends on the presence of the spans, so needs a second pass
5914
+ if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) {
5915
+ if (lineIsHidden(doc, line)) { updateLineHeight(line, 0) }
5916
+ }) }
5917
+
5918
+ if (marker.clearOnEnter) { on(marker, "beforeCursorEnter", function () { return marker.clear(); }) }
5919
+
5920
+ if (marker.readOnly) {
5921
+ seeReadOnlySpans()
5922
+ if (doc.history.done.length || doc.history.undone.length)
5923
+ { doc.clearHistory() }
5924
+ }
5925
+ if (marker.collapsed) {
5926
+ marker.id = ++nextMarkerId
5927
+ marker.atomic = true
5928
+ }
5929
+ if (cm) {
5930
+ // Sync editor state
5931
+ if (updateMaxLine) { cm.curOp.updateMaxLine = true }
5932
+ if (marker.collapsed)
5933
+ { regChange(cm, from.line, to.line + 1) }
5934
+ else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)
5935
+ { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, "text") } }
5936
+ if (marker.atomic) { reCheckSelection(cm.doc) }
5937
+ signalLater(cm, "markerAdded", cm, marker)
5938
+ }
5939
+ return marker
5940
+ }
5941
+
5942
+ // SHARED TEXTMARKERS
5943
+
5944
+ // A shared marker spans multiple linked documents. It is
5945
+ // implemented as a meta-marker-object controlling multiple normal
5946
+ // markers.
5947
+ var SharedTextMarker = function(markers, primary) {
5948
+ var this$1 = this;
5949
+
5950
+ this.markers = markers
5951
+ this.primary = primary
5952
+ for (var i = 0; i < markers.length; ++i)
5953
+ { markers[i].parent = this$1 }
5954
+ };
5955
+
5956
+ SharedTextMarker.prototype.clear = function () {
5957
+ var this$1 = this;
5958
+
5959
+ if (this.explicitlyCleared) { return }
5960
+ this.explicitlyCleared = true
5961
+ for (var i = 0; i < this.markers.length; ++i)
5962
+ { this$1.markers[i].clear() }
5963
+ signalLater(this, "clear")
5964
+ };
5965
+
5966
+ SharedTextMarker.prototype.find = function (side, lineObj) {
5967
+ return this.primary.find(side, lineObj)
5968
+ };
5969
+ eventMixin(SharedTextMarker)
5970
+
5971
+ function markTextShared(doc, from, to, options, type) {
5972
+ options = copyObj(options)
5973
+ options.shared = false
5974
+ var markers = [markText(doc, from, to, options, type)], primary = markers[0]
5975
+ var widget = options.widgetNode
5976
+ linkedDocs(doc, function (doc) {
5977
+ if (widget) { options.widgetNode = widget.cloneNode(true) }
5978
+ markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type))
5979
+ for (var i = 0; i < doc.linked.length; ++i)
5980
+ { if (doc.linked[i].isParent) { return } }
5981
+ primary = lst(markers)
5982
+ })
5983
+ return new SharedTextMarker(markers, primary)
5984
+ }
5985
+
5986
+ function findSharedMarkers(doc) {
5987
+ return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; })
5988
+ }
5989
+
5990
+ function copySharedMarkers(doc, markers) {
5991
+ for (var i = 0; i < markers.length; i++) {
5992
+ var marker = markers[i], pos = marker.find()
5993
+ var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to)
5994
+ if (cmp(mFrom, mTo)) {
5995
+ var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type)
5996
+ marker.markers.push(subMark)
5997
+ subMark.parent = marker
5998
+ }
5999
+ }
6000
+ }
6001
+
6002
+ function detachSharedMarkers(markers) {
6003
+ var loop = function ( i ) {
6004
+ var marker = markers[i], linked = [marker.primary.doc]
6005
+ linkedDocs(marker.primary.doc, function (d) { return linked.push(d); })
6006
+ for (var j = 0; j < marker.markers.length; j++) {
6007
+ var subMarker = marker.markers[j]
6008
+ if (indexOf(linked, subMarker.doc) == -1) {
6009
+ subMarker.parent = null
6010
+ marker.markers.splice(j--, 1)
6011
+ }
6012
+ }
6013
+ };
6014
+
6015
+ for (var i = 0; i < markers.length; i++) loop( i );
6016
+ }
6017
+
6018
+ var nextDocId = 0
6019
+ var Doc = function(text, mode, firstLine, lineSep, direction) {
6020
+ if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep, direction) }
6021
+ if (firstLine == null) { firstLine = 0 }
6022
+
6023
+ BranchChunk.call(this, [new LeafChunk([new Line("", null)])])
6024
+ this.first = firstLine
6025
+ this.scrollTop = this.scrollLeft = 0
6026
+ this.cantEdit = false
6027
+ this.cleanGeneration = 1
6028
+ this.modeFrontier = this.highlightFrontier = firstLine
6029
+ var start = Pos(firstLine, 0)
6030
+ this.sel = simpleSelection(start)
6031
+ this.history = new History(null)
6032
+ this.id = ++nextDocId
6033
+ this.modeOption = mode
6034
+ this.lineSep = lineSep
6035
+ this.direction = (direction == "rtl") ? "rtl" : "ltr"
6036
+ this.extend = false
6037
+
6038
+ if (typeof text == "string") { text = this.splitLines(text) }
6039
+ updateDoc(this, {from: start, to: start, text: text})
6040
+ setSelection(this, simpleSelection(start), sel_dontScroll)
6041
+ }
6042
+
6043
+ Doc.prototype = createObj(BranchChunk.prototype, {
6044
+ constructor: Doc,
6045
+ // Iterate over the document. Supports two forms -- with only one
6046
+ // argument, it calls that for each line in the document. With
6047
+ // three, it iterates over the range given by the first two (with
6048
+ // the second being non-inclusive).
6049
+ iter: function(from, to, op) {
6050
+ if (op) { this.iterN(from - this.first, to - from, op) }
6051
+ else { this.iterN(this.first, this.first + this.size, from) }
6052
+ },
6053
+
6054
+ // Non-public interface for adding and removing lines.
6055
+ insert: function(at, lines) {
6056
+ var height = 0
6057
+ for (var i = 0; i < lines.length; ++i) { height += lines[i].height }
6058
+ this.insertInner(at - this.first, lines, height)
6059
+ },
6060
+ remove: function(at, n) { this.removeInner(at - this.first, n) },
6061
+
6062
+ // From here, the methods are part of the public interface. Most
6063
+ // are also available from CodeMirror (editor) instances.
6064
+
6065
+ getValue: function(lineSep) {
6066
+ var lines = getLines(this, this.first, this.first + this.size)
6067
+ if (lineSep === false) { return lines }
6068
+ return lines.join(lineSep || this.lineSeparator())
6069
+ },
6070
+ setValue: docMethodOp(function(code) {
6071
+ var top = Pos(this.first, 0), last = this.first + this.size - 1
6072
+ makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
6073
+ text: this.splitLines(code), origin: "setValue", full: true}, true)
6074
+ if (this.cm) { scrollToCoords(this.cm, 0, 0) }
6075
+ setSelection(this, simpleSelection(top), sel_dontScroll)
6076
+ }),
6077
+ replaceRange: function(code, from, to, origin) {
6078
+ from = clipPos(this, from)
6079
+ to = to ? clipPos(this, to) : from
6080
+ replaceRange(this, code, from, to, origin)
6081
+ },
6082
+ getRange: function(from, to, lineSep) {
6083
+ var lines = getBetween(this, clipPos(this, from), clipPos(this, to))
6084
+ if (lineSep === false) { return lines }
6085
+ return lines.join(lineSep || this.lineSeparator())
6086
+ },
6087
+
6088
+ getLine: function(line) {var l = this.getLineHandle(line); return l && l.text},
6089
+
6090
+ getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }},
6091
+ getLineNumber: function(line) {return lineNo(line)},
6092
+
6093
+ getLineHandleVisualStart: function(line) {
6094
+ if (typeof line == "number") { line = getLine(this, line) }
6095
+ return visualLine(line)
6096
+ },
6097
+
6098
+ lineCount: function() {return this.size},
6099
+ firstLine: function() {return this.first},
6100
+ lastLine: function() {return this.first + this.size - 1},
6101
+
6102
+ clipPos: function(pos) {return clipPos(this, pos)},
6103
+
6104
+ getCursor: function(start) {
6105
+ var range = this.sel.primary(), pos
6106
+ if (start == null || start == "head") { pos = range.head }
6107
+ else if (start == "anchor") { pos = range.anchor }
6108
+ else if (start == "end" || start == "to" || start === false) { pos = range.to() }
6109
+ else { pos = range.from() }
6110
+ return pos
6111
+ },
6112
+ listSelections: function() { return this.sel.ranges },
6113
+ somethingSelected: function() {return this.sel.somethingSelected()},
6114
+
6115
+ setCursor: docMethodOp(function(line, ch, options) {
6116
+ setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options)
6117
+ }),
6118
+ setSelection: docMethodOp(function(anchor, head, options) {
6119
+ setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options)
6120
+ }),
6121
+ extendSelection: docMethodOp(function(head, other, options) {
6122
+ extendSelection(this, clipPos(this, head), other && clipPos(this, other), options)
6123
+ }),
6124
+ extendSelections: docMethodOp(function(heads, options) {
6125
+ extendSelections(this, clipPosArray(this, heads), options)
6126
+ }),
6127
+ extendSelectionsBy: docMethodOp(function(f, options) {
6128
+ var heads = map(this.sel.ranges, f)
6129
+ extendSelections(this, clipPosArray(this, heads), options)
6130
+ }),
6131
+ setSelections: docMethodOp(function(ranges, primary, options) {
6132
+ var this$1 = this;
6133
+
6134
+ if (!ranges.length) { return }
6135
+ var out = []
6136
+ for (var i = 0; i < ranges.length; i++)
6137
+ { out[i] = new Range(clipPos(this$1, ranges[i].anchor),
6138
+ clipPos(this$1, ranges[i].head)) }
6139
+ if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex) }
6140
+ setSelection(this, normalizeSelection(out, primary), options)
6141
+ }),
6142
+ addSelection: docMethodOp(function(anchor, head, options) {
6143
+ var ranges = this.sel.ranges.slice(0)
6144
+ ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)))
6145
+ setSelection(this, normalizeSelection(ranges, ranges.length - 1), options)
6146
+ }),
6147
+
6148
+ getSelection: function(lineSep) {
6149
+ var this$1 = this;
6150
+
6151
+ var ranges = this.sel.ranges, lines
6152
+ for (var i = 0; i < ranges.length; i++) {
6153
+ var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())
6154
+ lines = lines ? lines.concat(sel) : sel
6155
+ }
6156
+ if (lineSep === false) { return lines }
6157
+ else { return lines.join(lineSep || this.lineSeparator()) }
6158
+ },
6159
+ getSelections: function(lineSep) {
6160
+ var this$1 = this;
6161
+
6162
+ var parts = [], ranges = this.sel.ranges
6163
+ for (var i = 0; i < ranges.length; i++) {
6164
+ var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())
6165
+ if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()) }
6166
+ parts[i] = sel
6167
+ }
6168
+ return parts
6169
+ },
6170
+ replaceSelection: function(code, collapse, origin) {
6171
+ var dup = []
6172
+ for (var i = 0; i < this.sel.ranges.length; i++)
6173
+ { dup[i] = code }
6174
+ this.replaceSelections(dup, collapse, origin || "+input")
6175
+ },
6176
+ replaceSelections: docMethodOp(function(code, collapse, origin) {
6177
+ var this$1 = this;
6178
+
6179
+ var changes = [], sel = this.sel
6180
+ for (var i = 0; i < sel.ranges.length; i++) {
6181
+ var range = sel.ranges[i]
6182
+ changes[i] = {from: range.from(), to: range.to(), text: this$1.splitLines(code[i]), origin: origin}
6183
+ }
6184
+ var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse)
6185
+ for (var i$1 = changes.length - 1; i$1 >= 0; i$1--)
6186
+ { makeChange(this$1, changes[i$1]) }
6187
+ if (newSel) { setSelectionReplaceHistory(this, newSel) }
6188
+ else if (this.cm) { ensureCursorVisible(this.cm) }
6189
+ }),
6190
+ undo: docMethodOp(function() {makeChangeFromHistory(this, "undo")}),
6191
+ redo: docMethodOp(function() {makeChangeFromHistory(this, "redo")}),
6192
+ undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true)}),
6193
+ redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true)}),
6194
+
6195
+ setExtending: function(val) {this.extend = val},
6196
+ getExtending: function() {return this.extend},
6197
+
6198
+ historySize: function() {
6199
+ var hist = this.history, done = 0, undone = 0
6200
+ for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done } }
6201
+ for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone } }
6202
+ return {undo: done, redo: undone}
6203
+ },
6204
+ clearHistory: function() {this.history = new History(this.history.maxGeneration)},
6205
+
6206
+ markClean: function() {
6207
+ this.cleanGeneration = this.changeGeneration(true)
6208
+ },
6209
+ changeGeneration: function(forceSplit) {
6210
+ if (forceSplit)
6211
+ { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null }
6212
+ return this.history.generation
6213
+ },
6214
+ isClean: function (gen) {
6215
+ return this.history.generation == (gen || this.cleanGeneration)
6216
+ },
6217
+
6218
+ getHistory: function() {
6219
+ return {done: copyHistoryArray(this.history.done),
6220
+ undone: copyHistoryArray(this.history.undone)}
6221
+ },
6222
+ setHistory: function(histData) {
6223
+ var hist = this.history = new History(this.history.maxGeneration)
6224
+ hist.done = copyHistoryArray(histData.done.slice(0), null, true)
6225
+ hist.undone = copyHistoryArray(histData.undone.slice(0), null, true)
6226
+ },
6227
+
6228
+ setGutterMarker: docMethodOp(function(line, gutterID, value) {
6229
+ return changeLine(this, line, "gutter", function (line) {
6230
+ var markers = line.gutterMarkers || (line.gutterMarkers = {})
6231
+ markers[gutterID] = value
6232
+ if (!value && isEmpty(markers)) { line.gutterMarkers = null }
6233
+ return true
6234
+ })
6235
+ }),
6236
+
6237
+ clearGutter: docMethodOp(function(gutterID) {
6238
+ var this$1 = this;
6239
+
6240
+ this.iter(function (line) {
6241
+ if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
6242
+ changeLine(this$1, line, "gutter", function () {
6243
+ line.gutterMarkers[gutterID] = null
6244
+ if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null }
6245
+ return true
6246
+ })
6247
+ }
6248
+ })
6249
+ }),
6250
+
6251
+ lineInfo: function(line) {
6252
+ var n
6253
+ if (typeof line == "number") {
6254
+ if (!isLine(this, line)) { return null }
6255
+ n = line
6256
+ line = getLine(this, line)
6257
+ if (!line) { return null }
6258
+ } else {
6259
+ n = lineNo(line)
6260
+ if (n == null) { return null }
6261
+ }
6262
+ return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
6263
+ textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
6264
+ widgets: line.widgets}
6265
+ },
6266
+
6267
+ addLineClass: docMethodOp(function(handle, where, cls) {
6268
+ return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
6269
+ var prop = where == "text" ? "textClass"
6270
+ : where == "background" ? "bgClass"
6271
+ : where == "gutter" ? "gutterClass" : "wrapClass"
6272
+ if (!line[prop]) { line[prop] = cls }
6273
+ else if (classTest(cls).test(line[prop])) { return false }
6274
+ else { line[prop] += " " + cls }
6275
+ return true
6276
+ })
6277
+ }),
6278
+ removeLineClass: docMethodOp(function(handle, where, cls) {
6279
+ return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
6280
+ var prop = where == "text" ? "textClass"
6281
+ : where == "background" ? "bgClass"
6282
+ : where == "gutter" ? "gutterClass" : "wrapClass"
6283
+ var cur = line[prop]
6284
+ if (!cur) { return false }
6285
+ else if (cls == null) { line[prop] = null }
6286
+ else {
6287
+ var found = cur.match(classTest(cls))
6288
+ if (!found) { return false }
6289
+ var end = found.index + found[0].length
6290
+ line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null
6291
+ }
6292
+ return true
6293
+ })
6294
+ }),
6295
+
6296
+ addLineWidget: docMethodOp(function(handle, node, options) {
6297
+ return addLineWidget(this, handle, node, options)
6298
+ }),
6299
+ removeLineWidget: function(widget) { widget.clear() },
6300
+
6301
+ markText: function(from, to, options) {
6302
+ return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range")
6303
+ },
6304
+ setBookmark: function(pos, options) {
6305
+ var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
6306
+ insertLeft: options && options.insertLeft,
6307
+ clearWhenEmpty: false, shared: options && options.shared,
6308
+ handleMouseEvents: options && options.handleMouseEvents}
6309
+ pos = clipPos(this, pos)
6310
+ return markText(this, pos, pos, realOpts, "bookmark")
6311
+ },
6312
+ findMarksAt: function(pos) {
6313
+ pos = clipPos(this, pos)
6314
+ var markers = [], spans = getLine(this, pos.line).markedSpans
6315
+ if (spans) { for (var i = 0; i < spans.length; ++i) {
6316
+ var span = spans[i]
6317
+ if ((span.from == null || span.from <= pos.ch) &&
6318
+ (span.to == null || span.to >= pos.ch))
6319
+ { markers.push(span.marker.parent || span.marker) }
6320
+ } }
6321
+ return markers
6322
+ },
6323
+ findMarks: function(from, to, filter) {
6324
+ from = clipPos(this, from); to = clipPos(this, to)
6325
+ var found = [], lineNo = from.line
6326
+ this.iter(from.line, to.line + 1, function (line) {
6327
+ var spans = line.markedSpans
6328
+ if (spans) { for (var i = 0; i < spans.length; i++) {
6329
+ var span = spans[i]
6330
+ if (!(span.to != null && lineNo == from.line && from.ch >= span.to ||
6331
+ span.from == null && lineNo != from.line ||
6332
+ span.from != null && lineNo == to.line && span.from >= to.ch) &&
6333
+ (!filter || filter(span.marker)))
6334
+ { found.push(span.marker.parent || span.marker) }
6335
+ } }
6336
+ ++lineNo
6337
+ })
6338
+ return found
6339
+ },
6340
+ getAllMarks: function() {
6341
+ var markers = []
6342
+ this.iter(function (line) {
6343
+ var sps = line.markedSpans
6344
+ if (sps) { for (var i = 0; i < sps.length; ++i)
6345
+ { if (sps[i].from != null) { markers.push(sps[i].marker) } } }
6346
+ })
6347
+ return markers
6348
+ },
6349
+
6350
+ posFromIndex: function(off) {
6351
+ var ch, lineNo = this.first, sepSize = this.lineSeparator().length
6352
+ this.iter(function (line) {
6353
+ var sz = line.text.length + sepSize
6354
+ if (sz > off) { ch = off; return true }
6355
+ off -= sz
6356
+ ++lineNo
6357
+ })
6358
+ return clipPos(this, Pos(lineNo, ch))
6359
+ },
6360
+ indexFromPos: function (coords) {
6361
+ coords = clipPos(this, coords)
6362
+ var index = coords.ch
6363
+ if (coords.line < this.first || coords.ch < 0) { return 0 }
6364
+ var sepSize = this.lineSeparator().length
6365
+ this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value
6366
+ index += line.text.length + sepSize
6367
+ })
6368
+ return index
6369
+ },
6370
+
6371
+ copy: function(copyHistory) {
6372
+ var doc = new Doc(getLines(this, this.first, this.first + this.size),
6373
+ this.modeOption, this.first, this.lineSep, this.direction)
6374
+ doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft
6375
+ doc.sel = this.sel
6376
+ doc.extend = false
6377
+ if (copyHistory) {
6378
+ doc.history.undoDepth = this.history.undoDepth
6379
+ doc.setHistory(this.getHistory())
6380
+ }
6381
+ return doc
6382
+ },
6383
+
6384
+ linkedDoc: function(options) {
6385
+ if (!options) { options = {} }
6386
+ var from = this.first, to = this.first + this.size
6387
+ if (options.from != null && options.from > from) { from = options.from }
6388
+ if (options.to != null && options.to < to) { to = options.to }
6389
+ var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction)
6390
+ if (options.sharedHist) { copy.history = this.history
6391
+ ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist})
6392
+ copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]
6393
+ copySharedMarkers(copy, findSharedMarkers(this))
6394
+ return copy
6395
+ },
6396
+ unlinkDoc: function(other) {
6397
+ var this$1 = this;
6398
+
6399
+ if (other instanceof CodeMirror) { other = other.doc }
6400
+ if (this.linked) { for (var i = 0; i < this.linked.length; ++i) {
6401
+ var link = this$1.linked[i]
6402
+ if (link.doc != other) { continue }
6403
+ this$1.linked.splice(i, 1)
6404
+ other.unlinkDoc(this$1)
6405
+ detachSharedMarkers(findSharedMarkers(this$1))
6406
+ break
6407
+ } }
6408
+ // If the histories were shared, split them again
6409
+ if (other.history == this.history) {
6410
+ var splitIds = [other.id]
6411
+ linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true)
6412
+ other.history = new History(null)
6413
+ other.history.done = copyHistoryArray(this.history.done, splitIds)
6414
+ other.history.undone = copyHistoryArray(this.history.undone, splitIds)
6415
+ }
6416
+ },
6417
+ iterLinkedDocs: function(f) {linkedDocs(this, f)},
6418
+
6419
+ getMode: function() {return this.mode},
6420
+ getEditor: function() {return this.cm},
6421
+
6422
+ splitLines: function(str) {
6423
+ if (this.lineSep) { return str.split(this.lineSep) }
6424
+ return splitLinesAuto(str)
6425
+ },
6426
+ lineSeparator: function() { return this.lineSep || "\n" },
6427
+
6428
+ setDirection: docMethodOp(function (dir) {
6429
+ if (dir != "rtl") { dir = "ltr" }
6430
+ if (dir == this.direction) { return }
6431
+ this.direction = dir
6432
+ this.iter(function (line) { return line.order = null; })
6433
+ if (this.cm) { directionChanged(this.cm) }
6434
+ })
6435
+ })
6436
+
6437
+ // Public alias.
6438
+ Doc.prototype.eachLine = Doc.prototype.iter
6439
+
6440
+ // Kludge to work around strange IE behavior where it'll sometimes
6441
+ // re-fire a series of drag-related events right after the drop (#1551)
6442
+ var lastDrop = 0
6443
+
6444
+ function onDrop(e) {
6445
+ var cm = this
6446
+ clearDragCursor(cm)
6447
+ if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
6448
+ { return }
6449
+ e_preventDefault(e)
6450
+ if (ie) { lastDrop = +new Date }
6451
+ var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files
6452
+ if (!pos || cm.isReadOnly()) { return }
6453
+ // Might be a file drop, in which case we simply extract the text
6454
+ // and insert it.
6455
+ if (files && files.length && window.FileReader && window.File) {
6456
+ var n = files.length, text = Array(n), read = 0
6457
+ var loadFile = function (file, i) {
6458
+ if (cm.options.allowDropFileTypes &&
6459
+ indexOf(cm.options.allowDropFileTypes, file.type) == -1)
6460
+ { return }
6461
+
6462
+ var reader = new FileReader
6463
+ reader.onload = operation(cm, function () {
6464
+ var content = reader.result
6465
+ if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) { content = "" }
6466
+ text[i] = content
6467
+ if (++read == n) {
6468
+ pos = clipPos(cm.doc, pos)
6469
+ var change = {from: pos, to: pos,
6470
+ text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())),
6471
+ origin: "paste"}
6472
+ makeChange(cm.doc, change)
6473
+ setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)))
6474
+ }
6475
+ })
6476
+ reader.readAsText(file)
6477
+ }
6478
+ for (var i = 0; i < n; ++i) { loadFile(files[i], i) }
6479
+ } else { // Normal drop
6480
+ // Don't do a replace if the drop happened inside of the selected text.
6481
+ if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
6482
+ cm.state.draggingText(e)
6483
+ // Ensure the editor is re-focused
6484
+ setTimeout(function () { return cm.display.input.focus(); }, 20)
6485
+ return
6486
+ }
6487
+ try {
6488
+ var text$1 = e.dataTransfer.getData("Text")
6489
+ if (text$1) {
6490
+ var selected
6491
+ if (cm.state.draggingText && !cm.state.draggingText.copy)
6492
+ { selected = cm.listSelections() }
6493
+ setSelectionNoUndo(cm.doc, simpleSelection(pos, pos))
6494
+ if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1)
6495
+ { replaceRange(cm.doc, "", selected[i$1].anchor, selected[i$1].head, "drag") } }
6496
+ cm.replaceSelection(text$1, "around", "paste")
6497
+ cm.display.input.focus()
6498
+ }
6499
+ }
6500
+ catch(e){}
6501
+ }
6502
+ }
6503
+
6504
+ function onDragStart(cm, e) {
6505
+ if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }
6506
+ if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return }
6507
+
6508
+ e.dataTransfer.setData("Text", cm.getSelection())
6509
+ e.dataTransfer.effectAllowed = "copyMove"
6510
+
6511
+ // Use dummy image instead of default browsers image.
6512
+ // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
6513
+ if (e.dataTransfer.setDragImage && !safari) {
6514
+ var img = elt("img", null, null, "position: fixed; left: 0; top: 0;")
6515
+ img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
6516
+ if (presto) {
6517
+ img.width = img.height = 1
6518
+ cm.display.wrapper.appendChild(img)
6519
+ // Force a relayout, or Opera won't use our image for some obscure reason
6520
+ img._top = img.offsetTop
6521
+ }
6522
+ e.dataTransfer.setDragImage(img, 0, 0)
6523
+ if (presto) { img.parentNode.removeChild(img) }
6524
+ }
6525
+ }
6526
+
6527
+ function onDragOver(cm, e) {
6528
+ var pos = posFromMouse(cm, e)
6529
+ if (!pos) { return }
6530
+ var frag = document.createDocumentFragment()
6531
+ drawSelectionCursor(cm, pos, frag)
6532
+ if (!cm.display.dragCursor) {
6533
+ cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors")
6534
+ cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv)
6535
+ }
6536
+ removeChildrenAndAdd(cm.display.dragCursor, frag)
6537
+ }
6538
+
6539
+ function clearDragCursor(cm) {
6540
+ if (cm.display.dragCursor) {
6541
+ cm.display.lineSpace.removeChild(cm.display.dragCursor)
6542
+ cm.display.dragCursor = null
6543
+ }
6544
+ }
6545
+
6546
+ // These must be handled carefully, because naively registering a
6547
+ // handler for each editor will cause the editors to never be
6548
+ // garbage collected.
6549
+
6550
+ function forEachCodeMirror(f) {
6551
+ if (!document.getElementsByClassName) { return }
6552
+ var byClass = document.getElementsByClassName("CodeMirror")
6553
+ for (var i = 0; i < byClass.length; i++) {
6554
+ var cm = byClass[i].CodeMirror
6555
+ if (cm) { f(cm) }
6556
+ }
6557
+ }
6558
+
6559
+ var globalsRegistered = false
6560
+ function ensureGlobalHandlers() {
6561
+ if (globalsRegistered) { return }
6562
+ registerGlobalHandlers()
6563
+ globalsRegistered = true
6564
+ }
6565
+ function registerGlobalHandlers() {
6566
+ // When the window resizes, we need to refresh active editors.
6567
+ var resizeTimer
6568
+ on(window, "resize", function () {
6569
+ if (resizeTimer == null) { resizeTimer = setTimeout(function () {
6570
+ resizeTimer = null
6571
+ forEachCodeMirror(onResize)
6572
+ }, 100) }
6573
+ })
6574
+ // When the window loses focus, we want to show the editor as blurred
6575
+ on(window, "blur", function () { return forEachCodeMirror(onBlur); })
6576
+ }
6577
+ // Called when the window resizes
6578
+ function onResize(cm) {
6579
+ var d = cm.display
6580
+ if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)
6581
+ { return }
6582
+ // Might be a text scaling operation, clear size caches.
6583
+ d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
6584
+ d.scrollbarsClipped = false
6585
+ cm.setSize()
6586
+ }
6587
+
6588
+ var keyNames = {
6589
+ 3: "Pause", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
6590
+ 19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
6591
+ 36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
6592
+ 46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod",
6593
+ 106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete", 145: "ScrollLock",
6594
+ 173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
6595
+ 221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
6596
+ 63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"
6597
+ }
6598
+
6599
+ // Number keys
6600
+ for (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i) }
6601
+ // Alphabetic keys
6602
+ for (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1) }
6603
+ // Function keys
6604
+ for (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = "F" + i$2 }
6605
+
6606
+ var keyMap = {}
6607
+
6608
+ keyMap.basic = {
6609
+ "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
6610
+ "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
6611
+ "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
6612
+ "Tab": "defaultTab", "Shift-Tab": "indentAuto",
6613
+ "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
6614
+ "Esc": "singleSelection"
6615
+ }
6616
+ // Note that the save and find-related commands aren't defined by
6617
+ // default. User code or addons can define them. Unknown commands
6618
+ // are simply ignored.
6619
+ keyMap.pcDefault = {
6620
+ "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
6621
+ "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
6622
+ "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
6623
+ "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
6624
+ "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
6625
+ "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
6626
+ "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
6627
+ fallthrough: "basic"
6628
+ }
6629
+ // Very basic readline/emacs-style bindings, which are standard on Mac.
6630
+ keyMap.emacsy = {
6631
+ "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
6632
+ "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
6633
+ "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
6634
+ "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars",
6635
+ "Ctrl-O": "openLine"
6636
+ }
6637
+ keyMap.macDefault = {
6638
+ "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
6639
+ "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
6640
+ "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
6641
+ "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
6642
+ "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
6643
+ "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
6644
+ "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
6645
+ fallthrough: ["basic", "emacsy"]
6646
+ }
6647
+ keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault
6648
+
6649
+ // KEYMAP DISPATCH
6650
+
6651
+ function normalizeKeyName(name) {
6652
+ var parts = name.split(/-(?!$)/)
6653
+ name = parts[parts.length - 1]
6654
+ var alt, ctrl, shift, cmd
6655
+ for (var i = 0; i < parts.length - 1; i++) {
6656
+ var mod = parts[i]
6657
+ if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true }
6658
+ else if (/^a(lt)?$/i.test(mod)) { alt = true }
6659
+ else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true }
6660
+ else if (/^s(hift)?$/i.test(mod)) { shift = true }
6661
+ else { throw new Error("Unrecognized modifier name: " + mod) }
6662
+ }
6663
+ if (alt) { name = "Alt-" + name }
6664
+ if (ctrl) { name = "Ctrl-" + name }
6665
+ if (cmd) { name = "Cmd-" + name }
6666
+ if (shift) { name = "Shift-" + name }
6667
+ return name
6668
+ }
6669
+
6670
+ // This is a kludge to keep keymaps mostly working as raw objects
6671
+ // (backwards compatibility) while at the same time support features
6672
+ // like normalization and multi-stroke key bindings. It compiles a
6673
+ // new normalized keymap, and then updates the old object to reflect
6674
+ // this.
6675
+ function normalizeKeyMap(keymap) {
6676
+ var copy = {}
6677
+ for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) {
6678
+ var value = keymap[keyname]
6679
+ if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue }
6680
+ if (value == "...") { delete keymap[keyname]; continue }
6681
+
6682
+ var keys = map(keyname.split(" "), normalizeKeyName)
6683
+ for (var i = 0; i < keys.length; i++) {
6684
+ var val = (void 0), name = (void 0)
6685
+ if (i == keys.length - 1) {
6686
+ name = keys.join(" ")
6687
+ val = value
6688
+ } else {
6689
+ name = keys.slice(0, i + 1).join(" ")
6690
+ val = "..."
6691
+ }
6692
+ var prev = copy[name]
6693
+ if (!prev) { copy[name] = val }
6694
+ else if (prev != val) { throw new Error("Inconsistent bindings for " + name) }
6695
+ }
6696
+ delete keymap[keyname]
6697
+ } }
6698
+ for (var prop in copy) { keymap[prop] = copy[prop] }
6699
+ return keymap
6700
+ }
6701
+
6702
+ function lookupKey(key, map, handle, context) {
6703
+ map = getKeyMap(map)
6704
+ var found = map.call ? map.call(key, context) : map[key]
6705
+ if (found === false) { return "nothing" }
6706
+ if (found === "...") { return "multi" }
6707
+ if (found != null && handle(found)) { return "handled" }
6708
+
6709
+ if (map.fallthrough) {
6710
+ if (Object.prototype.toString.call(map.fallthrough) != "[object Array]")
6711
+ { return lookupKey(key, map.fallthrough, handle, context) }
6712
+ for (var i = 0; i < map.fallthrough.length; i++) {
6713
+ var result = lookupKey(key, map.fallthrough[i], handle, context)
6714
+ if (result) { return result }
6715
+ }
6716
+ }
6717
+ }
6718
+
6719
+ // Modifier key presses don't count as 'real' key presses for the
6720
+ // purpose of keymap fallthrough.
6721
+ function isModifierKey(value) {
6722
+ var name = typeof value == "string" ? value : keyNames[value.keyCode]
6723
+ return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod"
6724
+ }
6725
+
6726
+ function addModifierNames(name, event, noShift) {
6727
+ var base = name
6728
+ if (event.altKey && base != "Alt") { name = "Alt-" + name }
6729
+ if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") { name = "Ctrl-" + name }
6730
+ if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") { name = "Cmd-" + name }
6731
+ if (!noShift && event.shiftKey && base != "Shift") { name = "Shift-" + name }
6732
+ return name
6733
+ }
6734
+
6735
+ // Look up the name of a key as indicated by an event object.
6736
+ function keyName(event, noShift) {
6737
+ if (presto && event.keyCode == 34 && event["char"]) { return false }
6738
+ var name = keyNames[event.keyCode]
6739
+ if (name == null || event.altGraphKey) { return false }
6740
+ // Ctrl-ScrollLock has keyCode 3, same as Ctrl-Pause,
6741
+ // so we'll use event.code when available (Chrome 48+, FF 38+, Safari 10.1+)
6742
+ if (event.keyCode == 3 && event.code) { name = event.code }
6743
+ return addModifierNames(name, event, noShift)
6744
+ }
6745
+
6746
+ function getKeyMap(val) {
6747
+ return typeof val == "string" ? keyMap[val] : val
6748
+ }
6749
+
6750
+ // Helper for deleting text near the selection(s), used to implement
6751
+ // backspace, delete, and similar functionality.
6752
+ function deleteNearSelection(cm, compute) {
6753
+ var ranges = cm.doc.sel.ranges, kill = []
6754
+ // Build up a set of ranges to kill first, merging overlapping
6755
+ // ranges.
6756
+ for (var i = 0; i < ranges.length; i++) {
6757
+ var toKill = compute(ranges[i])
6758
+ while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
6759
+ var replaced = kill.pop()
6760
+ if (cmp(replaced.from, toKill.from) < 0) {
6761
+ toKill.from = replaced.from
6762
+ break
6763
+ }
6764
+ }
6765
+ kill.push(toKill)
6766
+ }
6767
+ // Next, remove those actual ranges.
6768
+ runInOp(cm, function () {
6769
+ for (var i = kill.length - 1; i >= 0; i--)
6770
+ { replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete") }
6771
+ ensureCursorVisible(cm)
6772
+ })
6773
+ }
6774
+
6775
+ function moveCharLogically(line, ch, dir) {
6776
+ var target = skipExtendingChars(line.text, ch + dir, dir)
6777
+ return target < 0 || target > line.text.length ? null : target
6778
+ }
6779
+
6780
+ function moveLogically(line, start, dir) {
6781
+ var ch = moveCharLogically(line, start.ch, dir)
6782
+ return ch == null ? null : new Pos(start.line, ch, dir < 0 ? "after" : "before")
6783
+ }
6784
+
6785
+ function endOfLine(visually, cm, lineObj, lineNo, dir) {
6786
+ if (visually) {
6787
+ var order = getOrder(lineObj, cm.doc.direction)
6788
+ if (order) {
6789
+ var part = dir < 0 ? lst(order) : order[0]
6790
+ var moveInStorageOrder = (dir < 0) == (part.level == 1)
6791
+ var sticky = moveInStorageOrder ? "after" : "before"
6792
+ var ch
6793
+ // With a wrapped rtl chunk (possibly spanning multiple bidi parts),
6794
+ // it could be that the last bidi part is not on the last visual line,
6795
+ // since visual lines contain content order-consecutive chunks.
6796
+ // Thus, in rtl, we are looking for the first (content-order) character
6797
+ // in the rtl chunk that is on the last line (that is, the same line
6798
+ // as the last (content-order) character).
6799
+ if (part.level > 0 || cm.doc.direction == "rtl") {
6800
+ var prep = prepareMeasureForLine(cm, lineObj)
6801
+ ch = dir < 0 ? lineObj.text.length - 1 : 0
6802
+ var targetTop = measureCharPrepared(cm, prep, ch).top
6803
+ ch = findFirst(function (ch) { return measureCharPrepared(cm, prep, ch).top == targetTop; }, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch)
6804
+ if (sticky == "before") { ch = moveCharLogically(lineObj, ch, 1) }
6805
+ } else { ch = dir < 0 ? part.to : part.from }
6806
+ return new Pos(lineNo, ch, sticky)
6807
+ }
6808
+ }
6809
+ return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? "before" : "after")
6810
+ }
6811
+
6812
+ function moveVisually(cm, line, start, dir) {
6813
+ var bidi = getOrder(line, cm.doc.direction)
6814
+ if (!bidi) { return moveLogically(line, start, dir) }
6815
+ if (start.ch >= line.text.length) {
6816
+ start.ch = line.text.length
6817
+ start.sticky = "before"
6818
+ } else if (start.ch <= 0) {
6819
+ start.ch = 0
6820
+ start.sticky = "after"
6821
+ }
6822
+ var partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos]
6823
+ if (cm.doc.direction == "ltr" && part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) {
6824
+ // Case 1: We move within an ltr part in an ltr editor. Even with wrapped lines,
6825
+ // nothing interesting happens.
6826
+ return moveLogically(line, start, dir)
6827
+ }
6828
+
6829
+ var mv = function (pos, dir) { return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir); }
6830
+ var prep
6831
+ var getWrappedLineExtent = function (ch) {
6832
+ if (!cm.options.lineWrapping) { return {begin: 0, end: line.text.length} }
6833
+ prep = prep || prepareMeasureForLine(cm, line)
6834
+ return wrappedLineExtentChar(cm, line, prep, ch)
6835
+ }
6836
+ var wrappedLineExtent = getWrappedLineExtent(start.sticky == "before" ? mv(start, -1) : start.ch)
6837
+
6838
+ if (cm.doc.direction == "rtl" || part.level == 1) {
6839
+ var moveInStorageOrder = (part.level == 1) == (dir < 0)
6840
+ var ch = mv(start, moveInStorageOrder ? 1 : -1)
6841
+ if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {
6842
+ // Case 2: We move within an rtl part or in an rtl editor on the same visual line
6843
+ var sticky = moveInStorageOrder ? "before" : "after"
6844
+ return new Pos(start.line, ch, sticky)
6845
+ }
6846
+ }
6847
+
6848
+ // Case 3: Could not move within this bidi part in this visual line, so leave
6849
+ // the current bidi part
6850
+
6851
+ var searchInVisualLine = function (partPos, dir, wrappedLineExtent) {
6852
+ var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder
6853
+ ? new Pos(start.line, mv(ch, 1), "before")
6854
+ : new Pos(start.line, ch, "after"); }
6855
+
6856
+ for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {
6857
+ var part = bidi[partPos]
6858
+ var moveInStorageOrder = (dir > 0) == (part.level != 1)
6859
+ var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1)
6860
+ if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) }
6861
+ ch = moveInStorageOrder ? part.from : mv(part.to, -1)
6862
+ if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) }
6863
+ }
6864
+ }
6865
+
6866
+ // Case 3a: Look for other bidi parts on the same visual line
6867
+ var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent)
6868
+ if (res) { return res }
6869
+
6870
+ // Case 3b: Look for other bidi parts on the next visual line
6871
+ var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1)
6872
+ if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {
6873
+ res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh))
6874
+ if (res) { return res }
6875
+ }
6876
+
6877
+ // Case 4: Nowhere to move
6878
+ return null
6879
+ }
6880
+
6881
+ // Commands are parameter-less actions that can be performed on an
6882
+ // editor, mostly used for keybindings.
6883
+ var commands = {
6884
+ selectAll: selectAll,
6885
+ singleSelection: function (cm) { return cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll); },
6886
+ killLine: function (cm) { return deleteNearSelection(cm, function (range) {
6887
+ if (range.empty()) {
6888
+ var len = getLine(cm.doc, range.head.line).text.length
6889
+ if (range.head.ch == len && range.head.line < cm.lastLine())
6890
+ { return {from: range.head, to: Pos(range.head.line + 1, 0)} }
6891
+ else
6892
+ { return {from: range.head, to: Pos(range.head.line, len)} }
6893
+ } else {
6894
+ return {from: range.from(), to: range.to()}
6895
+ }
6896
+ }); },
6897
+ deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({
6898
+ from: Pos(range.from().line, 0),
6899
+ to: clipPos(cm.doc, Pos(range.to().line + 1, 0))
6900
+ }); }); },
6901
+ delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({
6902
+ from: Pos(range.from().line, 0), to: range.from()
6903
+ }); }); },
6904
+ delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) {
6905
+ var top = cm.charCoords(range.head, "div").top + 5
6906
+ var leftPos = cm.coordsChar({left: 0, top: top}, "div")
6907
+ return {from: leftPos, to: range.from()}
6908
+ }); },
6909
+ delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) {
6910
+ var top = cm.charCoords(range.head, "div").top + 5
6911
+ var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
6912
+ return {from: range.from(), to: rightPos }
6913
+ }); },
6914
+ undo: function (cm) { return cm.undo(); },
6915
+ redo: function (cm) { return cm.redo(); },
6916
+ undoSelection: function (cm) { return cm.undoSelection(); },
6917
+ redoSelection: function (cm) { return cm.redoSelection(); },
6918
+ goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); },
6919
+ goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); },
6920
+ goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); },
6921
+ {origin: "+move", bias: 1}
6922
+ ); },
6923
+ goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); },
6924
+ {origin: "+move", bias: 1}
6925
+ ); },
6926
+ goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); },
6927
+ {origin: "+move", bias: -1}
6928
+ ); },
6929
+ goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) {
6930
+ var top = cm.cursorCoords(range.head, "div").top + 5
6931
+ return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
6932
+ }, sel_move); },
6933
+ goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) {
6934
+ var top = cm.cursorCoords(range.head, "div").top + 5
6935
+ return cm.coordsChar({left: 0, top: top}, "div")
6936
+ }, sel_move); },
6937
+ goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) {
6938
+ var top = cm.cursorCoords(range.head, "div").top + 5
6939
+ var pos = cm.coordsChar({left: 0, top: top}, "div")
6940
+ if (pos.ch < cm.getLine(pos.line).search(/\S/)) { return lineStartSmart(cm, range.head) }
6941
+ return pos
6942
+ }, sel_move); },
6943
+ goLineUp: function (cm) { return cm.moveV(-1, "line"); },
6944
+ goLineDown: function (cm) { return cm.moveV(1, "line"); },
6945
+ goPageUp: function (cm) { return cm.moveV(-1, "page"); },
6946
+ goPageDown: function (cm) { return cm.moveV(1, "page"); },
6947
+ goCharLeft: function (cm) { return cm.moveH(-1, "char"); },
6948
+ goCharRight: function (cm) { return cm.moveH(1, "char"); },
6949
+ goColumnLeft: function (cm) { return cm.moveH(-1, "column"); },
6950
+ goColumnRight: function (cm) { return cm.moveH(1, "column"); },
6951
+ goWordLeft: function (cm) { return cm.moveH(-1, "word"); },
6952
+ goGroupRight: function (cm) { return cm.moveH(1, "group"); },
6953
+ goGroupLeft: function (cm) { return cm.moveH(-1, "group"); },
6954
+ goWordRight: function (cm) { return cm.moveH(1, "word"); },
6955
+ delCharBefore: function (cm) { return cm.deleteH(-1, "char"); },
6956
+ delCharAfter: function (cm) { return cm.deleteH(1, "char"); },
6957
+ delWordBefore: function (cm) { return cm.deleteH(-1, "word"); },
6958
+ delWordAfter: function (cm) { return cm.deleteH(1, "word"); },
6959
+ delGroupBefore: function (cm) { return cm.deleteH(-1, "group"); },
6960
+ delGroupAfter: function (cm) { return cm.deleteH(1, "group"); },
6961
+ indentAuto: function (cm) { return cm.indentSelection("smart"); },
6962
+ indentMore: function (cm) { return cm.indentSelection("add"); },
6963
+ indentLess: function (cm) { return cm.indentSelection("subtract"); },
6964
+ insertTab: function (cm) { return cm.replaceSelection("\t"); },
6965
+ insertSoftTab: function (cm) {
6966
+ var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize
6967
+ for (var i = 0; i < ranges.length; i++) {
6968
+ var pos = ranges[i].from()
6969
+ var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)
6970
+ spaces.push(spaceStr(tabSize - col % tabSize))
6971
+ }
6972
+ cm.replaceSelections(spaces)
6973
+ },
6974
+ defaultTab: function (cm) {
6975
+ if (cm.somethingSelected()) { cm.indentSelection("add") }
6976
+ else { cm.execCommand("insertTab") }
6977
+ },
6978
+ // Swap the two chars left and right of each selection's head.
6979
+ // Move cursor behind the two swapped characters afterwards.
6980
+ //
6981
+ // Doesn't consider line feeds a character.
6982
+ // Doesn't scan more than one line above to find a character.
6983
+ // Doesn't do anything on an empty line.
6984
+ // Doesn't do anything with non-empty selections.
6985
+ transposeChars: function (cm) { return runInOp(cm, function () {
6986
+ var ranges = cm.listSelections(), newSel = []
6987
+ for (var i = 0; i < ranges.length; i++) {
6988
+ if (!ranges[i].empty()) { continue }
6989
+ var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text
6990
+ if (line) {
6991
+ if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1) }
6992
+ if (cur.ch > 0) {
6993
+ cur = new Pos(cur.line, cur.ch + 1)
6994
+ cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
6995
+ Pos(cur.line, cur.ch - 2), cur, "+transpose")
6996
+ } else if (cur.line > cm.doc.first) {
6997
+ var prev = getLine(cm.doc, cur.line - 1).text
6998
+ if (prev) {
6999
+ cur = new Pos(cur.line, 1)
7000
+ cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
7001
+ prev.charAt(prev.length - 1),
7002
+ Pos(cur.line - 1, prev.length - 1), cur, "+transpose")
7003
+ }
7004
+ }
7005
+ }
7006
+ newSel.push(new Range(cur, cur))
7007
+ }
7008
+ cm.setSelections(newSel)
7009
+ }); },
7010
+ newlineAndIndent: function (cm) { return runInOp(cm, function () {
7011
+ var sels = cm.listSelections()
7012
+ for (var i = sels.length - 1; i >= 0; i--)
7013
+ { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input") }
7014
+ sels = cm.listSelections()
7015
+ for (var i$1 = 0; i$1 < sels.length; i$1++)
7016
+ { cm.indentLine(sels[i$1].from().line, null, true) }
7017
+ ensureCursorVisible(cm)
7018
+ }); },
7019
+ openLine: function (cm) { return cm.replaceSelection("\n", "start"); },
7020
+ toggleOverwrite: function (cm) { return cm.toggleOverwrite(); }
7021
+ }
7022
+
7023
+
7024
+ function lineStart(cm, lineN) {
7025
+ var line = getLine(cm.doc, lineN)
7026
+ var visual = visualLine(line)
7027
+ if (visual != line) { lineN = lineNo(visual) }
7028
+ return endOfLine(true, cm, visual, lineN, 1)
7029
+ }
7030
+ function lineEnd(cm, lineN) {
7031
+ var line = getLine(cm.doc, lineN)
7032
+ var visual = visualLineEnd(line)
7033
+ if (visual != line) { lineN = lineNo(visual) }
7034
+ return endOfLine(true, cm, line, lineN, -1)
7035
+ }
7036
+ function lineStartSmart(cm, pos) {
7037
+ var start = lineStart(cm, pos.line)
7038
+ var line = getLine(cm.doc, start.line)
7039
+ var order = getOrder(line, cm.doc.direction)
7040
+ if (!order || order[0].level == 0) {
7041
+ var firstNonWS = Math.max(0, line.text.search(/\S/))
7042
+ var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch
7043
+ return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky)
7044
+ }
7045
+ return start
7046
+ }
7047
+
7048
+ // Run a handler that was bound to a key.
7049
+ function doHandleBinding(cm, bound, dropShift) {
7050
+ if (typeof bound == "string") {
7051
+ bound = commands[bound]
7052
+ if (!bound) { return false }
7053
+ }
7054
+ // Ensure previous input has been read, so that the handler sees a
7055
+ // consistent view of the document
7056
+ cm.display.input.ensurePolled()
7057
+ var prevShift = cm.display.shift, done = false
7058
+ try {
7059
+ if (cm.isReadOnly()) { cm.state.suppressEdits = true }
7060
+ if (dropShift) { cm.display.shift = false }
7061
+ done = bound(cm) != Pass
7062
+ } finally {
7063
+ cm.display.shift = prevShift
7064
+ cm.state.suppressEdits = false
7065
+ }
7066
+ return done
7067
+ }
7068
+
7069
+ function lookupKeyForEditor(cm, name, handle) {
7070
+ for (var i = 0; i < cm.state.keyMaps.length; i++) {
7071
+ var result = lookupKey(name, cm.state.keyMaps[i], handle, cm)
7072
+ if (result) { return result }
7073
+ }
7074
+ return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))
7075
+ || lookupKey(name, cm.options.keyMap, handle, cm)
7076
+ }
7077
+
7078
+ // Note that, despite the name, this function is also used to check
7079
+ // for bound mouse clicks.
7080
+
7081
+ var stopSeq = new Delayed
7082
+
7083
+ function dispatchKey(cm, name, e, handle) {
7084
+ var seq = cm.state.keySeq
7085
+ if (seq) {
7086
+ if (isModifierKey(name)) { return "handled" }
7087
+ if (/\'$/.test(name))
7088
+ { cm.state.keySeq = null }
7089
+ else
7090
+ { stopSeq.set(50, function () {
7091
+ if (cm.state.keySeq == seq) {
7092
+ cm.state.keySeq = null
7093
+ cm.display.input.reset()
7094
+ }
7095
+ }) }
7096
+ if (dispatchKeyInner(cm, seq + " " + name, e, handle)) { return true }
7097
+ }
7098
+ return dispatchKeyInner(cm, name, e, handle)
7099
+ }
7100
+
7101
+ function dispatchKeyInner(cm, name, e, handle) {
7102
+ var result = lookupKeyForEditor(cm, name, handle)
7103
+
7104
+ if (result == "multi")
7105
+ { cm.state.keySeq = name }
7106
+ if (result == "handled")
7107
+ { signalLater(cm, "keyHandled", cm, name, e) }
7108
+
7109
+ if (result == "handled" || result == "multi") {
7110
+ e_preventDefault(e)
7111
+ restartBlink(cm)
7112
+ }
7113
+
7114
+ return !!result
7115
+ }
7116
+
7117
+ // Handle a key from the keydown event.
7118
+ function handleKeyBinding(cm, e) {
7119
+ var name = keyName(e, true)
7120
+ if (!name) { return false }
7121
+
7122
+ if (e.shiftKey && !cm.state.keySeq) {
7123
+ // First try to resolve full name (including 'Shift-'). Failing
7124
+ // that, see if there is a cursor-motion command (starting with
7125
+ // 'go') bound to the keyname without 'Shift-'.
7126
+ return dispatchKey(cm, "Shift-" + name, e, function (b) { return doHandleBinding(cm, b, true); })
7127
+ || dispatchKey(cm, name, e, function (b) {
7128
+ if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
7129
+ { return doHandleBinding(cm, b) }
7130
+ })
7131
+ } else {
7132
+ return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); })
7133
+ }
7134
+ }
7135
+
7136
+ // Handle a key from the keypress event
7137
+ function handleCharBinding(cm, e, ch) {
7138
+ return dispatchKey(cm, "'" + ch + "'", e, function (b) { return doHandleBinding(cm, b, true); })
7139
+ }
7140
+
7141
+ var lastStoppedKey = null
7142
+ function onKeyDown(e) {
7143
+ var cm = this
7144
+ cm.curOp.focus = activeElt()
7145
+ if (signalDOMEvent(cm, e)) { return }
7146
+ // IE does strange things with escape.
7147
+ if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false }
7148
+ var code = e.keyCode
7149
+ cm.display.shift = code == 16 || e.shiftKey
7150
+ var handled = handleKeyBinding(cm, e)
7151
+ if (presto) {
7152
+ lastStoppedKey = handled ? code : null
7153
+ // Opera has no cut event... we try to at least catch the key combo
7154
+ if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
7155
+ { cm.replaceSelection("", null, "cut") }
7156
+ }
7157
+
7158
+ // Turn mouse into crosshair when Alt is held on Mac.
7159
+ if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
7160
+ { showCrossHair(cm) }
7161
+ }
7162
+
7163
+ function showCrossHair(cm) {
7164
+ var lineDiv = cm.display.lineDiv
7165
+ addClass(lineDiv, "CodeMirror-crosshair")
7166
+
7167
+ function up(e) {
7168
+ if (e.keyCode == 18 || !e.altKey) {
7169
+ rmClass(lineDiv, "CodeMirror-crosshair")
7170
+ off(document, "keyup", up)
7171
+ off(document, "mouseover", up)
7172
+ }
7173
+ }
7174
+ on(document, "keyup", up)
7175
+ on(document, "mouseover", up)
7176
+ }
7177
+
7178
+ function onKeyUp(e) {
7179
+ if (e.keyCode == 16) { this.doc.sel.shift = false }
7180
+ signalDOMEvent(this, e)
7181
+ }
7182
+
7183
+ function onKeyPress(e) {
7184
+ var cm = this
7185
+ if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return }
7186
+ var keyCode = e.keyCode, charCode = e.charCode
7187
+ if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return}
7188
+ if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return }
7189
+ var ch = String.fromCharCode(charCode == null ? keyCode : charCode)
7190
+ // Some browsers fire keypress events for backspace
7191
+ if (ch == "\x08") { return }
7192
+ if (handleCharBinding(cm, e, ch)) { return }
7193
+ cm.display.input.onKeyPress(e)
7194
+ }
7195
+
7196
+ var DOUBLECLICK_DELAY = 400
7197
+
7198
+ var PastClick = function(time, pos, button) {
7199
+ this.time = time
7200
+ this.pos = pos
7201
+ this.button = button
7202
+ };
7203
+
7204
+ PastClick.prototype.compare = function (time, pos, button) {
7205
+ return this.time + DOUBLECLICK_DELAY > time &&
7206
+ cmp(pos, this.pos) == 0 && button == this.button
7207
+ };
7208
+
7209
+ var lastClick;
7210
+ var lastDoubleClick;
7211
+ function clickRepeat(pos, button) {
7212
+ var now = +new Date
7213
+ if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) {
7214
+ lastClick = lastDoubleClick = null
7215
+ return "triple"
7216
+ } else if (lastClick && lastClick.compare(now, pos, button)) {
7217
+ lastDoubleClick = new PastClick(now, pos, button)
7218
+ lastClick = null
7219
+ return "double"
7220
+ } else {
7221
+ lastClick = new PastClick(now, pos, button)
7222
+ lastDoubleClick = null
7223
+ return "single"
7224
+ }
7225
+ }
7226
+
7227
+ // A mouse down can be a single click, double click, triple click,
7228
+ // start of selection drag, start of text drag, new cursor
7229
+ // (ctrl-click), rectangle drag (alt-drag), or xwin
7230
+ // middle-click-paste. Or it might be a click on something we should
7231
+ // not interfere with, such as a scrollbar or widget.
7232
+ function onMouseDown(e) {
7233
+ var cm = this, display = cm.display
7234
+ if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return }
7235
+ display.input.ensurePolled()
7236
+ display.shift = e.shiftKey
7237
+
7238
+ if (eventInWidget(display, e)) {
7239
+ if (!webkit) {
7240
+ // Briefly turn off draggability, to allow widgets to do
7241
+ // normal dragging things.
7242
+ display.scroller.draggable = false
7243
+ setTimeout(function () { return display.scroller.draggable = true; }, 100)
7244
+ }
7245
+ return
7246
+ }
7247
+ if (clickInGutter(cm, e)) { return }
7248
+ var pos = posFromMouse(cm, e), button = e_button(e), repeat = pos ? clickRepeat(pos, button) : "single"
7249
+ window.focus()
7250
+
7251
+ // #3261: make sure, that we're not starting a second selection
7252
+ if (button == 1 && cm.state.selectingText)
7253
+ { cm.state.selectingText(e) }
7254
+
7255
+ if (pos && handleMappedButton(cm, button, pos, repeat, e)) { return }
7256
+
7257
+ if (button == 1) {
7258
+ if (pos) { leftButtonDown(cm, pos, repeat, e) }
7259
+ else if (e_target(e) == display.scroller) { e_preventDefault(e) }
7260
+ } else if (button == 2) {
7261
+ if (pos) { extendSelection(cm.doc, pos) }
7262
+ setTimeout(function () { return display.input.focus(); }, 20)
7263
+ } else if (button == 3) {
7264
+ if (captureRightClick) { onContextMenu(cm, e) }
7265
+ else { delayBlurEvent(cm) }
7266
+ }
7267
+ }
7268
+
7269
+ function handleMappedButton(cm, button, pos, repeat, event) {
7270
+ var name = "Click"
7271
+ if (repeat == "double") { name = "Double" + name }
7272
+ else if (repeat == "triple") { name = "Triple" + name }
7273
+ name = (button == 1 ? "Left" : button == 2 ? "Middle" : "Right") + name
7274
+
7275
+ return dispatchKey(cm, addModifierNames(name, event), event, function (bound) {
7276
+ if (typeof bound == "string") { bound = commands[bound] }
7277
+ if (!bound) { return false }
7278
+ var done = false
7279
+ try {
7280
+ if (cm.isReadOnly()) { cm.state.suppressEdits = true }
7281
+ done = bound(cm, pos) != Pass
7282
+ } finally {
7283
+ cm.state.suppressEdits = false
7284
+ }
7285
+ return done
7286
+ })
7287
+ }
7288
+
7289
+ function configureMouse(cm, repeat, event) {
7290
+ var option = cm.getOption("configureMouse")
7291
+ var value = option ? option(cm, repeat, event) : {}
7292
+ if (value.unit == null) {
7293
+ var rect = chromeOS ? event.shiftKey && event.metaKey : event.altKey
7294
+ value.unit = rect ? "rectangle" : repeat == "single" ? "char" : repeat == "double" ? "word" : "line"
7295
+ }
7296
+ if (value.extend == null || cm.doc.extend) { value.extend = cm.doc.extend || event.shiftKey }
7297
+ if (value.addNew == null) { value.addNew = mac ? event.metaKey : event.ctrlKey }
7298
+ if (value.moveOnDrag == null) { value.moveOnDrag = !(mac ? event.altKey : event.ctrlKey) }
7299
+ return value
7300
+ }
7301
+
7302
+ function leftButtonDown(cm, pos, repeat, event) {
7303
+ if (ie) { setTimeout(bind(ensureFocus, cm), 0) }
7304
+ else { cm.curOp.focus = activeElt() }
7305
+
7306
+ var behavior = configureMouse(cm, repeat, event)
7307
+
7308
+ var sel = cm.doc.sel, contained
7309
+ if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&
7310
+ repeat == "single" && (contained = sel.contains(pos)) > -1 &&
7311
+ (cmp((contained = sel.ranges[contained]).from(), pos) < 0 || pos.xRel > 0) &&
7312
+ (cmp(contained.to(), pos) > 0 || pos.xRel < 0))
7313
+ { leftButtonStartDrag(cm, event, pos, behavior) }
7314
+ else
7315
+ { leftButtonSelect(cm, event, pos, behavior) }
7316
+ }
7317
+
7318
+ // Start a text drag. When it ends, see if any dragging actually
7319
+ // happen, and treat as a click if it didn't.
7320
+ function leftButtonStartDrag(cm, event, pos, behavior) {
7321
+ var display = cm.display, moved = false
7322
+ var dragEnd = operation(cm, function (e) {
7323
+ if (webkit) { display.scroller.draggable = false }
7324
+ cm.state.draggingText = false
7325
+ off(display.wrapper.ownerDocument, "mouseup", dragEnd)
7326
+ off(display.wrapper.ownerDocument, "mousemove", mouseMove)
7327
+ off(display.scroller, "dragstart", dragStart)
7328
+ off(display.scroller, "drop", dragEnd)
7329
+ if (!moved) {
7330
+ e_preventDefault(e)
7331
+ if (!behavior.addNew)
7332
+ { extendSelection(cm.doc, pos, null, null, behavior.extend) }
7333
+ // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
7334
+ if (webkit || ie && ie_version == 9)
7335
+ { setTimeout(function () {display.wrapper.ownerDocument.body.focus(); display.input.focus()}, 20) }
7336
+ else
7337
+ { display.input.focus() }
7338
+ }
7339
+ })
7340
+ var mouseMove = function(e2) {
7341
+ moved = moved || Math.abs(event.clientX - e2.clientX) + Math.abs(event.clientY - e2.clientY) >= 10
7342
+ }
7343
+ var dragStart = function () { return moved = true; }
7344
+ // Let the drag handler handle this.
7345
+ if (webkit) { display.scroller.draggable = true }
7346
+ cm.state.draggingText = dragEnd
7347
+ dragEnd.copy = !behavior.moveOnDrag
7348
+ // IE's approach to draggable
7349
+ if (display.scroller.dragDrop) { display.scroller.dragDrop() }
7350
+ on(display.wrapper.ownerDocument, "mouseup", dragEnd)
7351
+ on(display.wrapper.ownerDocument, "mousemove", mouseMove)
7352
+ on(display.scroller, "dragstart", dragStart)
7353
+ on(display.scroller, "drop", dragEnd)
7354
+
7355
+ delayBlurEvent(cm)
7356
+ setTimeout(function () { return display.input.focus(); }, 20)
7357
+ }
7358
+
7359
+ function rangeForUnit(cm, pos, unit) {
7360
+ if (unit == "char") { return new Range(pos, pos) }
7361
+ if (unit == "word") { return cm.findWordAt(pos) }
7362
+ if (unit == "line") { return new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }
7363
+ var result = unit(cm, pos)
7364
+ return new Range(result.from, result.to)
7365
+ }
7366
+
7367
+ // Normal selection, as opposed to text dragging.
7368
+ function leftButtonSelect(cm, event, start, behavior) {
7369
+ var display = cm.display, doc = cm.doc
7370
+ e_preventDefault(event)
7371
+
7372
+ var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges
7373
+ if (behavior.addNew && !behavior.extend) {
7374
+ ourIndex = doc.sel.contains(start)
7375
+ if (ourIndex > -1)
7376
+ { ourRange = ranges[ourIndex] }
7377
+ else
7378
+ { ourRange = new Range(start, start) }
7379
+ } else {
7380
+ ourRange = doc.sel.primary()
7381
+ ourIndex = doc.sel.primIndex
7382
+ }
7383
+
7384
+ if (behavior.unit == "rectangle") {
7385
+ if (!behavior.addNew) { ourRange = new Range(start, start) }
7386
+ start = posFromMouse(cm, event, true, true)
7387
+ ourIndex = -1
7388
+ } else {
7389
+ var range = rangeForUnit(cm, start, behavior.unit)
7390
+ if (behavior.extend)
7391
+ { ourRange = extendRange(ourRange, range.anchor, range.head, behavior.extend) }
7392
+ else
7393
+ { ourRange = range }
7394
+ }
7395
+
7396
+ if (!behavior.addNew) {
7397
+ ourIndex = 0
7398
+ setSelection(doc, new Selection([ourRange], 0), sel_mouse)
7399
+ startSel = doc.sel
7400
+ } else if (ourIndex == -1) {
7401
+ ourIndex = ranges.length
7402
+ setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),
7403
+ {scroll: false, origin: "*mouse"})
7404
+ } else if (ranges.length > 1 && ranges[ourIndex].empty() && behavior.unit == "char" && !behavior.extend) {
7405
+ setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),
7406
+ {scroll: false, origin: "*mouse"})
7407
+ startSel = doc.sel
7408
+ } else {
7409
+ replaceOneSelection(doc, ourIndex, ourRange, sel_mouse)
7410
+ }
7411
+
7412
+ var lastPos = start
7413
+ function extendTo(pos) {
7414
+ if (cmp(lastPos, pos) == 0) { return }
7415
+ lastPos = pos
7416
+
7417
+ if (behavior.unit == "rectangle") {
7418
+ var ranges = [], tabSize = cm.options.tabSize
7419
+ var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize)
7420
+ var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize)
7421
+ var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol)
7422
+ for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
7423
+ line <= end; line++) {
7424
+ var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize)
7425
+ if (left == right)
7426
+ { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))) }
7427
+ else if (text.length > leftPos)
7428
+ { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))) }
7429
+ }
7430
+ if (!ranges.length) { ranges.push(new Range(start, start)) }
7431
+ setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
7432
+ {origin: "*mouse", scroll: false})
7433
+ cm.scrollIntoView(pos)
7434
+ } else {
7435
+ var oldRange = ourRange
7436
+ var range = rangeForUnit(cm, pos, behavior.unit)
7437
+ var anchor = oldRange.anchor, head
7438
+ if (cmp(range.anchor, anchor) > 0) {
7439
+ head = range.head
7440
+ anchor = minPos(oldRange.from(), range.anchor)
7441
+ } else {
7442
+ head = range.anchor
7443
+ anchor = maxPos(oldRange.to(), range.head)
7444
+ }
7445
+ var ranges$1 = startSel.ranges.slice(0)
7446
+ ranges$1[ourIndex] = bidiSimplify(cm, new Range(clipPos(doc, anchor), head))
7447
+ setSelection(doc, normalizeSelection(ranges$1, ourIndex), sel_mouse)
7448
+ }
7449
+ }
7450
+
7451
+ var editorSize = display.wrapper.getBoundingClientRect()
7452
+ // Used to ensure timeout re-tries don't fire when another extend
7453
+ // happened in the meantime (clearTimeout isn't reliable -- at
7454
+ // least on Chrome, the timeouts still happen even when cleared,
7455
+ // if the clear happens after their scheduled firing time).
7456
+ var counter = 0
7457
+
7458
+ function extend(e) {
7459
+ var curCount = ++counter
7460
+ var cur = posFromMouse(cm, e, true, behavior.unit == "rectangle")
7461
+ if (!cur) { return }
7462
+ if (cmp(cur, lastPos) != 0) {
7463
+ cm.curOp.focus = activeElt()
7464
+ extendTo(cur)
7465
+ var visible = visibleLines(display, doc)
7466
+ if (cur.line >= visible.to || cur.line < visible.from)
7467
+ { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e) }}), 150) }
7468
+ } else {
7469
+ var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0
7470
+ if (outside) { setTimeout(operation(cm, function () {
7471
+ if (counter != curCount) { return }
7472
+ display.scroller.scrollTop += outside
7473
+ extend(e)
7474
+ }), 50) }
7475
+ }
7476
+ }
7477
+
7478
+ function done(e) {
7479
+ cm.state.selectingText = false
7480
+ counter = Infinity
7481
+ e_preventDefault(e)
7482
+ display.input.focus()
7483
+ off(display.wrapper.ownerDocument, "mousemove", move)
7484
+ off(display.wrapper.ownerDocument, "mouseup", up)
7485
+ doc.history.lastSelOrigin = null
7486
+ }
7487
+
7488
+ var move = operation(cm, function (e) {
7489
+ if (e.buttons === 0 || !e_button(e)) { done(e) }
7490
+ else { extend(e) }
7491
+ })
7492
+ var up = operation(cm, done)
7493
+ cm.state.selectingText = up
7494
+ on(display.wrapper.ownerDocument, "mousemove", move)
7495
+ on(display.wrapper.ownerDocument, "mouseup", up)
7496
+ }
7497
+
7498
+ // Used when mouse-selecting to adjust the anchor to the proper side
7499
+ // of a bidi jump depending on the visual position of the head.
7500
+ function bidiSimplify(cm, range) {
7501
+ var anchor = range.anchor;
7502
+ var head = range.head;
7503
+ var anchorLine = getLine(cm.doc, anchor.line)
7504
+ if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) { return range }
7505
+ var order = getOrder(anchorLine)
7506
+ if (!order) { return range }
7507
+ var index = getBidiPartAt(order, anchor.ch, anchor.sticky), part = order[index]
7508
+ if (part.from != anchor.ch && part.to != anchor.ch) { return range }
7509
+ var boundary = index + ((part.from == anchor.ch) == (part.level != 1) ? 0 : 1)
7510
+ if (boundary == 0 || boundary == order.length) { return range }
7511
+
7512
+ // Compute the relative visual position of the head compared to the
7513
+ // anchor (<0 is to the left, >0 to the right)
7514
+ var leftSide
7515
+ if (head.line != anchor.line) {
7516
+ leftSide = (head.line - anchor.line) * (cm.doc.direction == "ltr" ? 1 : -1) > 0
7517
+ } else {
7518
+ var headIndex = getBidiPartAt(order, head.ch, head.sticky)
7519
+ var dir = headIndex - index || (head.ch - anchor.ch) * (part.level == 1 ? -1 : 1)
7520
+ if (headIndex == boundary - 1 || headIndex == boundary)
7521
+ { leftSide = dir < 0 }
7522
+ else
7523
+ { leftSide = dir > 0 }
7524
+ }
7525
+
7526
+ var usePart = order[boundary + (leftSide ? -1 : 0)]
7527
+ var from = leftSide == (usePart.level == 1)
7528
+ var ch = from ? usePart.from : usePart.to, sticky = from ? "after" : "before"
7529
+ return anchor.ch == ch && anchor.sticky == sticky ? range : new Range(new Pos(anchor.line, ch, sticky), head)
7530
+ }
7531
+
7532
+
7533
+ // Determines whether an event happened in the gutter, and fires the
7534
+ // handlers for the corresponding event.
7535
+ function gutterEvent(cm, e, type, prevent) {
7536
+ var mX, mY
7537
+ if (e.touches) {
7538
+ mX = e.touches[0].clientX
7539
+ mY = e.touches[0].clientY
7540
+ } else {
7541
+ try { mX = e.clientX; mY = e.clientY }
7542
+ catch(e) { return false }
7543
+ }
7544
+ if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false }
7545
+ if (prevent) { e_preventDefault(e) }
7546
+
7547
+ var display = cm.display
7548
+ var lineBox = display.lineDiv.getBoundingClientRect()
7549
+
7550
+ if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) }
7551
+ mY -= lineBox.top - display.viewOffset
7552
+
7553
+ for (var i = 0; i < cm.options.gutters.length; ++i) {
7554
+ var g = display.gutters.childNodes[i]
7555
+ if (g && g.getBoundingClientRect().right >= mX) {
7556
+ var line = lineAtHeight(cm.doc, mY)
7557
+ var gutter = cm.options.gutters[i]
7558
+ signal(cm, type, cm, line, gutter, e)
7559
+ return e_defaultPrevented(e)
7560
+ }
7561
+ }
7562
+ }
7563
+
7564
+ function clickInGutter(cm, e) {
7565
+ return gutterEvent(cm, e, "gutterClick", true)
7566
+ }
7567
+
7568
+ // CONTEXT MENU HANDLING
7569
+
7570
+ // To make the context menu work, we need to briefly unhide the
7571
+ // textarea (making it as unobtrusive as possible) to let the
7572
+ // right-click take effect on it.
7573
+ function onContextMenu(cm, e) {
7574
+ if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return }
7575
+ if (signalDOMEvent(cm, e, "contextmenu")) { return }
7576
+ cm.display.input.onContextMenu(e)
7577
+ }
7578
+
7579
+ function contextMenuInGutter(cm, e) {
7580
+ if (!hasHandler(cm, "gutterContextMenu")) { return false }
7581
+ return gutterEvent(cm, e, "gutterContextMenu", false)
7582
+ }
7583
+
7584
+ function themeChanged(cm) {
7585
+ cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
7586
+ cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-")
7587
+ clearCaches(cm)
7588
+ }
7589
+
7590
+ var Init = {toString: function(){return "CodeMirror.Init"}}
7591
+
7592
+ var defaults = {}
7593
+ var optionHandlers = {}
7594
+
7595
+ function defineOptions(CodeMirror) {
7596
+ var optionHandlers = CodeMirror.optionHandlers
7597
+
7598
+ function option(name, deflt, handle, notOnInit) {
7599
+ CodeMirror.defaults[name] = deflt
7600
+ if (handle) { optionHandlers[name] =
7601
+ notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old) }} : handle }
7602
+ }
7603
+
7604
+ CodeMirror.defineOption = option
7605
+
7606
+ // Passed to option handlers when there is no old value.
7607
+ CodeMirror.Init = Init
7608
+
7609
+ // These two are, on init, called from the constructor because they
7610
+ // have to be initialized before the editor can start at all.
7611
+ option("value", "", function (cm, val) { return cm.setValue(val); }, true)
7612
+ option("mode", null, function (cm, val) {
7613
+ cm.doc.modeOption = val
7614
+ loadMode(cm)
7615
+ }, true)
7616
+
7617
+ option("indentUnit", 2, loadMode, true)
7618
+ option("indentWithTabs", false)
7619
+ option("smartIndent", true)
7620
+ option("tabSize", 4, function (cm) {
7621
+ resetModeState(cm)
7622
+ clearCaches(cm)
7623
+ regChange(cm)
7624
+ }, true)
7625
+
7626
+ option("lineSeparator", null, function (cm, val) {
7627
+ cm.doc.lineSep = val
7628
+ if (!val) { return }
7629
+ var newBreaks = [], lineNo = cm.doc.first
7630
+ cm.doc.iter(function (line) {
7631
+ for (var pos = 0;;) {
7632
+ var found = line.text.indexOf(val, pos)
7633
+ if (found == -1) { break }
7634
+ pos = found + val.length
7635
+ newBreaks.push(Pos(lineNo, found))
7636
+ }
7637
+ lineNo++
7638
+ })
7639
+ for (var i = newBreaks.length - 1; i >= 0; i--)
7640
+ { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)) }
7641
+ })
7642
+ option("specialChars", /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b-\u200f\u2028\u2029\ufeff]/g, function (cm, val, old) {
7643
+ cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g")
7644
+ if (old != Init) { cm.refresh() }
7645
+ })
7646
+ option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true)
7647
+ option("electricChars", true)
7648
+ option("inputStyle", mobile ? "contenteditable" : "textarea", function () {
7649
+ throw new Error("inputStyle can not (yet) be changed in a running editor") // FIXME
7650
+ }, true)
7651
+ option("spellcheck", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true)
7652
+ option("rtlMoveVisually", !windows)
7653
+ option("wholeLineUpdateBefore", true)
7654
+
7655
+ option("theme", "default", function (cm) {
7656
+ themeChanged(cm)
7657
+ guttersChanged(cm)
7658
+ }, true)
7659
+ option("keyMap", "default", function (cm, val, old) {
7660
+ var next = getKeyMap(val)
7661
+ var prev = old != Init && getKeyMap(old)
7662
+ if (prev && prev.detach) { prev.detach(cm, next) }
7663
+ if (next.attach) { next.attach(cm, prev || null) }
7664
+ })
7665
+ option("extraKeys", null)
7666
+ option("configureMouse", null)
7667
+
7668
+ option("lineWrapping", false, wrappingChanged, true)
7669
+ option("gutters", [], function (cm) {
7670
+ setGuttersForLineNumbers(cm.options)
7671
+ guttersChanged(cm)
7672
+ }, true)
7673
+ option("fixedGutter", true, function (cm, val) {
7674
+ cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0"
7675
+ cm.refresh()
7676
+ }, true)
7677
+ option("coverGutterNextToScrollbar", false, function (cm) { return updateScrollbars(cm); }, true)
7678
+ option("scrollbarStyle", "native", function (cm) {
7679
+ initScrollbars(cm)
7680
+ updateScrollbars(cm)
7681
+ cm.display.scrollbars.setScrollTop(cm.doc.scrollTop)
7682
+ cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft)
7683
+ }, true)
7684
+ option("lineNumbers", false, function (cm) {
7685
+ setGuttersForLineNumbers(cm.options)
7686
+ guttersChanged(cm)
7687
+ }, true)
7688
+ option("firstLineNumber", 1, guttersChanged, true)
7689
+ option("lineNumberFormatter", function (integer) { return integer; }, guttersChanged, true)
7690
+ option("showCursorWhenSelecting", false, updateSelection, true)
7691
+
7692
+ option("resetSelectionOnContextMenu", true)
7693
+ option("lineWiseCopyCut", true)
7694
+ option("pasteLinesPerSelection", true)
7695
+
7696
+ option("readOnly", false, function (cm, val) {
7697
+ if (val == "nocursor") {
7698
+ onBlur(cm)
7699
+ cm.display.input.blur()
7700
+ }
7701
+ cm.display.input.readOnlyChanged(val)
7702
+ })
7703
+ option("disableInput", false, function (cm, val) {if (!val) { cm.display.input.reset() }}, true)
7704
+ option("dragDrop", true, dragDropChanged)
7705
+ option("allowDropFileTypes", null)
7706
+
7707
+ option("cursorBlinkRate", 530)
7708
+ option("cursorScrollMargin", 0)
7709
+ option("cursorHeight", 1, updateSelection, true)
7710
+ option("singleCursorHeightPerLine", true, updateSelection, true)
7711
+ option("workTime", 100)
7712
+ option("workDelay", 100)
7713
+ option("flattenSpans", true, resetModeState, true)
7714
+ option("addModeClass", false, resetModeState, true)
7715
+ option("pollInterval", 100)
7716
+ option("undoDepth", 200, function (cm, val) { return cm.doc.history.undoDepth = val; })
7717
+ option("historyEventDelay", 1250)
7718
+ option("viewportMargin", 10, function (cm) { return cm.refresh(); }, true)
7719
+ option("maxHighlightLength", 10000, resetModeState, true)
7720
+ option("moveInputWithCursor", true, function (cm, val) {
7721
+ if (!val) { cm.display.input.resetPosition() }
7722
+ })
7723
+
7724
+ option("tabindex", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || ""; })
7725
+ option("autofocus", null)
7726
+ option("direction", "ltr", function (cm, val) { return cm.doc.setDirection(val); }, true)
7727
+ }
7728
+
7729
+ function guttersChanged(cm) {
7730
+ updateGutters(cm)
7731
+ regChange(cm)
7732
+ alignHorizontally(cm)
7733
+ }
7734
+
7735
+ function dragDropChanged(cm, value, old) {
7736
+ var wasOn = old && old != Init
7737
+ if (!value != !wasOn) {
7738
+ var funcs = cm.display.dragFunctions
7739
+ var toggle = value ? on : off
7740
+ toggle(cm.display.scroller, "dragstart", funcs.start)
7741
+ toggle(cm.display.scroller, "dragenter", funcs.enter)
7742
+ toggle(cm.display.scroller, "dragover", funcs.over)
7743
+ toggle(cm.display.scroller, "dragleave", funcs.leave)
7744
+ toggle(cm.display.scroller, "drop", funcs.drop)
7745
+ }
7746
+ }
7747
+
7748
+ function wrappingChanged(cm) {
7749
+ if (cm.options.lineWrapping) {
7750
+ addClass(cm.display.wrapper, "CodeMirror-wrap")
7751
+ cm.display.sizer.style.minWidth = ""
7752
+ cm.display.sizerWidth = null
7753
+ } else {
7754
+ rmClass(cm.display.wrapper, "CodeMirror-wrap")
7755
+ findMaxLine(cm)
7756
+ }
7757
+ estimateLineHeights(cm)
7758
+ regChange(cm)
7759
+ clearCaches(cm)
7760
+ setTimeout(function () { return updateScrollbars(cm); }, 100)
7761
+ }
7762
+
7763
+ // A CodeMirror instance represents an editor. This is the object
7764
+ // that user code is usually dealing with.
7765
+
7766
+ function CodeMirror(place, options) {
7767
+ var this$1 = this;
7768
+
7769
+ if (!(this instanceof CodeMirror)) { return new CodeMirror(place, options) }
7770
+
7771
+ this.options = options = options ? copyObj(options) : {}
7772
+ // Determine effective options based on given values and defaults.
7773
+ copyObj(defaults, options, false)
7774
+ setGuttersForLineNumbers(options)
7775
+
7776
+ var doc = options.value
7777
+ if (typeof doc == "string") { doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction) }
7778
+ this.doc = doc
7779
+
7780
+ var input = new CodeMirror.inputStyles[options.inputStyle](this)
7781
+ var display = this.display = new Display(place, doc, input)
7782
+ display.wrapper.CodeMirror = this
7783
+ updateGutters(this)
7784
+ themeChanged(this)
7785
+ if (options.lineWrapping)
7786
+ { this.display.wrapper.className += " CodeMirror-wrap" }
7787
+ initScrollbars(this)
7788
+
7789
+ this.state = {
7790
+ keyMaps: [], // stores maps added by addKeyMap
7791
+ overlays: [], // highlighting overlays, as added by addOverlay
7792
+ modeGen: 0, // bumped when mode/overlay changes, used to invalidate highlighting info
7793
+ overwrite: false,
7794
+ delayingBlurEvent: false,
7795
+ focused: false,
7796
+ suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
7797
+ pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll
7798
+ selectingText: false,
7799
+ draggingText: false,
7800
+ highlight: new Delayed(), // stores highlight worker timeout
7801
+ keySeq: null, // Unfinished key sequence
7802
+ specialChars: null
7803
+ }
7804
+
7805
+ if (options.autofocus && !mobile) { display.input.focus() }
7806
+
7807
+ // Override magic textarea content restore that IE sometimes does
7808
+ // on our hidden textarea on reload
7809
+ if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20) }
7810
+
7811
+ registerEventHandlers(this)
7812
+ ensureGlobalHandlers()
7813
+
7814
+ startOperation(this)
7815
+ this.curOp.forceUpdate = true
7816
+ attachDoc(this, doc)
7817
+
7818
+ if ((options.autofocus && !mobile) || this.hasFocus())
7819
+ { setTimeout(bind(onFocus, this), 20) }
7820
+ else
7821
+ { onBlur(this) }
7822
+
7823
+ for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt))
7824
+ { optionHandlers[opt](this$1, options[opt], Init) } }
7825
+ maybeUpdateLineNumberWidth(this)
7826
+ if (options.finishInit) { options.finishInit(this) }
7827
+ for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1) }
7828
+ endOperation(this)
7829
+ // Suppress optimizelegibility in Webkit, since it breaks text
7830
+ // measuring on line wrapping boundaries.
7831
+ if (webkit && options.lineWrapping &&
7832
+ getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
7833
+ { display.lineDiv.style.textRendering = "auto" }
7834
+ }
7835
+
7836
+ // The default configuration options.
7837
+ CodeMirror.defaults = defaults
7838
+ // Functions to run when options are changed.
7839
+ CodeMirror.optionHandlers = optionHandlers
7840
+
7841
+ // Attach the necessary event handlers when initializing the editor
7842
+ function registerEventHandlers(cm) {
7843
+ var d = cm.display
7844
+ on(d.scroller, "mousedown", operation(cm, onMouseDown))
7845
+ // Older IE's will not fire a second mousedown for a double click
7846
+ if (ie && ie_version < 11)
7847
+ { on(d.scroller, "dblclick", operation(cm, function (e) {
7848
+ if (signalDOMEvent(cm, e)) { return }
7849
+ var pos = posFromMouse(cm, e)
7850
+ if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return }
7851
+ e_preventDefault(e)
7852
+ var word = cm.findWordAt(pos)
7853
+ extendSelection(cm.doc, word.anchor, word.head)
7854
+ })) }
7855
+ else
7856
+ { on(d.scroller, "dblclick", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }) }
7857
+ // Some browsers fire contextmenu *after* opening the menu, at
7858
+ // which point we can't mess with it anymore. Context menu is
7859
+ // handled in onMouseDown for these browsers.
7860
+ if (!captureRightClick) { on(d.scroller, "contextmenu", function (e) { return onContextMenu(cm, e); }) }
7861
+
7862
+ // Used to suppress mouse event handling when a touch happens
7863
+ var touchFinished, prevTouch = {end: 0}
7864
+ function finishTouch() {
7865
+ if (d.activeTouch) {
7866
+ touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000)
7867
+ prevTouch = d.activeTouch
7868
+ prevTouch.end = +new Date
7869
+ }
7870
+ }
7871
+ function isMouseLikeTouchEvent(e) {
7872
+ if (e.touches.length != 1) { return false }
7873
+ var touch = e.touches[0]
7874
+ return touch.radiusX <= 1 && touch.radiusY <= 1
7875
+ }
7876
+ function farAway(touch, other) {
7877
+ if (other.left == null) { return true }
7878
+ var dx = other.left - touch.left, dy = other.top - touch.top
7879
+ return dx * dx + dy * dy > 20 * 20
7880
+ }
7881
+ on(d.scroller, "touchstart", function (e) {
7882
+ if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) {
7883
+ d.input.ensurePolled()
7884
+ clearTimeout(touchFinished)
7885
+ var now = +new Date
7886
+ d.activeTouch = {start: now, moved: false,
7887
+ prev: now - prevTouch.end <= 300 ? prevTouch : null}
7888
+ if (e.touches.length == 1) {
7889
+ d.activeTouch.left = e.touches[0].pageX
7890
+ d.activeTouch.top = e.touches[0].pageY
7891
+ }
7892
+ }
7893
+ })
7894
+ on(d.scroller, "touchmove", function () {
7895
+ if (d.activeTouch) { d.activeTouch.moved = true }
7896
+ })
7897
+ on(d.scroller, "touchend", function (e) {
7898
+ var touch = d.activeTouch
7899
+ if (touch && !eventInWidget(d, e) && touch.left != null &&
7900
+ !touch.moved && new Date - touch.start < 300) {
7901
+ var pos = cm.coordsChar(d.activeTouch, "page"), range
7902
+ if (!touch.prev || farAway(touch, touch.prev)) // Single tap
7903
+ { range = new Range(pos, pos) }
7904
+ else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
7905
+ { range = cm.findWordAt(pos) }
7906
+ else // Triple tap
7907
+ { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }
7908
+ cm.setSelection(range.anchor, range.head)
7909
+ cm.focus()
7910
+ e_preventDefault(e)
7911
+ }
7912
+ finishTouch()
7913
+ })
7914
+ on(d.scroller, "touchcancel", finishTouch)
7915
+
7916
+ // Sync scrolling between fake scrollbars and real scrollable
7917
+ // area, ensure viewport is updated when scrolling.
7918
+ on(d.scroller, "scroll", function () {
7919
+ if (d.scroller.clientHeight) {
7920
+ updateScrollTop(cm, d.scroller.scrollTop)
7921
+ setScrollLeft(cm, d.scroller.scrollLeft, true)
7922
+ signal(cm, "scroll", cm)
7923
+ }
7924
+ })
7925
+
7926
+ // Listen to wheel events in order to try and update the viewport on time.
7927
+ on(d.scroller, "mousewheel", function (e) { return onScrollWheel(cm, e); })
7928
+ on(d.scroller, "DOMMouseScroll", function (e) { return onScrollWheel(cm, e); })
7929
+
7930
+ // Prevent wrapper from ever scrolling
7931
+ on(d.wrapper, "scroll", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; })
7932
+
7933
+ d.dragFunctions = {
7934
+ enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e) }},
7935
+ over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},
7936
+ start: function (e) { return onDragStart(cm, e); },
7937
+ drop: operation(cm, onDrop),
7938
+ leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}
7939
+ }
7940
+
7941
+ var inp = d.input.getField()
7942
+ on(inp, "keyup", function (e) { return onKeyUp.call(cm, e); })
7943
+ on(inp, "keydown", operation(cm, onKeyDown))
7944
+ on(inp, "keypress", operation(cm, onKeyPress))
7945
+ on(inp, "focus", function (e) { return onFocus(cm, e); })
7946
+ on(inp, "blur", function (e) { return onBlur(cm, e); })
7947
+ }
7948
+
7949
+ var initHooks = []
7950
+ CodeMirror.defineInitHook = function (f) { return initHooks.push(f); }
7951
+
7952
+ // Indent the given line. The how parameter can be "smart",
7953
+ // "add"/null, "subtract", or "prev". When aggressive is false
7954
+ // (typically set to true for forced single-line indents), empty
7955
+ // lines are not indented, and places where the mode returns Pass
7956
+ // are left alone.
7957
+ function indentLine(cm, n, how, aggressive) {
7958
+ var doc = cm.doc, state
7959
+ if (how == null) { how = "add" }
7960
+ if (how == "smart") {
7961
+ // Fall back to "prev" when the mode doesn't have an indentation
7962
+ // method.
7963
+ if (!doc.mode.indent) { how = "prev" }
7964
+ else { state = getContextBefore(cm, n).state }
7965
+ }
7966
+
7967
+ var tabSize = cm.options.tabSize
7968
+ var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize)
7969
+ if (line.stateAfter) { line.stateAfter = null }
7970
+ var curSpaceString = line.text.match(/^\s*/)[0], indentation
7971
+ if (!aggressive && !/\S/.test(line.text)) {
7972
+ indentation = 0
7973
+ how = "not"
7974
+ } else if (how == "smart") {
7975
+ indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text)
7976
+ if (indentation == Pass || indentation > 150) {
7977
+ if (!aggressive) { return }
7978
+ how = "prev"
7979
+ }
7980
+ }
7981
+ if (how == "prev") {
7982
+ if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize) }
7983
+ else { indentation = 0 }
7984
+ } else if (how == "add") {
7985
+ indentation = curSpace + cm.options.indentUnit
7986
+ } else if (how == "subtract") {
7987
+ indentation = curSpace - cm.options.indentUnit
7988
+ } else if (typeof how == "number") {
7989
+ indentation = curSpace + how
7990
+ }
7991
+ indentation = Math.max(0, indentation)
7992
+
7993
+ var indentString = "", pos = 0
7994
+ if (cm.options.indentWithTabs)
7995
+ { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t"} }
7996
+ if (pos < indentation) { indentString += spaceStr(indentation - pos) }
7997
+
7998
+ if (indentString != curSpaceString) {
7999
+ replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input")
8000
+ line.stateAfter = null
8001
+ return true
8002
+ } else {
8003
+ // Ensure that, if the cursor was in the whitespace at the start
8004
+ // of the line, it is moved to the end of that space.
8005
+ for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {
8006
+ var range = doc.sel.ranges[i$1]
8007
+ if (range.head.line == n && range.head.ch < curSpaceString.length) {
8008
+ var pos$1 = Pos(n, curSpaceString.length)
8009
+ replaceOneSelection(doc, i$1, new Range(pos$1, pos$1))
8010
+ break
8011
+ }
8012
+ }
8013
+ }
8014
+ }
8015
+
8016
+ // This will be set to a {lineWise: bool, text: [string]} object, so
8017
+ // that, when pasting, we know what kind of selections the copied
8018
+ // text was made out of.
8019
+ var lastCopied = null
8020
+
8021
+ function setLastCopied(newLastCopied) {
8022
+ lastCopied = newLastCopied
8023
+ }
8024
+
8025
+ function applyTextInput(cm, inserted, deleted, sel, origin) {
8026
+ var doc = cm.doc
8027
+ cm.display.shift = false
8028
+ if (!sel) { sel = doc.sel }
8029
+
8030
+ var paste = cm.state.pasteIncoming || origin == "paste"
8031
+ var textLines = splitLinesAuto(inserted), multiPaste = null
8032
+ // When pasting N lines into N selections, insert one line per selection
8033
+ if (paste && sel.ranges.length > 1) {
8034
+ if (lastCopied && lastCopied.text.join("\n") == inserted) {
8035
+ if (sel.ranges.length % lastCopied.text.length == 0) {
8036
+ multiPaste = []
8037
+ for (var i = 0; i < lastCopied.text.length; i++)
8038
+ { multiPaste.push(doc.splitLines(lastCopied.text[i])) }
8039
+ }
8040
+ } else if (textLines.length == sel.ranges.length && cm.options.pasteLinesPerSelection) {
8041
+ multiPaste = map(textLines, function (l) { return [l]; })
8042
+ }
8043
+ }
8044
+
8045
+ var updateInput
8046
+ // Normal behavior is to insert the new text into every selection
8047
+ for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) {
8048
+ var range = sel.ranges[i$1]
8049
+ var from = range.from(), to = range.to()
8050
+ if (range.empty()) {
8051
+ if (deleted && deleted > 0) // Handle deletion
8052
+ { from = Pos(from.line, from.ch - deleted) }
8053
+ else if (cm.state.overwrite && !paste) // Handle overwrite
8054
+ { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)) }
8055
+ else if (lastCopied && lastCopied.lineWise && lastCopied.text.join("\n") == inserted)
8056
+ { from = to = Pos(from.line, 0) }
8057
+ }
8058
+ updateInput = cm.curOp.updateInput
8059
+ var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines,
8060
+ origin: origin || (paste ? "paste" : cm.state.cutIncoming ? "cut" : "+input")}
8061
+ makeChange(cm.doc, changeEvent)
8062
+ signalLater(cm, "inputRead", cm, changeEvent)
8063
+ }
8064
+ if (inserted && !paste)
8065
+ { triggerElectric(cm, inserted) }
8066
+
8067
+ ensureCursorVisible(cm)
8068
+ cm.curOp.updateInput = updateInput
8069
+ cm.curOp.typing = true
8070
+ cm.state.pasteIncoming = cm.state.cutIncoming = false
8071
+ }
8072
+
8073
+ function handlePaste(e, cm) {
8074
+ var pasted = e.clipboardData && e.clipboardData.getData("Text")
8075
+ if (pasted) {
8076
+ e.preventDefault()
8077
+ if (!cm.isReadOnly() && !cm.options.disableInput)
8078
+ { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, "paste"); }) }
8079
+ return true
8080
+ }
8081
+ }
8082
+
8083
+ function triggerElectric(cm, inserted) {
8084
+ // When an 'electric' character is inserted, immediately trigger a reindent
8085
+ if (!cm.options.electricChars || !cm.options.smartIndent) { return }
8086
+ var sel = cm.doc.sel
8087
+
8088
+ for (var i = sel.ranges.length - 1; i >= 0; i--) {
8089
+ var range = sel.ranges[i]
8090
+ if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) { continue }
8091
+ var mode = cm.getModeAt(range.head)
8092
+ var indented = false
8093
+ if (mode.electricChars) {
8094
+ for (var j = 0; j < mode.electricChars.length; j++)
8095
+ { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
8096
+ indented = indentLine(cm, range.head.line, "smart")
8097
+ break
8098
+ } }
8099
+ } else if (mode.electricInput) {
8100
+ if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))
8101
+ { indented = indentLine(cm, range.head.line, "smart") }
8102
+ }
8103
+ if (indented) { signalLater(cm, "electricInput", cm, range.head.line) }
8104
+ }
8105
+ }
8106
+
8107
+ function copyableRanges(cm) {
8108
+ var text = [], ranges = []
8109
+ for (var i = 0; i < cm.doc.sel.ranges.length; i++) {
8110
+ var line = cm.doc.sel.ranges[i].head.line
8111
+ var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}
8112
+ ranges.push(lineRange)
8113
+ text.push(cm.getRange(lineRange.anchor, lineRange.head))
8114
+ }
8115
+ return {text: text, ranges: ranges}
8116
+ }
8117
+
8118
+ function disableBrowserMagic(field, spellcheck) {
8119
+ field.setAttribute("autocorrect", "off")
8120
+ field.setAttribute("autocapitalize", "off")
8121
+ field.setAttribute("spellcheck", !!spellcheck)
8122
+ }
8123
+
8124
+ function hiddenTextarea() {
8125
+ var te = elt("textarea", null, null, "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none")
8126
+ var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;")
8127
+ // The textarea is kept positioned near the cursor to prevent the
8128
+ // fact that it'll be scrolled into view on input from scrolling
8129
+ // our fake cursor out of view. On webkit, when wrap=off, paste is
8130
+ // very slow. So make the area wide instead.
8131
+ if (webkit) { te.style.width = "1000px" }
8132
+ else { te.setAttribute("wrap", "off") }
8133
+ // If border: 0; -- iOS fails to open keyboard (issue #1287)
8134
+ if (ios) { te.style.border = "1px solid black" }
8135
+ disableBrowserMagic(te)
8136
+ return div
8137
+ }
8138
+
8139
+ // The publicly visible API. Note that methodOp(f) means
8140
+ // 'wrap f in an operation, performed on its `this` parameter'.
8141
+
8142
+ // This is not the complete set of editor methods. Most of the
8143
+ // methods defined on the Doc type are also injected into
8144
+ // CodeMirror.prototype, for backwards compatibility and
8145
+ // convenience.
8146
+
8147
+ function addEditorMethods(CodeMirror) {
8148
+ var optionHandlers = CodeMirror.optionHandlers
8149
+
8150
+ var helpers = CodeMirror.helpers = {}
8151
+
8152
+ CodeMirror.prototype = {
8153
+ constructor: CodeMirror,
8154
+ focus: function(){window.focus(); this.display.input.focus()},
8155
+
8156
+ setOption: function(option, value) {
8157
+ var options = this.options, old = options[option]
8158
+ if (options[option] == value && option != "mode") { return }
8159
+ options[option] = value
8160
+ if (optionHandlers.hasOwnProperty(option))
8161
+ { operation(this, optionHandlers[option])(this, value, old) }
8162
+ signal(this, "optionChange", this, option)
8163
+ },
8164
+
8165
+ getOption: function(option) {return this.options[option]},
8166
+ getDoc: function() {return this.doc},
8167
+
8168
+ addKeyMap: function(map, bottom) {
8169
+ this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map))
8170
+ },
8171
+ removeKeyMap: function(map) {
8172
+ var maps = this.state.keyMaps
8173
+ for (var i = 0; i < maps.length; ++i)
8174
+ { if (maps[i] == map || maps[i].name == map) {
8175
+ maps.splice(i, 1)
8176
+ return true
8177
+ } }
8178
+ },
8179
+
8180
+ addOverlay: methodOp(function(spec, options) {
8181
+ var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec)
8182
+ if (mode.startState) { throw new Error("Overlays may not be stateful.") }
8183
+ insertSorted(this.state.overlays,
8184
+ {mode: mode, modeSpec: spec, opaque: options && options.opaque,
8185
+ priority: (options && options.priority) || 0},
8186
+ function (overlay) { return overlay.priority; })
8187
+ this.state.modeGen++
8188
+ regChange(this)
8189
+ }),
8190
+ removeOverlay: methodOp(function(spec) {
8191
+ var this$1 = this;
8192
+
8193
+ var overlays = this.state.overlays
8194
+ for (var i = 0; i < overlays.length; ++i) {
8195
+ var cur = overlays[i].modeSpec
8196
+ if (cur == spec || typeof spec == "string" && cur.name == spec) {
8197
+ overlays.splice(i, 1)
8198
+ this$1.state.modeGen++
8199
+ regChange(this$1)
8200
+ return
8201
+ }
8202
+ }
8203
+ }),
8204
+
8205
+ indentLine: methodOp(function(n, dir, aggressive) {
8206
+ if (typeof dir != "string" && typeof dir != "number") {
8207
+ if (dir == null) { dir = this.options.smartIndent ? "smart" : "prev" }
8208
+ else { dir = dir ? "add" : "subtract" }
8209
+ }
8210
+ if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive) }
8211
+ }),
8212
+ indentSelection: methodOp(function(how) {
8213
+ var this$1 = this;
8214
+
8215
+ var ranges = this.doc.sel.ranges, end = -1
8216
+ for (var i = 0; i < ranges.length; i++) {
8217
+ var range = ranges[i]
8218
+ if (!range.empty()) {
8219
+ var from = range.from(), to = range.to()
8220
+ var start = Math.max(end, from.line)
8221
+ end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1
8222
+ for (var j = start; j < end; ++j)
8223
+ { indentLine(this$1, j, how) }
8224
+ var newRanges = this$1.doc.sel.ranges
8225
+ if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)
8226
+ { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll) }
8227
+ } else if (range.head.line > end) {
8228
+ indentLine(this$1, range.head.line, how, true)
8229
+ end = range.head.line
8230
+ if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1) }
8231
+ }
8232
+ }
8233
+ }),
8234
+
8235
+ // Fetch the parser token for a given character. Useful for hacks
8236
+ // that want to inspect the mode state (say, for completion).
8237
+ getTokenAt: function(pos, precise) {
8238
+ return takeToken(this, pos, precise)
8239
+ },
8240
+
8241
+ getLineTokens: function(line, precise) {
8242
+ return takeToken(this, Pos(line), precise, true)
8243
+ },
8244
+
8245
+ getTokenTypeAt: function(pos) {
8246
+ pos = clipPos(this.doc, pos)
8247
+ var styles = getLineStyles(this, getLine(this.doc, pos.line))
8248
+ var before = 0, after = (styles.length - 1) / 2, ch = pos.ch
8249
+ var type
8250
+ if (ch == 0) { type = styles[2] }
8251
+ else { for (;;) {
8252
+ var mid = (before + after) >> 1
8253
+ if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid }
8254
+ else if (styles[mid * 2 + 1] < ch) { before = mid + 1 }
8255
+ else { type = styles[mid * 2 + 2]; break }
8256
+ } }
8257
+ var cut = type ? type.indexOf("overlay ") : -1
8258
+ return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1)
8259
+ },
8260
+
8261
+ getModeAt: function(pos) {
8262
+ var mode = this.doc.mode
8263
+ if (!mode.innerMode) { return mode }
8264
+ return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode
8265
+ },
8266
+
8267
+ getHelper: function(pos, type) {
8268
+ return this.getHelpers(pos, type)[0]
8269
+ },
8270
+
8271
+ getHelpers: function(pos, type) {
8272
+ var this$1 = this;
8273
+
8274
+ var found = []
8275
+ if (!helpers.hasOwnProperty(type)) { return found }
8276
+ var help = helpers[type], mode = this.getModeAt(pos)
8277
+ if (typeof mode[type] == "string") {
8278
+ if (help[mode[type]]) { found.push(help[mode[type]]) }
8279
+ } else if (mode[type]) {
8280
+ for (var i = 0; i < mode[type].length; i++) {
8281
+ var val = help[mode[type][i]]
8282
+ if (val) { found.push(val) }
8283
+ }
8284
+ } else if (mode.helperType && help[mode.helperType]) {
8285
+ found.push(help[mode.helperType])
8286
+ } else if (help[mode.name]) {
8287
+ found.push(help[mode.name])
8288
+ }
8289
+ for (var i$1 = 0; i$1 < help._global.length; i$1++) {
8290
+ var cur = help._global[i$1]
8291
+ if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1)
8292
+ { found.push(cur.val) }
8293
+ }
8294
+ return found
8295
+ },
8296
+
8297
+ getStateAfter: function(line, precise) {
8298
+ var doc = this.doc
8299
+ line = clipLine(doc, line == null ? doc.first + doc.size - 1: line)
8300
+ return getContextBefore(this, line + 1, precise).state
8301
+ },
8302
+
8303
+ cursorCoords: function(start, mode) {
8304
+ var pos, range = this.doc.sel.primary()
8305
+ if (start == null) { pos = range.head }
8306
+ else if (typeof start == "object") { pos = clipPos(this.doc, start) }
8307
+ else { pos = start ? range.from() : range.to() }
8308
+ return cursorCoords(this, pos, mode || "page")
8309
+ },
8310
+
8311
+ charCoords: function(pos, mode) {
8312
+ return charCoords(this, clipPos(this.doc, pos), mode || "page")
8313
+ },
8314
+
8315
+ coordsChar: function(coords, mode) {
8316
+ coords = fromCoordSystem(this, coords, mode || "page")
8317
+ return coordsChar(this, coords.left, coords.top)
8318
+ },
8319
+
8320
+ lineAtHeight: function(height, mode) {
8321
+ height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top
8322
+ return lineAtHeight(this.doc, height + this.display.viewOffset)
8323
+ },
8324
+ heightAtLine: function(line, mode, includeWidgets) {
8325
+ var end = false, lineObj
8326
+ if (typeof line == "number") {
8327
+ var last = this.doc.first + this.doc.size - 1
8328
+ if (line < this.doc.first) { line = this.doc.first }
8329
+ else if (line > last) { line = last; end = true }
8330
+ lineObj = getLine(this.doc, line)
8331
+ } else {
8332
+ lineObj = line
8333
+ }
8334
+ return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page", includeWidgets || end).top +
8335
+ (end ? this.doc.height - heightAtLine(lineObj) : 0)
8336
+ },
8337
+
8338
+ defaultTextHeight: function() { return textHeight(this.display) },
8339
+ defaultCharWidth: function() { return charWidth(this.display) },
8340
+
8341
+ getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}},
8342
+
8343
+ addWidget: function(pos, node, scroll, vert, horiz) {
8344
+ var display = this.display
8345
+ pos = cursorCoords(this, clipPos(this.doc, pos))
8346
+ var top = pos.bottom, left = pos.left
8347
+ node.style.position = "absolute"
8348
+ node.setAttribute("cm-ignore-events", "true")
8349
+ this.display.input.setUneditable(node)
8350
+ display.sizer.appendChild(node)
8351
+ if (vert == "over") {
8352
+ top = pos.top
8353
+ } else if (vert == "above" || vert == "near") {
8354
+ var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
8355
+ hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth)
8356
+ // Default to positioning above (if specified and possible); otherwise default to positioning below
8357
+ if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
8358
+ { top = pos.top - node.offsetHeight }
8359
+ else if (pos.bottom + node.offsetHeight <= vspace)
8360
+ { top = pos.bottom }
8361
+ if (left + node.offsetWidth > hspace)
8362
+ { left = hspace - node.offsetWidth }
8363
+ }
8364
+ node.style.top = top + "px"
8365
+ node.style.left = node.style.right = ""
8366
+ if (horiz == "right") {
8367
+ left = display.sizer.clientWidth - node.offsetWidth
8368
+ node.style.right = "0px"
8369
+ } else {
8370
+ if (horiz == "left") { left = 0 }
8371
+ else if (horiz == "middle") { left = (display.sizer.clientWidth - node.offsetWidth) / 2 }
8372
+ node.style.left = left + "px"
8373
+ }
8374
+ if (scroll)
8375
+ { scrollIntoView(this, {left: left, top: top, right: left + node.offsetWidth, bottom: top + node.offsetHeight}) }
8376
+ },
8377
+
8378
+ triggerOnKeyDown: methodOp(onKeyDown),
8379
+ triggerOnKeyPress: methodOp(onKeyPress),
8380
+ triggerOnKeyUp: onKeyUp,
8381
+ triggerOnMouseDown: methodOp(onMouseDown),
8382
+
8383
+ execCommand: function(cmd) {
8384
+ if (commands.hasOwnProperty(cmd))
8385
+ { return commands[cmd].call(null, this) }
8386
+ },
8387
+
8388
+ triggerElectric: methodOp(function(text) { triggerElectric(this, text) }),
8389
+
8390
+ findPosH: function(from, amount, unit, visually) {
8391
+ var this$1 = this;
8392
+
8393
+ var dir = 1
8394
+ if (amount < 0) { dir = -1; amount = -amount }
8395
+ var cur = clipPos(this.doc, from)
8396
+ for (var i = 0; i < amount; ++i) {
8397
+ cur = findPosH(this$1.doc, cur, dir, unit, visually)
8398
+ if (cur.hitSide) { break }
8399
+ }
8400
+ return cur
8401
+ },
8402
+
8403
+ moveH: methodOp(function(dir, unit) {
8404
+ var this$1 = this;
8405
+
8406
+ this.extendSelectionsBy(function (range) {
8407
+ if (this$1.display.shift || this$1.doc.extend || range.empty())
8408
+ { return findPosH(this$1.doc, range.head, dir, unit, this$1.options.rtlMoveVisually) }
8409
+ else
8410
+ { return dir < 0 ? range.from() : range.to() }
8411
+ }, sel_move)
8412
+ }),
8413
+
8414
+ deleteH: methodOp(function(dir, unit) {
8415
+ var sel = this.doc.sel, doc = this.doc
8416
+ if (sel.somethingSelected())
8417
+ { doc.replaceSelection("", null, "+delete") }
8418
+ else
8419
+ { deleteNearSelection(this, function (range) {
8420
+ var other = findPosH(doc, range.head, dir, unit, false)
8421
+ return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other}
8422
+ }) }
8423
+ }),
8424
+
8425
+ findPosV: function(from, amount, unit, goalColumn) {
8426
+ var this$1 = this;
8427
+
8428
+ var dir = 1, x = goalColumn
8429
+ if (amount < 0) { dir = -1; amount = -amount }
8430
+ var cur = clipPos(this.doc, from)
8431
+ for (var i = 0; i < amount; ++i) {
8432
+ var coords = cursorCoords(this$1, cur, "div")
8433
+ if (x == null) { x = coords.left }
8434
+ else { coords.left = x }
8435
+ cur = findPosV(this$1, coords, dir, unit)
8436
+ if (cur.hitSide) { break }
8437
+ }
8438
+ return cur
8439
+ },
8440
+
8441
+ moveV: methodOp(function(dir, unit) {
8442
+ var this$1 = this;
8443
+
8444
+ var doc = this.doc, goals = []
8445
+ var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected()
8446
+ doc.extendSelectionsBy(function (range) {
8447
+ if (collapse)
8448
+ { return dir < 0 ? range.from() : range.to() }
8449
+ var headPos = cursorCoords(this$1, range.head, "div")
8450
+ if (range.goalColumn != null) { headPos.left = range.goalColumn }
8451
+ goals.push(headPos.left)
8452
+ var pos = findPosV(this$1, headPos, dir, unit)
8453
+ if (unit == "page" && range == doc.sel.primary())
8454
+ { addToScrollTop(this$1, charCoords(this$1, pos, "div").top - headPos.top) }
8455
+ return pos
8456
+ }, sel_move)
8457
+ if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++)
8458
+ { doc.sel.ranges[i].goalColumn = goals[i] } }
8459
+ }),
8460
+
8461
+ // Find the word at the given position (as returned by coordsChar).
8462
+ findWordAt: function(pos) {
8463
+ var doc = this.doc, line = getLine(doc, pos.line).text
8464
+ var start = pos.ch, end = pos.ch
8465
+ if (line) {
8466
+ var helper = this.getHelper(pos, "wordChars")
8467
+ if ((pos.sticky == "before" || end == line.length) && start) { --start; } else { ++end }
8468
+ var startChar = line.charAt(start)
8469
+ var check = isWordChar(startChar, helper)
8470
+ ? function (ch) { return isWordChar(ch, helper); }
8471
+ : /\s/.test(startChar) ? function (ch) { return /\s/.test(ch); }
8472
+ : function (ch) { return (!/\s/.test(ch) && !isWordChar(ch)); }
8473
+ while (start > 0 && check(line.charAt(start - 1))) { --start }
8474
+ while (end < line.length && check(line.charAt(end))) { ++end }
8475
+ }
8476
+ return new Range(Pos(pos.line, start), Pos(pos.line, end))
8477
+ },
8478
+
8479
+ toggleOverwrite: function(value) {
8480
+ if (value != null && value == this.state.overwrite) { return }
8481
+ if (this.state.overwrite = !this.state.overwrite)
8482
+ { addClass(this.display.cursorDiv, "CodeMirror-overwrite") }
8483
+ else
8484
+ { rmClass(this.display.cursorDiv, "CodeMirror-overwrite") }
8485
+
8486
+ signal(this, "overwriteToggle", this, this.state.overwrite)
8487
+ },
8488
+ hasFocus: function() { return this.display.input.getField() == activeElt() },
8489
+ isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) },
8490
+
8491
+ scrollTo: methodOp(function (x, y) { scrollToCoords(this, x, y) }),
8492
+ getScrollInfo: function() {
8493
+ var scroller = this.display.scroller
8494
+ return {left: scroller.scrollLeft, top: scroller.scrollTop,
8495
+ height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,
8496
+ width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,
8497
+ clientHeight: displayHeight(this), clientWidth: displayWidth(this)}
8498
+ },
8499
+
8500
+ scrollIntoView: methodOp(function(range, margin) {
8501
+ if (range == null) {
8502
+ range = {from: this.doc.sel.primary().head, to: null}
8503
+ if (margin == null) { margin = this.options.cursorScrollMargin }
8504
+ } else if (typeof range == "number") {
8505
+ range = {from: Pos(range, 0), to: null}
8506
+ } else if (range.from == null) {
8507
+ range = {from: range, to: null}
8508
+ }
8509
+ if (!range.to) { range.to = range.from }
8510
+ range.margin = margin || 0
8511
+
8512
+ if (range.from.line != null) {
8513
+ scrollToRange(this, range)
8514
+ } else {
8515
+ scrollToCoordsRange(this, range.from, range.to, range.margin)
8516
+ }
8517
+ }),
8518
+
8519
+ setSize: methodOp(function(width, height) {
8520
+ var this$1 = this;
8521
+
8522
+ var interpret = function (val) { return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val; }
8523
+ if (width != null) { this.display.wrapper.style.width = interpret(width) }
8524
+ if (height != null) { this.display.wrapper.style.height = interpret(height) }
8525
+ if (this.options.lineWrapping) { clearLineMeasurementCache(this) }
8526
+ var lineNo = this.display.viewFrom
8527
+ this.doc.iter(lineNo, this.display.viewTo, function (line) {
8528
+ if (line.widgets) { for (var i = 0; i < line.widgets.length; i++)
8529
+ { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo, "widget"); break } } }
8530
+ ++lineNo
8531
+ })
8532
+ this.curOp.forceUpdate = true
8533
+ signal(this, "refresh", this)
8534
+ }),
8535
+
8536
+ operation: function(f){return runInOp(this, f)},
8537
+ startOperation: function(){return startOperation(this)},
8538
+ endOperation: function(){return endOperation(this)},
8539
+
8540
+ refresh: methodOp(function() {
8541
+ var oldHeight = this.display.cachedTextHeight
8542
+ regChange(this)
8543
+ this.curOp.forceUpdate = true
8544
+ clearCaches(this)
8545
+ scrollToCoords(this, this.doc.scrollLeft, this.doc.scrollTop)
8546
+ updateGutterSpace(this)
8547
+ if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)
8548
+ { estimateLineHeights(this) }
8549
+ signal(this, "refresh", this)
8550
+ }),
8551
+
8552
+ swapDoc: methodOp(function(doc) {
8553
+ var old = this.doc
8554
+ old.cm = null
8555
+ attachDoc(this, doc)
8556
+ clearCaches(this)
8557
+ this.display.input.reset()
8558
+ scrollToCoords(this, doc.scrollLeft, doc.scrollTop)
8559
+ this.curOp.forceScroll = true
8560
+ signalLater(this, "swapDoc", this, old)
8561
+ return old
8562
+ }),
8563
+
8564
+ getInputField: function(){return this.display.input.getField()},
8565
+ getWrapperElement: function(){return this.display.wrapper},
8566
+ getScrollerElement: function(){return this.display.scroller},
8567
+ getGutterElement: function(){return this.display.gutters}
8568
+ }
8569
+ eventMixin(CodeMirror)
8570
+
8571
+ CodeMirror.registerHelper = function(type, name, value) {
8572
+ if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []} }
8573
+ helpers[type][name] = value
8574
+ }
8575
+ CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {
8576
+ CodeMirror.registerHelper(type, name, value)
8577
+ helpers[type]._global.push({pred: predicate, val: value})
8578
+ }
8579
+ }
8580
+
8581
+ // Used for horizontal relative motion. Dir is -1 or 1 (left or
8582
+ // right), unit can be "char", "column" (like char, but doesn't
8583
+ // cross line boundaries), "word" (across next word), or "group" (to
8584
+ // the start of next group of word or non-word-non-whitespace
8585
+ // chars). The visually param controls whether, in right-to-left
8586
+ // text, direction 1 means to move towards the next index in the
8587
+ // string, or towards the character to the right of the current
8588
+ // position. The resulting position will have a hitSide=true
8589
+ // property if it reached the end of the document.
8590
+ function findPosH(doc, pos, dir, unit, visually) {
8591
+ var oldPos = pos
8592
+ var origDir = dir
8593
+ var lineObj = getLine(doc, pos.line)
8594
+ function findNextLine() {
8595
+ var l = pos.line + dir
8596
+ if (l < doc.first || l >= doc.first + doc.size) { return false }
8597
+ pos = new Pos(l, pos.ch, pos.sticky)
8598
+ return lineObj = getLine(doc, l)
8599
+ }
8600
+ function moveOnce(boundToLine) {
8601
+ var next
8602
+ if (visually) {
8603
+ next = moveVisually(doc.cm, lineObj, pos, dir)
8604
+ } else {
8605
+ next = moveLogically(lineObj, pos, dir)
8606
+ }
8607
+ if (next == null) {
8608
+ if (!boundToLine && findNextLine())
8609
+ { pos = endOfLine(visually, doc.cm, lineObj, pos.line, dir) }
8610
+ else
8611
+ { return false }
8612
+ } else {
8613
+ pos = next
8614
+ }
8615
+ return true
8616
+ }
8617
+
8618
+ if (unit == "char") {
8619
+ moveOnce()
8620
+ } else if (unit == "column") {
8621
+ moveOnce(true)
8622
+ } else if (unit == "word" || unit == "group") {
8623
+ var sawType = null, group = unit == "group"
8624
+ var helper = doc.cm && doc.cm.getHelper(pos, "wordChars")
8625
+ for (var first = true;; first = false) {
8626
+ if (dir < 0 && !moveOnce(!first)) { break }
8627
+ var cur = lineObj.text.charAt(pos.ch) || "\n"
8628
+ var type = isWordChar(cur, helper) ? "w"
8629
+ : group && cur == "\n" ? "n"
8630
+ : !group || /\s/.test(cur) ? null
8631
+ : "p"
8632
+ if (group && !first && !type) { type = "s" }
8633
+ if (sawType && sawType != type) {
8634
+ if (dir < 0) {dir = 1; moveOnce(); pos.sticky = "after"}
8635
+ break
8636
+ }
8637
+
8638
+ if (type) { sawType = type }
8639
+ if (dir > 0 && !moveOnce(!first)) { break }
8640
+ }
8641
+ }
8642
+ var result = skipAtomic(doc, pos, oldPos, origDir, true)
8643
+ if (equalCursorPos(oldPos, result)) { result.hitSide = true }
8644
+ return result
8645
+ }
8646
+
8647
+ // For relative vertical movement. Dir may be -1 or 1. Unit can be
8648
+ // "page" or "line". The resulting position will have a hitSide=true
8649
+ // property if it reached the end of the document.
8650
+ function findPosV(cm, pos, dir, unit) {
8651
+ var doc = cm.doc, x = pos.left, y
8652
+ if (unit == "page") {
8653
+ var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight)
8654
+ var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3)
8655
+ y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount
8656
+
8657
+ } else if (unit == "line") {
8658
+ y = dir > 0 ? pos.bottom + 3 : pos.top - 3
8659
+ }
8660
+ var target
8661
+ for (;;) {
8662
+ target = coordsChar(cm, x, y)
8663
+ if (!target.outside) { break }
8664
+ if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break }
8665
+ y += dir * 5
8666
+ }
8667
+ return target
8668
+ }
8669
+
8670
+ // CONTENTEDITABLE INPUT STYLE
8671
+
8672
+ var ContentEditableInput = function(cm) {
8673
+ this.cm = cm
8674
+ this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null
8675
+ this.polling = new Delayed()
8676
+ this.composing = null
8677
+ this.gracePeriod = false
8678
+ this.readDOMTimeout = null
8679
+ };
8680
+
8681
+ ContentEditableInput.prototype.init = function (display) {
8682
+ var this$1 = this;
8683
+
8684
+ var input = this, cm = input.cm
8685
+ var div = input.div = display.lineDiv
8686
+ disableBrowserMagic(div, cm.options.spellcheck)
8687
+
8688
+ on(div, "paste", function (e) {
8689
+ if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }
8690
+ // IE doesn't fire input events, so we schedule a read for the pasted content in this way
8691
+ if (ie_version <= 11) { setTimeout(operation(cm, function () { return this$1.updateFromDOM(); }), 20) }
8692
+ })
8693
+
8694
+ on(div, "compositionstart", function (e) {
8695
+ this$1.composing = {data: e.data, done: false}
8696
+ })
8697
+ on(div, "compositionupdate", function (e) {
8698
+ if (!this$1.composing) { this$1.composing = {data: e.data, done: false} }
8699
+ })
8700
+ on(div, "compositionend", function (e) {
8701
+ if (this$1.composing) {
8702
+ if (e.data != this$1.composing.data) { this$1.readFromDOMSoon() }
8703
+ this$1.composing.done = true
8704
+ }
8705
+ })
8706
+
8707
+ on(div, "touchstart", function () { return input.forceCompositionEnd(); })
8708
+
8709
+ on(div, "input", function () {
8710
+ if (!this$1.composing) { this$1.readFromDOMSoon() }
8711
+ })
8712
+
8713
+ function onCopyCut(e) {
8714
+ if (signalDOMEvent(cm, e)) { return }
8715
+ if (cm.somethingSelected()) {
8716
+ setLastCopied({lineWise: false, text: cm.getSelections()})
8717
+ if (e.type == "cut") { cm.replaceSelection("", null, "cut") }
8718
+ } else if (!cm.options.lineWiseCopyCut) {
8719
+ return
8720
+ } else {
8721
+ var ranges = copyableRanges(cm)
8722
+ setLastCopied({lineWise: true, text: ranges.text})
8723
+ if (e.type == "cut") {
8724
+ cm.operation(function () {
8725
+ cm.setSelections(ranges.ranges, 0, sel_dontScroll)
8726
+ cm.replaceSelection("", null, "cut")
8727
+ })
8728
+ }
8729
+ }
8730
+ if (e.clipboardData) {
8731
+ e.clipboardData.clearData()
8732
+ var content = lastCopied.text.join("\n")
8733
+ // iOS exposes the clipboard API, but seems to discard content inserted into it
8734
+ e.clipboardData.setData("Text", content)
8735
+ if (e.clipboardData.getData("Text") == content) {
8736
+ e.preventDefault()
8737
+ return
8738
+ }
8739
+ }
8740
+ // Old-fashioned briefly-focus-a-textarea hack
8741
+ var kludge = hiddenTextarea(), te = kludge.firstChild
8742
+ cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild)
8743
+ te.value = lastCopied.text.join("\n")
8744
+ var hadFocus = document.activeElement
8745
+ selectInput(te)
8746
+ setTimeout(function () {
8747
+ cm.display.lineSpace.removeChild(kludge)
8748
+ hadFocus.focus()
8749
+ if (hadFocus == div) { input.showPrimarySelection() }
8750
+ }, 50)
8751
+ }
8752
+ on(div, "copy", onCopyCut)
8753
+ on(div, "cut", onCopyCut)
8754
+ };
8755
+
8756
+ ContentEditableInput.prototype.prepareSelection = function () {
8757
+ var result = prepareSelection(this.cm, false)
8758
+ result.focus = this.cm.state.focused
8759
+ return result
8760
+ };
8761
+
8762
+ ContentEditableInput.prototype.showSelection = function (info, takeFocus) {
8763
+ if (!info || !this.cm.display.view.length) { return }
8764
+ if (info.focus || takeFocus) { this.showPrimarySelection() }
8765
+ this.showMultipleSelections(info)
8766
+ };
8767
+
8768
+ ContentEditableInput.prototype.getSelection = function () {
8769
+ return this.cm.display.wrapper.ownerDocument.getSelection()
8770
+ };
8771
+
8772
+ ContentEditableInput.prototype.showPrimarySelection = function () {
8773
+ var sel = this.getSelection(), cm = this.cm, prim = cm.doc.sel.primary()
8774
+ var from = prim.from(), to = prim.to()
8775
+
8776
+ if (cm.display.viewTo == cm.display.viewFrom || from.line >= cm.display.viewTo || to.line < cm.display.viewFrom) {
8777
+ sel.removeAllRanges()
8778
+ return
8779
+ }
8780
+
8781
+ var curAnchor = domToPos(cm, sel.anchorNode, sel.anchorOffset)
8782
+ var curFocus = domToPos(cm, sel.focusNode, sel.focusOffset)
8783
+ if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&
8784
+ cmp(minPos(curAnchor, curFocus), from) == 0 &&
8785
+ cmp(maxPos(curAnchor, curFocus), to) == 0)
8786
+ { return }
8787
+
8788
+ var view = cm.display.view
8789
+ var start = (from.line >= cm.display.viewFrom && posToDOM(cm, from)) ||
8790
+ {node: view[0].measure.map[2], offset: 0}
8791
+ var end = to.line < cm.display.viewTo && posToDOM(cm, to)
8792
+ if (!end) {
8793
+ var measure = view[view.length - 1].measure
8794
+ var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map
8795
+ end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]}
8796
+ }
8797
+
8798
+ if (!start || !end) {
8799
+ sel.removeAllRanges()
8800
+ return
8801
+ }
8802
+
8803
+ var old = sel.rangeCount && sel.getRangeAt(0), rng
8804
+ try { rng = range(start.node, start.offset, end.offset, end.node) }
8805
+ catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible
8806
+ if (rng) {
8807
+ if (!gecko && cm.state.focused) {
8808
+ sel.collapse(start.node, start.offset)
8809
+ if (!rng.collapsed) {
8810
+ sel.removeAllRanges()
8811
+ sel.addRange(rng)
8812
+ }
8813
+ } else {
8814
+ sel.removeAllRanges()
8815
+ sel.addRange(rng)
8816
+ }
8817
+ if (old && sel.anchorNode == null) { sel.addRange(old) }
8818
+ else if (gecko) { this.startGracePeriod() }
8819
+ }
8820
+ this.rememberSelection()
8821
+ };
8822
+
8823
+ ContentEditableInput.prototype.startGracePeriod = function () {
8824
+ var this$1 = this;
8825
+
8826
+ clearTimeout(this.gracePeriod)
8827
+ this.gracePeriod = setTimeout(function () {
8828
+ this$1.gracePeriod = false
8829
+ if (this$1.selectionChanged())
8830
+ { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }) }
8831
+ }, 20)
8832
+ };
8833
+
8834
+ ContentEditableInput.prototype.showMultipleSelections = function (info) {
8835
+ removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors)
8836
+ removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection)
8837
+ };
8838
+
8839
+ ContentEditableInput.prototype.rememberSelection = function () {
8840
+ var sel = this.getSelection()
8841
+ this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset
8842
+ this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset
8843
+ };
8844
+
8845
+ ContentEditableInput.prototype.selectionInEditor = function () {
8846
+ var sel = this.getSelection()
8847
+ if (!sel.rangeCount) { return false }
8848
+ var node = sel.getRangeAt(0).commonAncestorContainer
8849
+ return contains(this.div, node)
8850
+ };
8851
+
8852
+ ContentEditableInput.prototype.focus = function () {
8853
+ if (this.cm.options.readOnly != "nocursor") {
8854
+ if (!this.selectionInEditor())
8855
+ { this.showSelection(this.prepareSelection(), true) }
8856
+ this.div.focus()
8857
+ }
8858
+ };
8859
+ ContentEditableInput.prototype.blur = function () { this.div.blur() };
8860
+ ContentEditableInput.prototype.getField = function () { return this.div };
8861
+
8862
+ ContentEditableInput.prototype.supportsTouch = function () { return true };
8863
+
8864
+ ContentEditableInput.prototype.receivedFocus = function () {
8865
+ var input = this
8866
+ if (this.selectionInEditor())
8867
+ { this.pollSelection() }
8868
+ else
8869
+ { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }) }
8870
+
8871
+ function poll() {
8872
+ if (input.cm.state.focused) {
8873
+ input.pollSelection()
8874
+ input.polling.set(input.cm.options.pollInterval, poll)
8875
+ }
8876
+ }
8877
+ this.polling.set(this.cm.options.pollInterval, poll)
8878
+ };
8879
+
8880
+ ContentEditableInput.prototype.selectionChanged = function () {
8881
+ var sel = this.getSelection()
8882
+ return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
8883
+ sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset
8884
+ };
8885
+
8886
+ ContentEditableInput.prototype.pollSelection = function () {
8887
+ if (this.readDOMTimeout != null || this.gracePeriod || !this.selectionChanged()) { return }
8888
+ var sel = this.getSelection(), cm = this.cm
8889
+ // On Android Chrome (version 56, at least), backspacing into an
8890
+ // uneditable block element will put the cursor in that element,
8891
+ // and then, because it's not editable, hide the virtual keyboard.
8892
+ // Because Android doesn't allow us to actually detect backspace
8893
+ // presses in a sane way, this code checks for when that happens
8894
+ // and simulates a backspace press in this case.
8895
+ if (android && chrome && this.cm.options.gutters.length && isInGutter(sel.anchorNode)) {
8896
+ this.cm.triggerOnKeyDown({type: "keydown", keyCode: 8, preventDefault: Math.abs})
8897
+ this.blur()
8898
+ this.focus()
8899
+ return
8900
+ }
8901
+ if (this.composing) { return }
8902
+ this.rememberSelection()
8903
+ var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset)
8904
+ var head = domToPos(cm, sel.focusNode, sel.focusOffset)
8905
+ if (anchor && head) { runInOp(cm, function () {
8906
+ setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll)
8907
+ if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true }
8908
+ }) }
8909
+ };
8910
+
8911
+ ContentEditableInput.prototype.pollContent = function () {
8912
+ if (this.readDOMTimeout != null) {
8913
+ clearTimeout(this.readDOMTimeout)
8914
+ this.readDOMTimeout = null
8915
+ }
8916
+
8917
+ var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary()
8918
+ var from = sel.from(), to = sel.to()
8919
+ if (from.ch == 0 && from.line > cm.firstLine())
8920
+ { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length) }
8921
+ if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine())
8922
+ { to = Pos(to.line + 1, 0) }
8923
+ if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false }
8924
+
8925
+ var fromIndex, fromLine, fromNode
8926
+ if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {
8927
+ fromLine = lineNo(display.view[0].line)
8928
+ fromNode = display.view[0].node
8929
+ } else {
8930
+ fromLine = lineNo(display.view[fromIndex].line)
8931
+ fromNode = display.view[fromIndex - 1].node.nextSibling
8932
+ }
8933
+ var toIndex = findViewIndex(cm, to.line)
8934
+ var toLine, toNode
8935
+ if (toIndex == display.view.length - 1) {
8936
+ toLine = display.viewTo - 1
8937
+ toNode = display.lineDiv.lastChild
8938
+ } else {
8939
+ toLine = lineNo(display.view[toIndex + 1].line) - 1
8940
+ toNode = display.view[toIndex + 1].node.previousSibling
8941
+ }
8942
+
8943
+ if (!fromNode) { return false }
8944
+ var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine))
8945
+ var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length))
8946
+ while (newText.length > 1 && oldText.length > 1) {
8947
+ if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine-- }
8948
+ else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++ }
8949
+ else { break }
8950
+ }
8951
+
8952
+ var cutFront = 0, cutEnd = 0
8953
+ var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length)
8954
+ while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))
8955
+ { ++cutFront }
8956
+ var newBot = lst(newText), oldBot = lst(oldText)
8957
+ var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),
8958
+ oldBot.length - (oldText.length == 1 ? cutFront : 0))
8959
+ while (cutEnd < maxCutEnd &&
8960
+ newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))
8961
+ { ++cutEnd }
8962
+ // Try to move start of change to start of selection if ambiguous
8963
+ if (newText.length == 1 && oldText.length == 1 && fromLine == from.line) {
8964
+ while (cutFront && cutFront > from.ch &&
8965
+ newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) {
8966
+ cutFront--
8967
+ cutEnd++
8968
+ }
8969
+ }
8970
+
8971
+ newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\u200b+/, "")
8972
+ newText[0] = newText[0].slice(cutFront).replace(/\u200b+$/, "")
8973
+
8974
+ var chFrom = Pos(fromLine, cutFront)
8975
+ var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0)
8976
+ if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
8977
+ replaceRange(cm.doc, newText, chFrom, chTo, "+input")
8978
+ return true
8979
+ }
8980
+ };
8981
+
8982
+ ContentEditableInput.prototype.ensurePolled = function () {
8983
+ this.forceCompositionEnd()
8984
+ };
8985
+ ContentEditableInput.prototype.reset = function () {
8986
+ this.forceCompositionEnd()
8987
+ };
8988
+ ContentEditableInput.prototype.forceCompositionEnd = function () {
8989
+ if (!this.composing) { return }
8990
+ clearTimeout(this.readDOMTimeout)
8991
+ this.composing = null
8992
+ this.updateFromDOM()
8993
+ this.div.blur()
8994
+ this.div.focus()
8995
+ };
8996
+ ContentEditableInput.prototype.readFromDOMSoon = function () {
8997
+ var this$1 = this;
8998
+
8999
+ if (this.readDOMTimeout != null) { return }
9000
+ this.readDOMTimeout = setTimeout(function () {
9001
+ this$1.readDOMTimeout = null
9002
+ if (this$1.composing) {
9003
+ if (this$1.composing.done) { this$1.composing = null }
9004
+ else { return }
9005
+ }
9006
+ this$1.updateFromDOM()
9007
+ }, 80)
9008
+ };
9009
+
9010
+ ContentEditableInput.prototype.updateFromDOM = function () {
9011
+ var this$1 = this;
9012
+
9013
+ if (this.cm.isReadOnly() || !this.pollContent())
9014
+ { runInOp(this.cm, function () { return regChange(this$1.cm); }) }
9015
+ };
9016
+
9017
+ ContentEditableInput.prototype.setUneditable = function (node) {
9018
+ node.contentEditable = "false"
9019
+ };
9020
+
9021
+ ContentEditableInput.prototype.onKeyPress = function (e) {
9022
+ if (e.charCode == 0 || this.composing) { return }
9023
+ e.preventDefault()
9024
+ if (!this.cm.isReadOnly())
9025
+ { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0) }
9026
+ };
9027
+
9028
+ ContentEditableInput.prototype.readOnlyChanged = function (val) {
9029
+ this.div.contentEditable = String(val != "nocursor")
9030
+ };
9031
+
9032
+ ContentEditableInput.prototype.onContextMenu = function () {};
9033
+ ContentEditableInput.prototype.resetPosition = function () {};
9034
+
9035
+ ContentEditableInput.prototype.needsContentAttribute = true
9036
+
9037
+ function posToDOM(cm, pos) {
9038
+ var view = findViewForLine(cm, pos.line)
9039
+ if (!view || view.hidden) { return null }
9040
+ var line = getLine(cm.doc, pos.line)
9041
+ var info = mapFromLineView(view, line, pos.line)
9042
+
9043
+ var order = getOrder(line, cm.doc.direction), side = "left"
9044
+ if (order) {
9045
+ var partPos = getBidiPartAt(order, pos.ch)
9046
+ side = partPos % 2 ? "right" : "left"
9047
+ }
9048
+ var result = nodeAndOffsetInLineMap(info.map, pos.ch, side)
9049
+ result.offset = result.collapse == "right" ? result.end : result.start
9050
+ return result
9051
+ }
9052
+
9053
+ function isInGutter(node) {
9054
+ for (var scan = node; scan; scan = scan.parentNode)
9055
+ { if (/CodeMirror-gutter-wrapper/.test(scan.className)) { return true } }
9056
+ return false
9057
+ }
9058
+
9059
+ function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }
9060
+
9061
+ function domTextBetween(cm, from, to, fromLine, toLine) {
9062
+ var text = "", closing = false, lineSep = cm.doc.lineSeparator(), extraLinebreak = false
9063
+ function recognizeMarker(id) { return function (marker) { return marker.id == id; } }
9064
+ function close() {
9065
+ if (closing) {
9066
+ text += lineSep
9067
+ if (extraLinebreak) { text += lineSep }
9068
+ closing = extraLinebreak = false
9069
+ }
9070
+ }
9071
+ function addText(str) {
9072
+ if (str) {
9073
+ close()
9074
+ text += str
9075
+ }
9076
+ }
9077
+ function walk(node) {
9078
+ if (node.nodeType == 1) {
9079
+ var cmText = node.getAttribute("cm-text")
9080
+ if (cmText) {
9081
+ addText(cmText)
9082
+ return
9083
+ }
9084
+ var markerID = node.getAttribute("cm-marker"), range
9085
+ if (markerID) {
9086
+ var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID))
9087
+ if (found.length && (range = found[0].find(0)))
9088
+ { addText(getBetween(cm.doc, range.from, range.to).join(lineSep)) }
9089
+ return
9090
+ }
9091
+ if (node.getAttribute("contenteditable") == "false") { return }
9092
+ var isBlock = /^(pre|div|p|li|table|br)$/i.test(node.nodeName)
9093
+ if (!/^br$/i.test(node.nodeName) && node.textContent.length == 0) { return }
9094
+
9095
+ if (isBlock) { close() }
9096
+ for (var i = 0; i < node.childNodes.length; i++)
9097
+ { walk(node.childNodes[i]) }
9098
+
9099
+ if (/^(pre|p)$/i.test(node.nodeName)) { extraLinebreak = true }
9100
+ if (isBlock) { closing = true }
9101
+ } else if (node.nodeType == 3) {
9102
+ addText(node.nodeValue.replace(/\u200b/g, "").replace(/\u00a0/g, " "))
9103
+ }
9104
+ }
9105
+ for (;;) {
9106
+ walk(from)
9107
+ if (from == to) { break }
9108
+ from = from.nextSibling
9109
+ extraLinebreak = false
9110
+ }
9111
+ return text
9112
+ }
9113
+
9114
+ function domToPos(cm, node, offset) {
9115
+ var lineNode
9116
+ if (node == cm.display.lineDiv) {
9117
+ lineNode = cm.display.lineDiv.childNodes[offset]
9118
+ if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) }
9119
+ node = null; offset = 0
9120
+ } else {
9121
+ for (lineNode = node;; lineNode = lineNode.parentNode) {
9122
+ if (!lineNode || lineNode == cm.display.lineDiv) { return null }
9123
+ if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break }
9124
+ }
9125
+ }
9126
+ for (var i = 0; i < cm.display.view.length; i++) {
9127
+ var lineView = cm.display.view[i]
9128
+ if (lineView.node == lineNode)
9129
+ { return locateNodeInLineView(lineView, node, offset) }
9130
+ }
9131
+ }
9132
+
9133
+ function locateNodeInLineView(lineView, node, offset) {
9134
+ var wrapper = lineView.text.firstChild, bad = false
9135
+ if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) }
9136
+ if (node == wrapper) {
9137
+ bad = true
9138
+ node = wrapper.childNodes[offset]
9139
+ offset = 0
9140
+ if (!node) {
9141
+ var line = lineView.rest ? lst(lineView.rest) : lineView.line
9142
+ return badPos(Pos(lineNo(line), line.text.length), bad)
9143
+ }
9144
+ }
9145
+
9146
+ var textNode = node.nodeType == 3 ? node : null, topNode = node
9147
+ if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {
9148
+ textNode = node.firstChild
9149
+ if (offset) { offset = textNode.nodeValue.length }
9150
+ }
9151
+ while (topNode.parentNode != wrapper) { topNode = topNode.parentNode }
9152
+ var measure = lineView.measure, maps = measure.maps
9153
+
9154
+ function find(textNode, topNode, offset) {
9155
+ for (var i = -1; i < (maps ? maps.length : 0); i++) {
9156
+ var map = i < 0 ? measure.map : maps[i]
9157
+ for (var j = 0; j < map.length; j += 3) {
9158
+ var curNode = map[j + 2]
9159
+ if (curNode == textNode || curNode == topNode) {
9160
+ var line = lineNo(i < 0 ? lineView.line : lineView.rest[i])
9161
+ var ch = map[j] + offset
9162
+ if (offset < 0 || curNode != textNode) { ch = map[j + (offset ? 1 : 0)] }
9163
+ return Pos(line, ch)
9164
+ }
9165
+ }
9166
+ }
9167
+ }
9168
+ var found = find(textNode, topNode, offset)
9169
+ if (found) { return badPos(found, bad) }
9170
+
9171
+ // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems
9172
+ for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {
9173
+ found = find(after, after.firstChild, 0)
9174
+ if (found)
9175
+ { return badPos(Pos(found.line, found.ch - dist), bad) }
9176
+ else
9177
+ { dist += after.textContent.length }
9178
+ }
9179
+ for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {
9180
+ found = find(before, before.firstChild, -1)
9181
+ if (found)
9182
+ { return badPos(Pos(found.line, found.ch + dist$1), bad) }
9183
+ else
9184
+ { dist$1 += before.textContent.length }
9185
+ }
9186
+ }
9187
+
9188
+ // TEXTAREA INPUT STYLE
9189
+
9190
+ var TextareaInput = function(cm) {
9191
+ this.cm = cm
9192
+ // See input.poll and input.reset
9193
+ this.prevInput = ""
9194
+
9195
+ // Flag that indicates whether we expect input to appear real soon
9196
+ // now (after some event like 'keypress' or 'input') and are
9197
+ // polling intensively.
9198
+ this.pollingFast = false
9199
+ // Self-resetting timeout for the poller
9200
+ this.polling = new Delayed()
9201
+ // Used to work around IE issue with selection being forgotten when focus moves away from textarea
9202
+ this.hasSelection = false
9203
+ this.composing = null
9204
+ };
9205
+
9206
+ TextareaInput.prototype.init = function (display) {
9207
+ var this$1 = this;
9208
+
9209
+ var input = this, cm = this.cm
9210
+ this.createField(display)
9211
+ var te = this.textarea
9212
+
9213
+ display.wrapper.insertBefore(this.wrapper, display.wrapper.firstChild)
9214
+
9215
+ // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
9216
+ if (ios) { te.style.width = "0px" }
9217
+
9218
+ on(te, "input", function () {
9219
+ if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null }
9220
+ input.poll()
9221
+ })
9222
+
9223
+ on(te, "paste", function (e) {
9224
+ if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }
9225
+
9226
+ cm.state.pasteIncoming = true
9227
+ input.fastPoll()
9228
+ })
9229
+
9230
+ function prepareCopyCut(e) {
9231
+ if (signalDOMEvent(cm, e)) { return }
9232
+ if (cm.somethingSelected()) {
9233
+ setLastCopied({lineWise: false, text: cm.getSelections()})
9234
+ } else if (!cm.options.lineWiseCopyCut) {
9235
+ return
9236
+ } else {
9237
+ var ranges = copyableRanges(cm)
9238
+ setLastCopied({lineWise: true, text: ranges.text})
9239
+ if (e.type == "cut") {
9240
+ cm.setSelections(ranges.ranges, null, sel_dontScroll)
9241
+ } else {
9242
+ input.prevInput = ""
9243
+ te.value = ranges.text.join("\n")
9244
+ selectInput(te)
9245
+ }
9246
+ }
9247
+ if (e.type == "cut") { cm.state.cutIncoming = true }
9248
+ }
9249
+ on(te, "cut", prepareCopyCut)
9250
+ on(te, "copy", prepareCopyCut)
9251
+
9252
+ on(display.scroller, "paste", function (e) {
9253
+ if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return }
9254
+ cm.state.pasteIncoming = true
9255
+ input.focus()
9256
+ })
9257
+
9258
+ // Prevent normal selection in the editor (we handle our own)
9259
+ on(display.lineSpace, "selectstart", function (e) {
9260
+ if (!eventInWidget(display, e)) { e_preventDefault(e) }
9261
+ })
9262
+
9263
+ on(te, "compositionstart", function () {
9264
+ var start = cm.getCursor("from")
9265
+ if (input.composing) { input.composing.range.clear() }
9266
+ input.composing = {
9267
+ start: start,
9268
+ range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"})
9269
+ }
9270
+ })
9271
+ on(te, "compositionend", function () {
9272
+ if (input.composing) {
9273
+ input.poll()
9274
+ input.composing.range.clear()
9275
+ input.composing = null
9276
+ }
9277
+ })
9278
+ };
9279
+
9280
+ TextareaInput.prototype.createField = function (_display) {
9281
+ // Wraps and hides input textarea
9282
+ this.wrapper = hiddenTextarea()
9283
+ // The semihidden textarea that is focused when the editor is
9284
+ // focused, and receives input.
9285
+ this.textarea = this.wrapper.firstChild
9286
+ };
9287
+
9288
+ TextareaInput.prototype.prepareSelection = function () {
9289
+ // Redraw the selection and/or cursor
9290
+ var cm = this.cm, display = cm.display, doc = cm.doc
9291
+ var result = prepareSelection(cm)
9292
+
9293
+ // Move the hidden textarea near the cursor to prevent scrolling artifacts
9294
+ if (cm.options.moveInputWithCursor) {
9295
+ var headPos = cursorCoords(cm, doc.sel.primary().head, "div")
9296
+ var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect()
9297
+ result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
9298
+ headPos.top + lineOff.top - wrapOff.top))
9299
+ result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
9300
+ headPos.left + lineOff.left - wrapOff.left))
9301
+ }
9302
+
9303
+ return result
9304
+ };
9305
+
9306
+ TextareaInput.prototype.showSelection = function (drawn) {
9307
+ var cm = this.cm, display = cm.display
9308
+ removeChildrenAndAdd(display.cursorDiv, drawn.cursors)
9309
+ removeChildrenAndAdd(display.selectionDiv, drawn.selection)
9310
+ if (drawn.teTop != null) {
9311
+ this.wrapper.style.top = drawn.teTop + "px"
9312
+ this.wrapper.style.left = drawn.teLeft + "px"
9313
+ }
9314
+ };
9315
+
9316
+ // Reset the input to correspond to the selection (or to be empty,
9317
+ // when not typing and nothing is selected)
9318
+ TextareaInput.prototype.reset = function (typing) {
9319
+ if (this.contextMenuPending || this.composing) { return }
9320
+ var cm = this.cm
9321
+ if (cm.somethingSelected()) {
9322
+ this.prevInput = ""
9323
+ var content = cm.getSelection()
9324
+ this.textarea.value = content
9325
+ if (cm.state.focused) { selectInput(this.textarea) }
9326
+ if (ie && ie_version >= 9) { this.hasSelection = content }
9327
+ } else if (!typing) {
9328
+ this.prevInput = this.textarea.value = ""
9329
+ if (ie && ie_version >= 9) { this.hasSelection = null }
9330
+ }
9331
+ };
9332
+
9333
+ TextareaInput.prototype.getField = function () { return this.textarea };
9334
+
9335
+ TextareaInput.prototype.supportsTouch = function () { return false };
9336
+
9337
+ TextareaInput.prototype.focus = function () {
9338
+ if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) {
9339
+ try { this.textarea.focus() }
9340
+ catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
9341
+ }
9342
+ };
9343
+
9344
+ TextareaInput.prototype.blur = function () { this.textarea.blur() };
9345
+
9346
+ TextareaInput.prototype.resetPosition = function () {
9347
+ this.wrapper.style.top = this.wrapper.style.left = 0
9348
+ };
9349
+
9350
+ TextareaInput.prototype.receivedFocus = function () { this.slowPoll() };
9351
+
9352
+ // Poll for input changes, using the normal rate of polling. This
9353
+ // runs as long as the editor is focused.
9354
+ TextareaInput.prototype.slowPoll = function () {
9355
+ var this$1 = this;
9356
+
9357
+ if (this.pollingFast) { return }
9358
+ this.polling.set(this.cm.options.pollInterval, function () {
9359
+ this$1.poll()
9360
+ if (this$1.cm.state.focused) { this$1.slowPoll() }
9361
+ })
9362
+ };
9363
+
9364
+ // When an event has just come in that is likely to add or change
9365
+ // something in the input textarea, we poll faster, to ensure that
9366
+ // the change appears on the screen quickly.
9367
+ TextareaInput.prototype.fastPoll = function () {
9368
+ var missed = false, input = this
9369
+ input.pollingFast = true
9370
+ function p() {
9371
+ var changed = input.poll()
9372
+ if (!changed && !missed) {missed = true; input.polling.set(60, p)}
9373
+ else {input.pollingFast = false; input.slowPoll()}
9374
+ }
9375
+ input.polling.set(20, p)
9376
+ };
9377
+
9378
+ // Read input from the textarea, and update the document to match.
9379
+ // When something is selected, it is present in the textarea, and
9380
+ // selected (unless it is huge, in which case a placeholder is
9381
+ // used). When nothing is selected, the cursor sits after previously
9382
+ // seen text (can be empty), which is stored in prevInput (we must
9383
+ // not reset the textarea when typing, because that breaks IME).
9384
+ TextareaInput.prototype.poll = function () {
9385
+ var this$1 = this;
9386
+
9387
+ var cm = this.cm, input = this.textarea, prevInput = this.prevInput
9388
+ // Since this is called a *lot*, try to bail out as cheaply as
9389
+ // possible when it is clear that nothing happened. hasSelection
9390
+ // will be the case when there is a lot of text in the textarea,
9391
+ // in which case reading its value would be expensive.
9392
+ if (this.contextMenuPending || !cm.state.focused ||
9393
+ (hasSelection(input) && !prevInput && !this.composing) ||
9394
+ cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)
9395
+ { return false }
9396
+
9397
+ var text = input.value
9398
+ // If nothing changed, bail.
9399
+ if (text == prevInput && !cm.somethingSelected()) { return false }
9400
+ // Work around nonsensical selection resetting in IE9/10, and
9401
+ // inexplicable appearance of private area unicode characters on
9402
+ // some key combos in Mac (#2689).
9403
+ if (ie && ie_version >= 9 && this.hasSelection === text ||
9404
+ mac && /[\uf700-\uf7ff]/.test(text)) {
9405
+ cm.display.input.reset()
9406
+ return false
9407
+ }
9408
+
9409
+ if (cm.doc.sel == cm.display.selForContextMenu) {
9410
+ var first = text.charCodeAt(0)
9411
+ if (first == 0x200b && !prevInput) { prevInput = "\u200b" }
9412
+ if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo") }
9413
+ }
9414
+ // Find the part of the input that is actually new
9415
+ var same = 0, l = Math.min(prevInput.length, text.length)
9416
+ while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same }
9417
+
9418
+ runInOp(cm, function () {
9419
+ applyTextInput(cm, text.slice(same), prevInput.length - same,
9420
+ null, this$1.composing ? "*compose" : null)
9421
+
9422
+ // Don't leave long text in the textarea, since it makes further polling slow
9423
+ if (text.length > 1000 || text.indexOf("\n") > -1) { input.value = this$1.prevInput = "" }
9424
+ else { this$1.prevInput = text }
9425
+
9426
+ if (this$1.composing) {
9427
+ this$1.composing.range.clear()
9428
+ this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor("to"),
9429
+ {className: "CodeMirror-composing"})
9430
+ }
9431
+ })
9432
+ return true
9433
+ };
9434
+
9435
+ TextareaInput.prototype.ensurePolled = function () {
9436
+ if (this.pollingFast && this.poll()) { this.pollingFast = false }
9437
+ };
9438
+
9439
+ TextareaInput.prototype.onKeyPress = function () {
9440
+ if (ie && ie_version >= 9) { this.hasSelection = null }
9441
+ this.fastPoll()
9442
+ };
9443
+
9444
+ TextareaInput.prototype.onContextMenu = function (e) {
9445
+ var input = this, cm = input.cm, display = cm.display, te = input.textarea
9446
+ var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop
9447
+ if (!pos || presto) { return } // Opera is difficult.
9448
+
9449
+ // Reset the current text selection only if the click is done outside of the selection
9450
+ // and 'resetSelectionOnContextMenu' option is true.
9451
+ var reset = cm.options.resetSelectionOnContextMenu
9452
+ if (reset && cm.doc.sel.contains(pos) == -1)
9453
+ { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll) }
9454
+
9455
+ var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText
9456
+ input.wrapper.style.cssText = "position: absolute"
9457
+ var wrapperBox = input.wrapper.getBoundingClientRect()
9458
+ te.style.cssText = "position: absolute; width: 30px; height: 30px;\n top: " + (e.clientY - wrapperBox.top - 5) + "px; left: " + (e.clientX - wrapperBox.left - 5) + "px;\n z-index: 1000; background: " + (ie ? "rgba(255, 255, 255, .05)" : "transparent") + ";\n outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);"
9459
+ var oldScrollY
9460
+ if (webkit) { oldScrollY = window.scrollY } // Work around Chrome issue (#2712)
9461
+ display.input.focus()
9462
+ if (webkit) { window.scrollTo(null, oldScrollY) }
9463
+ display.input.reset()
9464
+ // Adds "Select all" to context menu in FF
9465
+ if (!cm.somethingSelected()) { te.value = input.prevInput = " " }
9466
+ input.contextMenuPending = true
9467
+ display.selForContextMenu = cm.doc.sel
9468
+ clearTimeout(display.detectingSelectAll)
9469
+
9470
+ // Select-all will be greyed out if there's nothing to select, so
9471
+ // this adds a zero-width space so that we can later check whether
9472
+ // it got selected.
9473
+ function prepareSelectAllHack() {
9474
+ if (te.selectionStart != null) {
9475
+ var selected = cm.somethingSelected()
9476
+ var extval = "\u200b" + (selected ? te.value : "")
9477
+ te.value = "\u21da" // Used to catch context-menu undo
9478
+ te.value = extval
9479
+ input.prevInput = selected ? "" : "\u200b"
9480
+ te.selectionStart = 1; te.selectionEnd = extval.length
9481
+ // Re-set this, in case some other handler touched the
9482
+ // selection in the meantime.
9483
+ display.selForContextMenu = cm.doc.sel
9484
+ }
9485
+ }
9486
+ function rehide() {
9487
+ input.contextMenuPending = false
9488
+ input.wrapper.style.cssText = oldWrapperCSS
9489
+ te.style.cssText = oldCSS
9490
+ if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos) }
9491
+
9492
+ // Try to detect the user choosing select-all
9493
+ if (te.selectionStart != null) {
9494
+ if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack() }
9495
+ var i = 0, poll = function () {
9496
+ if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&
9497
+ te.selectionEnd > 0 && input.prevInput == "\u200b") {
9498
+ operation(cm, selectAll)(cm)
9499
+ } else if (i++ < 10) {
9500
+ display.detectingSelectAll = setTimeout(poll, 500)
9501
+ } else {
9502
+ display.selForContextMenu = null
9503
+ display.input.reset()
9504
+ }
9505
+ }
9506
+ display.detectingSelectAll = setTimeout(poll, 200)
9507
+ }
9508
+ }
9509
+
9510
+ if (ie && ie_version >= 9) { prepareSelectAllHack() }
9511
+ if (captureRightClick) {
9512
+ e_stop(e)
9513
+ var mouseup = function () {
9514
+ off(window, "mouseup", mouseup)
9515
+ setTimeout(rehide, 20)
9516
+ }
9517
+ on(window, "mouseup", mouseup)
9518
+ } else {
9519
+ setTimeout(rehide, 50)
9520
+ }
9521
+ };
9522
+
9523
+ TextareaInput.prototype.readOnlyChanged = function (val) {
9524
+ if (!val) { this.reset() }
9525
+ this.textarea.disabled = val == "nocursor"
9526
+ };
9527
+
9528
+ TextareaInput.prototype.setUneditable = function () {};
9529
+
9530
+ TextareaInput.prototype.needsContentAttribute = false
9531
+
9532
+ function fromTextArea(textarea, options) {
9533
+ options = options ? copyObj(options) : {}
9534
+ options.value = textarea.value
9535
+ if (!options.tabindex && textarea.tabIndex)
9536
+ { options.tabindex = textarea.tabIndex }
9537
+ if (!options.placeholder && textarea.placeholder)
9538
+ { options.placeholder = textarea.placeholder }
9539
+ // Set autofocus to true if this textarea is focused, or if it has
9540
+ // autofocus and no other element is focused.
9541
+ if (options.autofocus == null) {
9542
+ var hasFocus = activeElt()
9543
+ options.autofocus = hasFocus == textarea ||
9544
+ textarea.getAttribute("autofocus") != null && hasFocus == document.body
9545
+ }
9546
+
9547
+ function save() {textarea.value = cm.getValue()}
9548
+
9549
+ var realSubmit
9550
+ if (textarea.form) {
9551
+ on(textarea.form, "submit", save)
9552
+ // Deplorable hack to make the submit method do the right thing.
9553
+ if (!options.leaveSubmitMethodAlone) {
9554
+ var form = textarea.form
9555
+ realSubmit = form.submit
9556
+ try {
9557
+ var wrappedSubmit = form.submit = function () {
9558
+ save()
9559
+ form.submit = realSubmit
9560
+ form.submit()
9561
+ form.submit = wrappedSubmit
9562
+ }
9563
+ } catch(e) {}
9564
+ }
9565
+ }
9566
+
9567
+ options.finishInit = function (cm) {
9568
+ cm.save = save
9569
+ cm.getTextArea = function () { return textarea; }
9570
+ cm.toTextArea = function () {
9571
+ cm.toTextArea = isNaN // Prevent this from being ran twice
9572
+ save()
9573
+ textarea.parentNode.removeChild(cm.getWrapperElement())
9574
+ textarea.style.display = ""
9575
+ if (textarea.form) {
9576
+ off(textarea.form, "submit", save)
9577
+ if (typeof textarea.form.submit == "function")
9578
+ { textarea.form.submit = realSubmit }
9579
+ }
9580
+ }
9581
+ }
9582
+
9583
+ textarea.style.display = "none"
9584
+ var cm = CodeMirror(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); },
9585
+ options)
9586
+ return cm
9587
+ }
9588
+
9589
+ function addLegacyProps(CodeMirror) {
9590
+ CodeMirror.off = off
9591
+ CodeMirror.on = on
9592
+ CodeMirror.wheelEventPixels = wheelEventPixels
9593
+ CodeMirror.Doc = Doc
9594
+ CodeMirror.splitLines = splitLinesAuto
9595
+ CodeMirror.countColumn = countColumn
9596
+ CodeMirror.findColumn = findColumn
9597
+ CodeMirror.isWordChar = isWordCharBasic
9598
+ CodeMirror.Pass = Pass
9599
+ CodeMirror.signal = signal
9600
+ CodeMirror.Line = Line
9601
+ CodeMirror.changeEnd = changeEnd
9602
+ CodeMirror.scrollbarModel = scrollbarModel
9603
+ CodeMirror.Pos = Pos
9604
+ CodeMirror.cmpPos = cmp
9605
+ CodeMirror.modes = modes
9606
+ CodeMirror.mimeModes = mimeModes
9607
+ CodeMirror.resolveMode = resolveMode
9608
+ CodeMirror.getMode = getMode
9609
+ CodeMirror.modeExtensions = modeExtensions
9610
+ CodeMirror.extendMode = extendMode
9611
+ CodeMirror.copyState = copyState
9612
+ CodeMirror.startState = startState
9613
+ CodeMirror.innerMode = innerMode
9614
+ CodeMirror.commands = commands
9615
+ CodeMirror.keyMap = keyMap
9616
+ CodeMirror.keyName = keyName
9617
+ CodeMirror.isModifierKey = isModifierKey
9618
+ CodeMirror.lookupKey = lookupKey
9619
+ CodeMirror.normalizeKeyMap = normalizeKeyMap
9620
+ CodeMirror.StringStream = StringStream
9621
+ CodeMirror.SharedTextMarker = SharedTextMarker
9622
+ CodeMirror.TextMarker = TextMarker
9623
+ CodeMirror.LineWidget = LineWidget
9624
+ CodeMirror.e_preventDefault = e_preventDefault
9625
+ CodeMirror.e_stopPropagation = e_stopPropagation
9626
+ CodeMirror.e_stop = e_stop
9627
+ CodeMirror.addClass = addClass
9628
+ CodeMirror.contains = contains
9629
+ CodeMirror.rmClass = rmClass
9630
+ CodeMirror.keyNames = keyNames
9631
+ }
9632
+
9633
+ // EDITOR CONSTRUCTOR
9634
+
9635
+ defineOptions(CodeMirror)
9636
+
9637
+ addEditorMethods(CodeMirror)
9638
+
9639
+ // Set up methods on CodeMirror's prototype to redirect to the editor's document.
9640
+ var dontDelegate = "iter insert remove copy getEditor constructor".split(" ")
9641
+ for (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)
9642
+ { CodeMirror.prototype[prop] = (function(method) {
9643
+ return function() {return method.apply(this.doc, arguments)}
9644
+ })(Doc.prototype[prop]) } }
9645
+
9646
+ eventMixin(Doc)
9647
+
9648
+ // INPUT HANDLING
9649
+
9650
+ CodeMirror.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput}
9651
+
9652
+ // MODE DEFINITION AND QUERYING
9653
+
9654
+ // Extra arguments are stored as the mode's dependencies, which is
9655
+ // used by (legacy) mechanisms like loadmode.js to automatically
9656
+ // load a mode. (Preferred mechanism is the require/define calls.)
9657
+ CodeMirror.defineMode = function(name/*, mode, …*/) {
9658
+ if (!CodeMirror.defaults.mode && name != "null") { CodeMirror.defaults.mode = name }
9659
+ defineMode.apply(this, arguments)
9660
+ }
9661
+
9662
+ CodeMirror.defineMIME = defineMIME
9663
+
9664
+ // Minimal default mode.
9665
+ CodeMirror.defineMode("null", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); })
9666
+ CodeMirror.defineMIME("text/plain", "null")
9667
+
9668
+ // EXTENSIONS
9669
+
9670
+ CodeMirror.defineExtension = function (name, func) {
9671
+ CodeMirror.prototype[name] = func
9672
+ }
9673
+ CodeMirror.defineDocExtension = function (name, func) {
9674
+ Doc.prototype[name] = func
9675
+ }
9676
+
9677
+ CodeMirror.fromTextArea = fromTextArea
9678
+
9679
+ addLegacyProps(CodeMirror)
9680
+
9681
+ CodeMirror.version = "5.38.0"
9682
+
9683
+ return CodeMirror;
9684
+
9685
+ })));
inc/lib/codemirror/mode/{css.js → css/css.js} RENAMED
@@ -28,6 +28,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
28
  colorKeywords = parserConfig.colorKeywords || {},
29
  valueKeywords = parserConfig.valueKeywords || {},
30
  allowNested = parserConfig.allowNested,
 
31
  supportsAtComponent = parserConfig.supportsAtComponent === true;
32
 
33
  var type, override;
@@ -76,9 +77,9 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
76
  return ret("qualifier", "qualifier");
77
  } else if (/[:;{}\[\]\(\)]/.test(ch)) {
78
  return ret(null, ch);
79
- } else if ((ch == "u" && stream.match(/rl(-prefix)?\(/)) ||
80
- (ch == "d" && stream.match("omain(")) ||
81
- (ch == "r" && stream.match("egexp("))) {
82
  stream.backUp(1);
83
  state.tokenize = tokenParenthesized;
84
  return ret("property", "word");
@@ -161,16 +162,16 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
161
  return pushContext(state, stream, "block");
162
  } else if (type == "}" && state.context.prev) {
163
  return popContext(state);
164
- } else if (supportsAtComponent && /@component/.test(type)) {
165
  return pushContext(state, stream, "atComponentBlock");
166
- } else if (/^@(-moz-)?document$/.test(type)) {
167
  return pushContext(state, stream, "documentTypes");
168
- } else if (/^@(media|supports|(-moz-)?document|import)$/.test(type)) {
169
  return pushContext(state, stream, "atBlock");
170
- } else if (/^@(font-face|counter-style)/.test(type)) {
171
  state.stateArg = type;
172
  return "restricted_atBlock_before";
173
- } else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/.test(type)) {
174
  return "keyframes";
175
  } else if (type && type.charAt(0) == "@") {
176
  return pushContext(state, stream, "at");
@@ -253,6 +254,8 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
253
  };
254
 
255
  states.pseudo = function(type, stream, state) {
 
 
256
  if (type == "word") {
257
  override = "variable-3";
258
  return state.context.type;
@@ -380,7 +383,8 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
380
  style = style[0];
381
  }
382
  override = style;
383
- state.state = states[state.state](type, stream, state);
 
384
  return override;
385
  },
386
 
@@ -398,7 +402,6 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
398
  ch == "{" && (cx.type == "at" || cx.type == "atBlock")) {
399
  // Dedent relative to current context.
400
  indent = Math.max(0, cx.indent - indentUnit);
401
- cx = cx.prev;
402
  }
403
  }
404
  return indent;
@@ -407,6 +410,8 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
407
  electricChars: "}",
408
  blockCommentStart: "/*",
409
  blockCommentEnd: "*/",
 
 
410
  fold: "brace"
411
  };
412
  });
@@ -414,7 +419,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
414
  function keySet(array) {
415
  var keys = {};
416
  for (var i = 0; i < array.length; ++i) {
417
- keys[array[i]] = true;
418
  }
419
  return keys;
420
  }
@@ -468,7 +473,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
468
  "border-top-left-radius", "border-top-right-radius", "border-top-style",
469
  "border-top-width", "border-width", "bottom", "box-decoration-break",
470
  "box-shadow", "box-sizing", "break-after", "break-before", "break-inside",
471
- "caption-side", "clear", "clip", "color", "color-profile", "column-count",
472
  "column-fill", "column-gap", "column-rule", "column-rule-color",
473
  "column-rule-style", "column-rule-width", "column-span", "column-width",
474
  "columns", "content", "counter-increment", "counter-reset", "crop", "cue",
@@ -489,12 +494,12 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
489
  "grid-row-start", "grid-template", "grid-template-areas", "grid-template-columns",
490
  "grid-template-rows", "hanging-punctuation", "height", "hyphens",
491
  "icon", "image-orientation", "image-rendering", "image-resolution",
492
- "inline-box-align", "justify-content", "left", "letter-spacing",
493
  "line-break", "line-height", "line-stacking", "line-stacking-ruby",
494
  "line-stacking-shift", "line-stacking-strategy", "list-style",
495
  "list-style-image", "list-style-position", "list-style-type", "margin",
496
  "margin-bottom", "margin-left", "margin-right", "margin-top",
497
- "marker-offset", "marks", "marquee-direction", "marquee-loop",
498
  "marquee-play-count", "marquee-speed", "marquee-style", "max-height",
499
  "max-width", "min-height", "min-width", "move-to", "nav-down", "nav-index",
500
  "nav-left", "nav-right", "nav-up", "object-fit", "object-position",
@@ -504,7 +509,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
504
  "padding", "padding-bottom", "padding-left", "padding-right", "padding-top",
505
  "page", "page-break-after", "page-break-before", "page-break-inside",
506
  "page-policy", "pause", "pause-after", "pause-before", "perspective",
507
- "perspective-origin", "pitch", "pitch-range", "play-during", "position",
508
  "presentation-level", "punctuation-trim", "quotes", "region-break-after",
509
  "region-break-before", "region-break-inside", "region-fragment",
510
  "rendering-intent", "resize", "rest", "rest-after", "rest-before", "richness",
@@ -522,9 +527,9 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
522
  "text-wrap", "top", "transform", "transform-origin", "transform-style",
523
  "transition", "transition-delay", "transition-duration",
524
  "transition-property", "transition-timing-function", "unicode-bidi",
525
- "vertical-align", "visibility", "voice-balance", "voice-duration",
526
  "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress",
527
- "voice-volume", "volume", "white-space", "widows", "width", "word-break",
528
  "word-spacing", "word-wrap", "z-index",
529
  // SVG-specific
530
  "clip-path", "clip-rule", "mask", "enable-background", "filter", "flood-color",
@@ -589,7 +594,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
589
  "above", "absolute", "activeborder", "additive", "activecaption", "afar",
590
  "after-white-space", "ahead", "alias", "all", "all-scroll", "alphabetic", "alternate",
591
  "always", "amharic", "amharic-abegede", "antialiased", "appworkspace",
592
- "arabic-indic", "armenian", "asterisks", "attr", "auto", "avoid", "avoid-column", "avoid-page",
593
  "avoid-region", "background", "backwards", "baseline", "below", "bidi-override", "binary",
594
  "bengali", "blink", "block", "block-axis", "bold", "bolder", "border", "border-box",
595
  "both", "bottom", "break", "break-all", "break-word", "bullets", "button", "button-bevel",
@@ -598,7 +603,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
598
  "cell", "center", "checkbox", "circle", "cjk-decimal", "cjk-earthly-branch",
599
  "cjk-heavenly-stem", "cjk-ideographic", "clear", "clip", "close-quote",
600
  "col-resize", "collapse", "color", "color-burn", "color-dodge", "column", "column-reverse",
601
- "compact", "condensed", "contain", "content",
602
  "content-box", "context-menu", "continuous", "copy", "counter", "counters", "cover", "crop",
603
  "cross", "crosshair", "currentcolor", "cursive", "cyclic", "darken", "dashed", "decimal",
604
  "decimal-leading-zero", "default", "default-button", "dense", "destination-atop",
@@ -641,7 +646,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
641
  "mix", "mongolian", "monospace", "move", "multiple", "multiply", "myanmar", "n-resize",
642
  "narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop",
643
  "no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap",
644
- "ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "octal", "open-quote",
645
  "optimizeLegibility", "optimizeSpeed", "oriya", "oromo", "outset",
646
  "outside", "outside-shape", "overlay", "overline", "padding", "padding-box",
647
  "painted", "page", "paused", "persian", "perspective", "plus-darker", "plus-lighter",
@@ -653,17 +658,17 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
653
  "rgb", "rgba", "ridge", "right", "rotate", "rotate3d", "rotateX", "rotateY",
654
  "rotateZ", "round", "row", "row-resize", "row-reverse", "rtl", "run-in", "running",
655
  "s-resize", "sans-serif", "saturation", "scale", "scale3d", "scaleX", "scaleY", "scaleZ", "screen",
656
- "scroll", "scrollbar", "se-resize", "searchfield",
657
  "searchfield-cancel-button", "searchfield-decoration",
658
- "searchfield-results-button", "searchfield-results-decoration",
659
  "semi-condensed", "semi-expanded", "separate", "serif", "show", "sidama",
660
  "simp-chinese-formal", "simp-chinese-informal", "single",
661
  "skew", "skewX", "skewY", "skip-white-space", "slide", "slider-horizontal",
662
  "slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow",
663
  "small", "small-caps", "small-caption", "smaller", "soft-light", "solid", "somali",
664
- "source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "spell-out", "square",
665
  "square-button", "start", "static", "status-bar", "stretch", "stroke", "sub",
666
- "subpixel-antialiased", "super", "sw-resize", "symbolic", "symbols", "table",
667
  "table-caption", "table-cell", "table-column", "table-column-group",
668
  "table-footer-group", "table-header-group", "table-row", "table-row-group",
669
  "tamil",
@@ -671,9 +676,9 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
671
  "thick", "thin", "threeddarkshadow", "threedface", "threedhighlight",
672
  "threedlightshadow", "threedshadow", "tibetan", "tigre", "tigrinya-er",
673
  "tigrinya-er-abegede", "tigrinya-et", "tigrinya-et-abegede", "to", "top",
674
- "trad-chinese-formal", "trad-chinese-informal",
675
  "translate", "translate3d", "translateX", "translateY", "translateZ",
676
- "transparent", "ultra-condensed", "ultra-expanded", "underline", "up",
677
  "upper-alpha", "upper-armenian", "upper-greek", "upper-hexadecimal",
678
  "upper-latin", "upper-norwegian", "upper-roman", "uppercase", "urdu", "url",
679
  "var", "vertical", "vertical-text", "visible", "visibleFill", "visiblePainted",
@@ -730,6 +735,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
730
  valueKeywords: valueKeywords,
731
  fontProperties: fontProperties,
732
  allowNested: true,
 
733
  tokenHooks: {
734
  "/": function(stream, state) {
735
  if (stream.eat("/")) {
@@ -743,8 +749,8 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
743
  }
744
  },
745
  ":": function(stream) {
746
- if (stream.match(/\s*\{/))
747
- return [null, "{"];
748
  return false;
749
  },
750
  "$": function(stream) {
@@ -772,6 +778,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
772
  valueKeywords: valueKeywords,
773
  fontProperties: fontProperties,
774
  allowNested: true,
 
775
  tokenHooks: {
776
  "/": function(stream, state) {
777
  if (stream.eat("/")) {
@@ -786,7 +793,7 @@ CodeMirror.defineMode("css", function(config, parserConfig) {
786
  },
787
  "@": function(stream) {
788
  if (stream.eat("{")) return [null, "interpolation"];
789
- if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\b/, false)) return false;
790
  stream.eatWhile(/[\w\\\-]/);
791
  if (stream.match(/^\s*:/, false))
792
  return ["variable-2", "variable-definition"];
28
  colorKeywords = parserConfig.colorKeywords || {},
29
  valueKeywords = parserConfig.valueKeywords || {},
30
  allowNested = parserConfig.allowNested,
31
+ lineComment = parserConfig.lineComment,
32
  supportsAtComponent = parserConfig.supportsAtComponent === true;
33
 
34
  var type, override;
77
  return ret("qualifier", "qualifier");
78
  } else if (/[:;{}\[\]\(\)]/.test(ch)) {
79
  return ret(null, ch);
80
+ } else if (((ch == "u" || ch == "U") && stream.match(/rl(-prefix)?\(/i)) ||
81
+ ((ch == "d" || ch == "D") && stream.match("omain(", true, true)) ||
82
+ ((ch == "r" || ch == "R") && stream.match("egexp(", true, true))) {
83
  stream.backUp(1);
84
  state.tokenize = tokenParenthesized;
85
  return ret("property", "word");
162
  return pushContext(state, stream, "block");
163
  } else if (type == "}" && state.context.prev) {
164
  return popContext(state);
165
+ } else if (supportsAtComponent && /@component/i.test(type)) {
166
  return pushContext(state, stream, "atComponentBlock");
167
+ } else if (/^@(-moz-)?document$/i.test(type)) {
168
  return pushContext(state, stream, "documentTypes");
169
+ } else if (/^@(media|supports|(-moz-)?document|import)$/i.test(type)) {
170
  return pushContext(state, stream, "atBlock");
171
+ } else if (/^@(font-face|counter-style)/i.test(type)) {
172
  state.stateArg = type;
173
  return "restricted_atBlock_before";
174
+ } else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/i.test(type)) {
175
  return "keyframes";
176
  } else if (type && type.charAt(0) == "@") {
177
  return pushContext(state, stream, "at");
254
  };
255
 
256
  states.pseudo = function(type, stream, state) {
257
+ if (type == "meta") return "pseudo";
258
+
259
  if (type == "word") {
260
  override = "variable-3";
261
  return state.context.type;
383
  style = style[0];
384
  }
385
  override = style;
386
+ if (type != "comment")
387
+ state.state = states[state.state](type, stream, state);
388
  return override;
389
  },
390
 
402
  ch == "{" && (cx.type == "at" || cx.type == "atBlock")) {
403
  // Dedent relative to current context.
404
  indent = Math.max(0, cx.indent - indentUnit);
 
405
  }
406
  }
407
  return indent;
410
  electricChars: "}",
411
  blockCommentStart: "/*",
412
  blockCommentEnd: "*/",
413
+ blockCommentContinue: " * ",
414
+ lineComment: lineComment,
415
  fold: "brace"
416
  };
417
  });
419
  function keySet(array) {
420
  var keys = {};
421
  for (var i = 0; i < array.length; ++i) {
422
+ keys[array[i].toLowerCase()] = true;
423
  }
424
  return keys;
425
  }
473
  "border-top-left-radius", "border-top-right-radius", "border-top-style",
474
  "border-top-width", "border-width", "bottom", "box-decoration-break",
475
  "box-shadow", "box-sizing", "break-after", "break-before", "break-inside",
476
+ "caption-side", "caret-color", "clear", "clip", "color", "color-profile", "column-count",
477
  "column-fill", "column-gap", "column-rule", "column-rule-color",
478
  "column-rule-style", "column-rule-width", "column-span", "column-width",
479
  "columns", "content", "counter-increment", "counter-reset", "crop", "cue",
494
  "grid-row-start", "grid-template", "grid-template-areas", "grid-template-columns",
495
  "grid-template-rows", "hanging-punctuation", "height", "hyphens",
496
  "icon", "image-orientation", "image-rendering", "image-resolution",
497
+ "inline-box-align", "justify-content", "justify-items", "justify-self", "left", "letter-spacing",
498
  "line-break", "line-height", "line-stacking", "line-stacking-ruby",
499
  "line-stacking-shift", "line-stacking-strategy", "list-style",
500
  "list-style-image", "list-style-position", "list-style-type", "margin",
501
  "margin-bottom", "margin-left", "margin-right", "margin-top",
502
+ "marks", "marquee-direction", "marquee-loop",
503
  "marquee-play-count", "marquee-speed", "marquee-style", "max-height",
504
  "max-width", "min-height", "min-width", "move-to", "nav-down", "nav-index",
505
  "nav-left", "nav-right", "nav-up", "object-fit", "object-position",
509
  "padding", "padding-bottom", "padding-left", "padding-right", "padding-top",
510
  "page", "page-break-after", "page-break-before", "page-break-inside",
511
  "page-policy", "pause", "pause-after", "pause-before", "perspective",
512
+ "perspective-origin", "pitch", "pitch-range", "place-content", "place-items", "place-self", "play-during", "position",
513
  "presentation-level", "punctuation-trim", "quotes", "region-break-after",
514
  "region-break-before", "region-break-inside", "region-fragment",
515
  "rendering-intent", "resize", "rest", "rest-after", "rest-before", "richness",
527
  "text-wrap", "top", "transform", "transform-origin", "transform-style",
528
  "transition", "transition-delay", "transition-duration",
529
  "transition-property", "transition-timing-function", "unicode-bidi",
530
+ "user-select", "vertical-align", "visibility", "voice-balance", "voice-duration",
531
  "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress",
532
+ "voice-volume", "volume", "white-space", "widows", "width", "will-change", "word-break",
533
  "word-spacing", "word-wrap", "z-index",
534
  // SVG-specific
535
  "clip-path", "clip-rule", "mask", "enable-background", "filter", "flood-color",
594
  "above", "absolute", "activeborder", "additive", "activecaption", "afar",
595
  "after-white-space", "ahead", "alias", "all", "all-scroll", "alphabetic", "alternate",
596
  "always", "amharic", "amharic-abegede", "antialiased", "appworkspace",
597
+ "arabic-indic", "armenian", "asterisks", "attr", "auto", "auto-flow", "avoid", "avoid-column", "avoid-page",
598
  "avoid-region", "background", "backwards", "baseline", "below", "bidi-override", "binary",
599
  "bengali", "blink", "block", "block-axis", "bold", "bolder", "border", "border-box",
600
  "both", "bottom", "break", "break-all", "break-word", "bullets", "button", "button-bevel",
603
  "cell", "center", "checkbox", "circle", "cjk-decimal", "cjk-earthly-branch",
604
  "cjk-heavenly-stem", "cjk-ideographic", "clear", "clip", "close-quote",
605
  "col-resize", "collapse", "color", "color-burn", "color-dodge", "column", "column-reverse",
606
+ "compact", "condensed", "contain", "content", "contents",
607
  "content-box", "context-menu", "continuous", "copy", "counter", "counters", "cover", "crop",
608
  "cross", "crosshair", "currentcolor", "cursive", "cyclic", "darken", "dashed", "decimal",
609
  "decimal-leading-zero", "default", "default-button", "dense", "destination-atop",
646
  "mix", "mongolian", "monospace", "move", "multiple", "multiply", "myanmar", "n-resize",
647
  "narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop",
648
  "no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap",
649
+ "ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "octal", "opacity", "open-quote",
650
  "optimizeLegibility", "optimizeSpeed", "oriya", "oromo", "outset",
651
  "outside", "outside-shape", "overlay", "overline", "padding", "padding-box",
652
  "painted", "page", "paused", "persian", "perspective", "plus-darker", "plus-lighter",
658
  "rgb", "rgba", "ridge", "right", "rotate", "rotate3d", "rotateX", "rotateY",
659
  "rotateZ", "round", "row", "row-resize", "row-reverse", "rtl", "run-in", "running",
660
  "s-resize", "sans-serif", "saturation", "scale", "scale3d", "scaleX", "scaleY", "scaleZ", "screen",
661
+ "scroll", "scrollbar", "scroll-position", "se-resize", "searchfield",
662
  "searchfield-cancel-button", "searchfield-decoration",
663
+ "searchfield-results-button", "searchfield-results-decoration", "self-start", "self-end",
664
  "semi-condensed", "semi-expanded", "separate", "serif", "show", "sidama",
665
  "simp-chinese-formal", "simp-chinese-informal", "single",
666
  "skew", "skewX", "skewY", "skip-white-space", "slide", "slider-horizontal",
667
  "slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow",
668
  "small", "small-caps", "small-caption", "smaller", "soft-light", "solid", "somali",
669
+ "source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "space-evenly", "spell-out", "square",
670
  "square-button", "start", "static", "status-bar", "stretch", "stroke", "sub",
671
+ "subpixel-antialiased", "super", "sw-resize", "symbolic", "symbols", "system-ui", "table",
672
  "table-caption", "table-cell", "table-column", "table-column-group",
673
  "table-footer-group", "table-header-group", "table-row", "table-row-group",
674
  "tamil",
676
  "thick", "thin", "threeddarkshadow", "threedface", "threedhighlight",
677
  "threedlightshadow", "threedshadow", "tibetan", "tigre", "tigrinya-er",
678
  "tigrinya-er-abegede", "tigrinya-et", "tigrinya-et-abegede", "to", "top",
679
+ "trad-chinese-formal", "trad-chinese-informal", "transform",
680
  "translate", "translate3d", "translateX", "translateY", "translateZ",
681
+ "transparent", "ultra-condensed", "ultra-expanded", "underline", "unset", "up",
682
  "upper-alpha", "upper-armenian", "upper-greek", "upper-hexadecimal",
683
  "upper-latin", "upper-norwegian", "upper-roman", "uppercase", "urdu", "url",
684
  "var", "vertical", "vertical-text", "visible", "visibleFill", "visiblePainted",
735
  valueKeywords: valueKeywords,
736
  fontProperties: fontProperties,
737
  allowNested: true,
738
+ lineComment: "//",
739
  tokenHooks: {
740
  "/": function(stream, state) {
741
  if (stream.eat("/")) {
749
  }
750
  },
751
  ":": function(stream) {
752
+ if (stream.match(/\s*\{/, false))
753
+ return [null, null]
754
  return false;
755
  },
756
  "$": function(stream) {
778
  valueKeywords: valueKeywords,
779
  fontProperties: fontProperties,
780
  allowNested: true,
781
+ lineComment: "//",
782
  tokenHooks: {
783
  "/": function(stream, state) {
784
  if (stream.eat("/")) {
793
  },
794
  "@": function(stream) {
795
  if (stream.eat("{")) return [null, "interpolation"];
796
+ if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\b/i, false)) return false;
797
  stream.eatWhile(/[\w\\\-]/);
798
  if (stream.match(/^\s*:/, false))
799
  return ["variable-2", "variable-definition"];
inc/lib/codemirror/mode/css/gss.html ADDED
@@ -0,0 +1,103 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: Closure Stylesheets (GSS) mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <link rel="stylesheet" href="../../addon/hint/show-hint.css">
9
+ <script src="../../lib/codemirror.js"></script>
10
+ <script src="css.js"></script>
11
+ <script src="../../addon/hint/show-hint.js"></script>
12
+ <script src="../../addon/hint/css-hint.js"></script>
13
+ <style>.CodeMirror {background: #f8f8f8;}</style>
14
+ <div id=nav>
15
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
16
+
17
+ <ul>
18
+ <li><a href="../../index.html">Home</a>
19
+ <li><a href="../../doc/manual.html">Manual</a>
20
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
21
+ </ul>
22
+ <ul>
23
+ <li><a href="../index.html">Language modes</a>
24
+ <li><a class=active href="#">Closure Stylesheets (GSS)</a>
25
+ </ul>
26
+ </div>
27
+
28
+ <article>
29
+ <h2>Closure Stylesheets (GSS) mode</h2>
30
+ <form><textarea id="code" name="code">
31
+ /* Some example Closure Stylesheets */
32
+
33
+ @provide 'some.styles';
34
+
35
+ @require 'other.styles';
36
+
37
+ @component {
38
+
39
+ @def FONT_FAMILY "Times New Roman", Georgia, Serif;
40
+ @def FONT_SIZE_NORMAL 15px;
41
+ @def FONT_NORMAL normal FONT_SIZE_NORMAL FONT_FAMILY;
42
+
43
+ @def BG_COLOR rgb(235, 239, 249);
44
+
45
+ @def DIALOG_BORDER_COLOR rgb(107, 144, 218);
46
+ @def DIALOG_BG_COLOR BG_COLOR;
47
+
48
+ @def LEFT_HAND_NAV_WIDTH 180px;
49
+ @def LEFT_HAND_NAV_PADDING 3px;
50
+
51
+ @defmixin size(WIDTH, HEIGHT) {
52
+ width: WIDTH;
53
+ height: HEIGHT;
54
+ }
55
+
56
+ body {
57
+ background-color: BG_COLOR;
58
+ margin: 0;
59
+ padding: 3em 6em;
60
+ font: FONT_NORMAL;
61
+ color: #000;
62
+ }
63
+
64
+ #navigation a {
65
+ font-weight: bold;
66
+ text-decoration: none !important;
67
+ }
68
+
69
+ .dialog {
70
+ background-color: DIALOG_BG_COLOR;
71
+ border: 1px solid DIALOG_BORDER_COLOR;
72
+ }
73
+
74
+ .content {
75
+ position: absolute;
76
+ margin-left: add(LEFT_HAND_NAV_PADDING, /* padding left */
77
+ LEFT_HAND_NAV_WIDTH,
78
+ LEFT_HAND_NAV_PADDING); /* padding right */
79
+
80
+ }
81
+
82
+ .logo {
83
+ @mixin size(150px, 55px);
84
+ background-image: url('http://www.google.com/images/logo_sm.gif');
85
+ }
86
+
87
+ }
88
+ </textarea></form>
89
+ <script>
90
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
91
+ extraKeys: {"Ctrl-Space": "autocomplete"},
92
+ lineNumbers: true,
93
+ matchBrackets: "text/x-less",
94
+ mode: "text/x-gss"
95
+ });
96
+ </script>
97
+
98
+ <p>A mode for <a href="https://github.com/google/closure-stylesheets">Closure Stylesheets</a> (GSS).</p>
99
+ <p><strong>MIME type defined:</strong> <code>text/x-gss</code>.</p>
100
+
101
+ <p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#gss_*">normal</a>, <a href="../../test/index.html#verbose,gss_*">verbose</a>.</p>
102
+
103
+ </article>
inc/lib/codemirror/mode/css/gss_test.js ADDED
@@ -0,0 +1,17 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://codemirror.net/LICENSE
3
+
4
+ (function() {
5
+ "use strict";
6
+
7
+ var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-gss");
8
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), "gss"); }
9
+
10
+ MT("atComponent",
11
+ "[def @component] {",
12
+ "[tag foo] {",
13
+ " [property color]: [keyword black];",
14
+ "}",
15
+ "}");
16
+
17
+ })();
inc/lib/codemirror/mode/css/index.html ADDED
@@ -0,0 +1,75 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: CSS mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <link rel="stylesheet" href="../../addon/hint/show-hint.css">
9
+ <script src="../../lib/codemirror.js"></script>
10
+ <script src="css.js"></script>
11
+ <script src="../../addon/hint/show-hint.js"></script>
12
+ <script src="../../addon/hint/css-hint.js"></script>
13
+ <style>.CodeMirror {background: #f8f8f8;}</style>
14
+ <div id=nav>
15
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
16
+
17
+ <ul>
18
+ <li><a href="../../index.html">Home</a>
19
+ <li><a href="../../doc/manual.html">Manual</a>
20
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
21
+ </ul>
22
+ <ul>
23
+ <li><a href="../index.html">Language modes</a>
24
+ <li><a class=active href="#">CSS</a>
25
+ </ul>
26
+ </div>
27
+
28
+ <article>
29
+ <h2>CSS mode</h2>
30
+ <form><textarea id="code" name="code">
31
+ /* Some example CSS */
32
+
33
+ @import url("something.css");
34
+
35
+ body {
36
+ margin: 0;
37
+ padding: 3em 6em;
38
+ font-family: tahoma, arial, sans-serif;
39
+ color: #000;
40
+ }
41
+
42
+ #navigation a {
43
+ font-weight: bold;
44
+ text-decoration: none !important;
45
+ }
46
+
47
+ h1 {
48
+ font-size: 2.5em;
49
+ }
50
+
51
+ h2 {
52
+ font-size: 1.7em;
53
+ }
54
+
55
+ h1:before, h2:before {
56
+ content: "::";
57
+ }
58
+
59
+ code {
60
+ font-family: courier, monospace;
61
+ font-size: 80%;
62
+ color: #418A8A;
63
+ }
64
+ </textarea></form>
65
+ <script>
66
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
67
+ extraKeys: {"Ctrl-Space": "autocomplete"}
68
+ });
69
+ </script>
70
+
71
+ <p><strong>MIME types defined:</strong> <code>text/css</code>, <code>text/x-scss</code> (<a href="scss.html">demo</a>), <code>text/x-less</code> (<a href="less.html">demo</a>).</p>
72
+
73
+ <p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#css_*">normal</a>, <a href="../../test/index.html#verbose,css_*">verbose</a>.</p>
74
+
75
+ </article>
inc/lib/codemirror/mode/css/less.html ADDED
@@ -0,0 +1,152 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: LESS mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <script src="../../lib/codemirror.js"></script>
9
+ <script src="../../addon/edit/matchbrackets.js"></script>
10
+ <script src="css.js"></script>
11
+ <style>.CodeMirror {border: 1px solid #ddd; line-height: 1.2;}</style>
12
+ <div id=nav>
13
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
14
+
15
+ <ul>
16
+ <li><a href="../../index.html">Home</a>
17
+ <li><a href="../../doc/manual.html">Manual</a>
18
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
19
+ </ul>
20
+ <ul>
21
+ <li><a href="../index.html">Language modes</a>
22
+ <li><a class=active href="#">LESS</a>
23
+ </ul>
24
+ </div>
25
+
26
+ <article>
27
+ <h2>LESS mode</h2>
28
+ <form><textarea id="code" name="code">@media screen and (device-aspect-ratio: 16/9) { … }
29
+ @media screen and (device-aspect-ratio: 1280/720) { … }
30
+ @media screen and (device-aspect-ratio: 2560/1440) { … }
31
+
32
+ html:lang(fr-be)
33
+
34
+ tr:nth-child(2n+1) /* represents every odd row of an HTML table */
35
+
36
+ img:nth-of-type(2n+1) { float: right; }
37
+ img:nth-of-type(2n) { float: left; }
38
+
39
+ body > h2:not(:first-of-type):not(:last-of-type)
40
+
41
+ html|*:not(:link):not(:visited)
42
+ *|*:not(:hover)
43
+ p::first-line { text-transform: uppercase }
44
+
45
+ @namespace foo url(http://www.example.com);
46
+ foo|h1 { color: blue } /* first rule */
47
+
48
+ span[hello="Ocean"][goodbye="Land"]
49
+
50
+ E[foo]{
51
+ padding:65px;
52
+ }
53
+
54
+ input[type="search"]::-webkit-search-decoration,
55
+ input[type="search"]::-webkit-search-cancel-button {
56
+ -webkit-appearance: none; // Inner-padding issues in Chrome OSX, Safari 5
57
+ }
58
+ button::-moz-focus-inner,
59
+ input::-moz-focus-inner { // Inner padding and border oddities in FF3/4
60
+ padding: 0;
61
+ border: 0;
62
+ }
63
+ .btn {
64
+ // reset here as of 2.0.3 due to Recess property order
65
+ border-color: #ccc;
66
+ border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);
67
+ }
68
+ fieldset span button, fieldset span input[type="file"] {
69
+ font-size:12px;
70
+ font-family:Arial, Helvetica, sans-serif;
71
+ }
72
+
73
+ .rounded-corners (@radius: 5px) {
74
+ border-radius: @radius;
75
+ -webkit-border-radius: @radius;
76
+ -moz-border-radius: @radius;
77
+ }
78
+
79
+ @import url("something.css");
80
+
81
+ @light-blue: hsl(190, 50%, 65%);
82
+
83
+ #menu {
84
+ position: absolute;
85
+ width: 100%;
86
+ z-index: 3;
87
+ clear: both;
88
+ display: block;
89
+ background-color: @blue;
90
+ height: 42px;
91
+ border-top: 2px solid lighten(@alpha-blue, 20%);
92
+ border-bottom: 2px solid darken(@alpha-blue, 25%);
93
+ .box-shadow(0, 1px, 8px, 0.6);
94
+ -moz-box-shadow: 0 0 0 #000; // Because firefox sucks.
95
+
96
+ &.docked {
97
+ background-color: hsla(210, 60%, 40%, 0.4);
98
+ }
99
+ &:hover {
100
+ background-color: @blue;
101
+ }
102
+
103
+ #dropdown {
104
+ margin: 0 0 0 117px;
105
+ padding: 0;
106
+ padding-top: 5px;
107
+ display: none;
108
+ width: 190px;
109
+ border-top: 2px solid @medium;
110
+ color: @highlight;
111
+ border: 2px solid darken(@medium, 25%);
112
+ border-left-color: darken(@medium, 15%);
113
+ border-right-color: darken(@medium, 15%);
114
+ border-top-width: 0;
115
+ background-color: darken(@medium, 10%);
116
+ ul {
117
+ padding: 0px;
118
+ }
119
+ li {
120
+ font-size: 14px;
121
+ display: block;
122
+ text-align: left;
123
+ padding: 0;
124
+ border: 0;
125
+ a {
126
+ display: block;
127
+ padding: 0px 15px;
128
+ text-decoration: none;
129
+ color: white;
130
+ &:hover {
131
+ background-color: darken(@medium, 15%);
132
+ text-decoration: none;
133
+ }
134
+ }
135
+ }
136
+ .border-radius(5px, bottom);
137
+ .box-shadow(0, 6px, 8px, 0.5);
138
+ }
139
+ }
140
+ </textarea></form>
141
+ <script>
142
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
143
+ lineNumbers : true,
144
+ matchBrackets : true,
145
+ mode: "text/x-less"
146
+ });
147
+ </script>
148
+
149
+ <p>The LESS mode is a sub-mode of the <a href="index.html">CSS mode</a> (defined in <code>css.js</code>).</p>
150
+
151
+ <p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#less_*">normal</a>, <a href="../../test/index.html#verbose,less_*">verbose</a>.</p>
152
+ </article>
inc/lib/codemirror/mode/css/less_test.js ADDED
@@ -0,0 +1,54 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://codemirror.net/LICENSE
3
+
4
+ (function() {
5
+ "use strict";
6
+
7
+ var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-less");
8
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), "less"); }
9
+
10
+ MT("variable",
11
+ "[variable-2 @base]: [atom #f04615];",
12
+ "[qualifier .class] {",
13
+ " [property width]: [variable percentage]([number 0.5]); [comment // returns `50%`]",
14
+ " [property color]: [variable saturate]([variable-2 @base], [number 5%]);",
15
+ "}");
16
+
17
+ MT("amp",
18
+ "[qualifier .child], [qualifier .sibling] {",
19
+ " [qualifier .parent] [atom &] {",
20
+ " [property color]: [keyword black];",
21
+ " }",
22
+ " [atom &] + [atom &] {",
23
+ " [property color]: [keyword red];",
24
+ " }",
25
+ "}");
26
+
27
+ MT("mixin",
28
+ "[qualifier .mixin] ([variable dark]; [variable-2 @color]) {",
29
+ " [property color]: [atom darken]([variable-2 @color], [number 10%]);",
30
+ "}",
31
+ "[qualifier .mixin] ([variable light]; [variable-2 @color]) {",
32
+ " [property color]: [atom lighten]([variable-2 @color], [number 10%]);",
33
+ "}",
34
+ "[qualifier .mixin] ([variable-2 @_]; [variable-2 @color]) {",
35
+ " [property display]: [atom block];",
36
+ "}",
37
+ "[variable-2 @switch]: [variable light];",
38
+ "[qualifier .class] {",
39
+ " [qualifier .mixin]([variable-2 @switch]; [atom #888]);",
40
+ "}");
41
+
42
+ MT("nest",
43
+ "[qualifier .one] {",
44
+ " [def @media] ([property width]: [number 400px]) {",
45
+ " [property font-size]: [number 1.2em];",
46
+ " [def @media] [attribute print] [keyword and] [property color] {",
47
+ " [property color]: [keyword blue];",
48
+ " }",
49
+ " }",
50
+ "}");
51
+
52
+
53
+ MT("interpolation", ".@{[variable foo]} { [property font-weight]: [atom bold]; }");
54
+ })();
inc/lib/codemirror/mode/css/scss.html ADDED
@@ -0,0 +1,157 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: SCSS mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <script src="../../lib/codemirror.js"></script>
9
+ <script src="css.js"></script>
10
+ <style>.CodeMirror {background: #f8f8f8;}</style>
11
+ <div id=nav>
12
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
13
+
14
+ <ul>
15
+ <li><a href="../../index.html">Home</a>
16
+ <li><a href="../../doc/manual.html">Manual</a>
17
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
18
+ </ul>
19
+ <ul>
20
+ <li><a href="../index.html">Language modes</a>
21
+ <li><a class=active href="#">SCSS</a>
22
+ </ul>
23
+ </div>
24
+
25
+ <article>
26
+ <h2>SCSS mode</h2>
27
+ <form><textarea id="code" name="code">
28
+ /* Some example SCSS */
29
+
30
+ @import "compass/css3";
31
+ $variable: #333;
32
+
33
+ $blue: #3bbfce;
34
+ $margin: 16px;
35
+
36
+ .content-navigation {
37
+ #nested {
38
+ background-color: black;
39
+ }
40
+ border-color: $blue;
41
+ color:
42
+ darken($blue, 9%);
43
+ }
44
+
45
+ .border {
46
+ padding: $margin / 2;
47
+ margin: $margin / 2;
48
+ border-color: $blue;
49
+ }
50
+
51
+ @mixin table-base {
52
+ th {
53
+ text-align: center;
54
+ font-weight: bold;
55
+ }
56
+ td, th {padding: 2px}
57
+ }
58
+
59
+ table.hl {
60
+ margin: 2em 0;
61
+ td.ln {
62
+ text-align: right;
63
+ }
64
+ }
65
+
66
+ li {
67
+ font: {
68
+ family: serif;
69
+ weight: bold;
70
+ size: 1.2em;
71
+ }
72
+ }
73
+
74
+ @mixin left($dist) {
75
+ float: left;
76
+ margin-left: $dist;
77
+ }
78
+
79
+ #data {
80
+ @include left(10px);
81
+ @include table-base;
82
+ }
83
+
84
+ .source {
85
+ @include flow-into(target);
86
+ border: 10px solid green;
87
+ margin: 20px;
88
+ width: 200px; }
89
+
90
+ .new-container {
91
+ @include flow-from(target);
92
+ border: 10px solid red;
93
+ margin: 20px;
94
+ width: 200px; }
95
+
96
+ body {
97
+ margin: 0;
98
+ padding: 3em 6em;
99
+ font-family: tahoma, arial, sans-serif;
100
+ color: #000;
101
+ }
102
+
103
+ @mixin yellow() {
104
+ background: yellow;
105
+ }
106
+
107
+ .big {
108
+ font-size: 14px;
109
+ }
110
+
111
+ .nested {
112
+ @include border-radius(3px);
113
+ @extend .big;
114
+ p {
115
+ background: whitesmoke;
116
+ a {
117
+ color: red;
118
+ }
119
+ }
120
+ }
121
+
122
+ #navigation a {
123
+ font-weight: bold;
124
+ text-decoration: none !important;
125
+ }
126
+
127
+ h1 {
128
+ font-size: 2.5em;
129
+ }
130
+
131
+ h2 {
132
+ font-size: 1.7em;
133
+ }
134
+
135
+ h1:before, h2:before {
136
+ content: "::";
137
+ }
138
+
139
+ code {
140
+ font-family: courier, monospace;
141
+ font-size: 80%;
142
+ color: #418A8A;
143
+ }
144
+ </textarea></form>
145
+ <script>
146
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
147
+ lineNumbers: true,
148
+ matchBrackets: true,
149
+ mode: "text/x-scss"
150
+ });
151
+ </script>
152
+
153
+ <p>The SCSS mode is a sub-mode of the <a href="index.html">CSS mode</a> (defined in <code>css.js</code>).</p>
154
+
155
+ <p><strong>Parsing/Highlighting Tests:</strong> <a href="../../test/index.html#scss_*">normal</a>, <a href="../../test/index.html#verbose,scss_*">verbose</a>.</p>
156
+
157
+ </article>
inc/lib/codemirror/mode/css/scss_test.js ADDED
@@ -0,0 +1,110 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://codemirror.net/LICENSE
3
+
4
+ (function() {
5
+ var mode = CodeMirror.getMode({indentUnit: 2}, "text/x-scss");
6
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), "scss"); }
7
+
8
+ MT('url_with_quotation',
9
+ "[tag foo] { [property background]:[atom url]([string test.jpg]) }");
10
+
11
+ MT('url_with_double_quotes',
12
+ "[tag foo] { [property background]:[atom url]([string \"test.jpg\"]) }");
13
+
14
+ MT('url_with_single_quotes',
15
+ "[tag foo] { [property background]:[atom url]([string \'test.jpg\']) }");
16
+
17
+ MT('string',
18
+ "[def @import] [string \"compass/css3\"]");
19
+
20
+ MT('important_keyword',
21
+ "[tag foo] { [property background]:[atom url]([string \'test.jpg\']) [keyword !important] }");
22
+
23
+ MT('variable',
24
+ "[variable-2 $blue]:[atom #333]");
25
+
26
+ MT('variable_as_attribute',
27
+ "[tag foo] { [property color]:[variable-2 $blue] }");
28
+
29
+ MT('numbers',
30
+ "[tag foo] { [property padding]:[number 10px] [number 10] [number 10em] [number 8in] }");
31
+
32
+ MT('number_percentage',
33
+ "[tag foo] { [property width]:[number 80%] }");
34
+
35
+ MT('selector',
36
+ "[builtin #hello][qualifier .world]{}");
37
+
38
+ MT('singleline_comment',
39
+ "[comment // this is a comment]");
40
+
41
+ MT('multiline_comment',
42
+ "[comment /*foobar*/]");
43
+
44
+ MT('attribute_with_hyphen',
45
+ "[tag foo] { [property font-size]:[number 10px] }");
46
+
47
+ MT('string_after_attribute',
48
+ "[tag foo] { [property content]:[string \"::\"] }");
49
+
50
+ MT('directives',
51
+ "[def @include] [qualifier .mixin]");
52
+
53
+ MT('basic_structure',
54
+ "[tag p] { [property background]:[keyword red]; }");
55
+
56
+ MT('nested_structure',
57
+ "[tag p] { [tag a] { [property color]:[keyword red]; } }");
58
+
59
+ MT('mixin',
60
+ "[def @mixin] [tag table-base] {}");
61
+
62
+ MT('number_without_semicolon',
63
+ "[tag p] {[property width]:[number 12]}",
64
+ "[tag a] {[property color]:[keyword red];}");
65
+
66
+ MT('atom_in_nested_block',
67
+ "[tag p] { [tag a] { [property color]:[atom #000]; } }");
68
+
69
+ MT('interpolation_in_property',
70
+ "[tag foo] { #{[variable-2 $hello]}:[number 2]; }");
71
+
72
+ MT('interpolation_in_selector',
73
+ "[tag foo]#{[variable-2 $hello]} { [property color]:[atom #000]; }");
74
+
75
+ MT('interpolation_error',
76
+ "[tag foo]#{[variable foo]} { [property color]:[atom #000]; }");
77
+
78
+ MT("divide_operator",
79
+ "[tag foo] { [property width]:[number 4] [operator /] [number 2] }");
80
+
81
+ MT('nested_structure_with_id_selector',
82
+ "[tag p] { [builtin #hello] { [property color]:[keyword red]; } }");
83
+
84
+ MT('indent_mixin',
85
+ "[def @mixin] [tag container] (",
86
+ " [variable-2 $a]: [number 10],",
87
+ " [variable-2 $b]: [number 10])",
88
+ "{}");
89
+
90
+ MT('indent_nested',
91
+ "[tag foo] {",
92
+ " [tag bar] {",
93
+ " }",
94
+ "}");
95
+
96
+ MT('indent_parentheses',
97
+ "[tag foo] {",
98
+ " [property color]: [atom darken]([variable-2 $blue],",
99
+ " [number 9%]);",
100
+ "}");
101
+
102
+ MT('indent_vardef',
103
+ "[variable-2 $name]:",
104
+ " [string 'val'];",
105
+ "[tag tag] {",
106
+ " [tag inner] {",
107
+ " [property margin]: [number 3px];",
108
+ " }",
109
+ "}");
110
+ })();
inc/lib/codemirror/mode/css/test.js ADDED
@@ -0,0 +1,209 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://codemirror.net/LICENSE
3
+
4
+ (function() {
5
+ var mode = CodeMirror.getMode({indentUnit: 2}, "css");
6
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
7
+
8
+ // Error, because "foobarhello" is neither a known type or property, but
9
+ // property was expected (after "and"), and it should be in parentheses.
10
+ MT("atMediaUnknownType",
11
+ "[def @media] [attribute screen] [keyword and] [error foobarhello] { }");
12
+
13
+ // Soft error, because "foobarhello" is not a known property or type.
14
+ MT("atMediaUnknownProperty",
15
+ "[def @media] [attribute screen] [keyword and] ([error foobarhello]) { }");
16
+
17
+ // Make sure nesting works with media queries
18
+ MT("atMediaMaxWidthNested",
19
+ "[def @media] [attribute screen] [keyword and] ([property max-width]: [number 25px]) { [tag foo] { } }");
20
+
21
+ MT("atMediaFeatureValueKeyword",
22
+ "[def @media] ([property orientation]: [keyword landscape]) { }");
23
+
24
+ MT("atMediaUnknownFeatureValueKeyword",
25
+ "[def @media] ([property orientation]: [error upsidedown]) { }");
26
+
27
+ MT("atMediaUppercase",
28
+ "[def @MEDIA] ([property orienTAtion]: [keyword landScape]) { }");
29
+
30
+ MT("tagSelector",
31
+ "[tag foo] { }");
32
+
33
+ MT("classSelector",
34
+ "[qualifier .foo-bar_hello] { }");
35
+
36
+ MT("idSelector",
37
+ "[builtin #foo] { [error #foo] }");
38
+
39
+ MT("tagSelectorUnclosed",
40
+ "[tag foo] { [property margin]: [number 0] } [tag bar] { }");
41
+
42
+ MT("tagStringNoQuotes",
43
+ "[tag foo] { [property font-family]: [variable hello] [variable world]; }");
44
+
45
+ MT("tagStringDouble",
46
+ "[tag foo] { [property font-family]: [string \"hello world\"]; }");
47
+
48
+ MT("tagStringSingle",
49
+ "[tag foo] { [property font-family]: [string 'hello world']; }");
50
+
51
+ MT("tagColorKeyword",
52
+ "[tag foo] {",
53
+ " [property color]: [keyword black];",
54
+ " [property color]: [keyword navy];",
55
+ " [property color]: [keyword yellow];",
56
+ "}");
57
+
58
+ MT("tagColorHex3",
59
+ "[tag foo] { [property background]: [atom #fff]; }");
60
+
61
+ MT("tagColorHex4",
62
+ "[tag foo] { [property background]: [atom #ffff]; }");
63
+
64
+ MT("tagColorHex6",
65
+ "[tag foo] { [property background]: [atom #ffffff]; }");
66
+
67
+ MT("tagColorHex8",
68
+ "[tag foo] { [property background]: [atom #ffffffff]; }");
69
+
70
+ MT("tagColorHex5Invalid",
71
+ "[tag foo] { [property background]: [atom&error #fffff]; }");
72
+
73
+ MT("tagColorHexInvalid",
74
+ "[tag foo] { [property background]: [atom&error #ffg]; }");
75
+
76
+ MT("tagNegativeNumber",
77
+ "[tag foo] { [property margin]: [number -5px]; }");
78
+
79
+ MT("tagPositiveNumber",
80
+ "[tag foo] { [property padding]: [number 5px]; }");
81
+
82
+ MT("tagVendor",
83
+ "[tag foo] { [meta -foo-][property box-sizing]: [meta -foo-][atom border-box]; }");
84
+
85
+ MT("tagBogusProperty",
86
+ "[tag foo] { [property&error barhelloworld]: [number 0]; }");
87
+
88
+ MT("tagTwoProperties",
89
+ "[tag foo] { [property margin]: [number 0]; [property padding]: [number 0]; }");
90
+
91
+ MT("tagTwoPropertiesURL",
92
+ "[tag foo] { [property background]: [atom url]([string //example.com/foo.png]); [property padding]: [number 0]; }");
93
+
94
+ MT("indent_tagSelector",
95
+ "[tag strong], [tag em] {",
96
+ " [property background]: [atom rgba](",
97
+ " [number 255], [number 255], [number 0], [number .2]",
98
+ " );",
99
+ "}");
100
+
101
+ MT("indent_atMedia",
102
+ "[def @media] {",
103
+ " [tag foo] {",
104
+ " [property color]:",
105
+ " [keyword yellow];",
106
+ " }",
107
+ "}");
108
+
109
+ MT("indent_comma",
110
+ "[tag foo] {",
111
+ " [property font-family]: [variable verdana],",
112
+ " [atom sans-serif];",
113
+ "}");
114
+
115
+ MT("indent_parentheses",
116
+ "[tag foo]:[variable-3 before] {",
117
+ " [property background]: [atom url](",
118
+ "[string blahblah]",
119
+ "[string etc]",
120
+ "[string ]) [keyword !important];",
121
+ "}");
122
+
123
+ MT("font_face",
124
+ "[def @font-face] {",
125
+ " [property font-family]: [string 'myfont'];",
126
+ " [error nonsense]: [string 'abc'];",
127
+ " [property src]: [atom url]([string http://blah]),",
128
+ " [atom url]([string http://foo]);",
129
+ "}");
130
+
131
+ MT("empty_url",
132
+ "[def @import] [atom url]() [attribute screen];");
133
+
134
+ MT("parens",
135
+ "[qualifier .foo] {",
136
+ " [property background-image]: [variable fade]([atom #000], [number 20%]);",
137
+ " [property border-image]: [atom linear-gradient](",
138
+ " [atom to] [atom bottom],",
139
+ " [variable fade]([atom #000], [number 20%]) [number 0%],",
140
+ " [variable fade]([atom #000], [number 20%]) [number 100%]",
141
+ " );",
142
+ "}");
143
+
144
+ MT("css_variable",
145
+ ":[variable-3 root] {",
146
+ " [variable-2 --main-color]: [atom #06c];",
147
+ "}",
148
+ "[tag h1][builtin #foo] {",
149
+ " [property color]: [atom var]([variable-2 --main-color]);",
150
+ "}");
151
+
152
+ MT("supports",
153
+ "[def @supports] ([keyword not] (([property text-align-last]: [atom justify]) [keyword or] ([meta -moz-][property text-align-last]: [atom justify])) {",
154
+ " [property text-align-last]: [atom justify];",
155
+ "}");
156
+
157
+ MT("document",
158
+ "[def @document] [tag url]([string http://blah]),",
159
+ " [tag url-prefix]([string https://]),",
160
+ " [tag domain]([string blah.com]),",
161
+ " [tag regexp]([string \".*blah.+\"]) {",
162
+ " [builtin #id] {",
163
+ " [property background-color]: [keyword white];",
164
+ " }",
165
+ " [tag foo] {",
166
+ " [property font-family]: [variable Verdana], [atom sans-serif];",
167
+ " }",
168
+ "}");
169
+
170
+ MT("document_url",
171
+ "[def @document] [tag url]([string http://blah]) { [qualifier .class] { } }");
172
+
173
+ MT("document_urlPrefix",
174
+ "[def @document] [tag url-prefix]([string https://]) { [builtin #id] { } }");
175
+
176
+ MT("document_domain",
177
+ "[def @document] [tag domain]([string blah.com]) { [tag foo] { } }");
178
+
179
+ MT("document_regexp",
180
+ "[def @document] [tag regexp]([string \".*blah.+\"]) { [builtin #id] { } }");
181
+
182
+ MT("counter-style",
183
+ "[def @counter-style] [variable binary] {",
184
+ " [property system]: [atom numeric];",
185
+ " [property symbols]: [number 0] [number 1];",
186
+ " [property suffix]: [string \".\"];",
187
+ " [property range]: [atom infinite];",
188
+ " [property speak-as]: [atom numeric];",
189
+ "}");
190
+
191
+ MT("counter-style-additive-symbols",
192
+ "[def @counter-style] [variable simple-roman] {",
193
+ " [property system]: [atom additive];",
194
+ " [property additive-symbols]: [number 10] [variable X], [number 5] [variable V], [number 1] [variable I];",
195
+ " [property range]: [number 1] [number 49];",
196
+ "}");
197
+
198
+ MT("counter-style-use",
199
+ "[tag ol][qualifier .roman] { [property list-style]: [variable simple-roman]; }");
200
+
201
+ MT("counter-style-symbols",
202
+ "[tag ol] { [property list-style]: [atom symbols]([atom cyclic] [string \"*\"] [string \"\\2020\"] [string \"\\2021\"] [string \"\\A7\"]); }");
203
+
204
+ MT("comment-does-not-disrupt",
205
+ "[def @font-face] [comment /* foo */] {",
206
+ " [property src]: [atom url]([string x]);",
207
+ " [property font-family]: [variable One];",
208
+ "}")
209
+ })();
inc/lib/codemirror/mode/{htmlmixed.js → htmlmixed/htmlmixed.js} RENAMED
@@ -14,7 +14,7 @@
14
  var defaultTags = {
15
  script: [
16
  ["lang", /(javascript|babel)/i, "javascript"],
17
- ["type", /^(?:text|application)\/(?:x-)?(?:java|ecma)script$|^$/i, "javascript"],
18
  ["type", /./, "text/plain"],
19
  [null, null, "javascript"]
20
  ],
@@ -46,7 +46,7 @@
46
 
47
  function getAttrValue(text, attr) {
48
  var match = text.match(getAttrRegexp(attr))
49
- return match ? match[2] : ""
50
  }
51
 
52
  function getTagRegexp(tagName, anchored) {
@@ -133,11 +133,11 @@
133
  return state.token(stream, state);
134
  },
135
 
136
- indent: function (state, textAfter) {
137
  if (!state.localMode || /^\s*<\//.test(textAfter))
138
  return htmlMode.indent(state.htmlState, textAfter);
139
  else if (state.localMode.indent)
140
- return state.localMode.indent(state.localState, textAfter);
141
  else
142
  return CodeMirror.Pass;
143
  },
14
  var defaultTags = {
15
  script: [
16
  ["lang", /(javascript|babel)/i, "javascript"],
17
+ ["type", /^(?:text|application)\/(?:x-)?(?:java|ecma)script$|^module$|^$/i, "javascript"],
18
  ["type", /./, "text/plain"],
19
  [null, null, "javascript"]
20
  ],
46
 
47
  function getAttrValue(text, attr) {
48
  var match = text.match(getAttrRegexp(attr))
49
+ return match ? /^\s*(.*?)\s*$/.exec(match[2])[1] : ""
50
  }
51
 
52
  function getTagRegexp(tagName, anchored) {
133
  return state.token(stream, state);
134
  },
135
 
136
+ indent: function (state, textAfter, line) {
137
  if (!state.localMode || /^\s*<\//.test(textAfter))
138
  return htmlMode.indent(state.htmlState, textAfter);
139
  else if (state.localMode.indent)
140
+ return state.localMode.indent(state.localState, textAfter, line);
141
  else
142
  return CodeMirror.Pass;
143
  },
inc/lib/codemirror/mode/htmlmixed/index.html ADDED
@@ -0,0 +1,100 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: HTML mixed mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <script src="../../lib/codemirror.js"></script>
9
+ <script src="../../addon/selection/selection-pointer.js"></script>
10
+ <script src="../xml/xml.js"></script>
11
+ <script src="../javascript/javascript.js"></script>
12
+ <script src="../css/css.js"></script>
13
+ <script src="../vbscript/vbscript.js"></script>
14
+ <script src="htmlmixed.js"></script>
15
+ <style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
16
+ <div id=nav>
17
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
18
+
19
+ <ul>
20
+ <li><a href="../../index.html">Home</a>
21
+ <li><a href="../../doc/manual.html">Manual</a>
22
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
23
+ </ul>
24
+ <ul>
25
+ <li><a href="../index.html">Language modes</a>
26
+ <li><a class=active href="#">HTML mixed</a>
27
+ </ul>
28
+ </div>
29
+
30
+ <article>
31
+ <h2>HTML mixed mode</h2>
32
+ <form><textarea id="code" name="code">
33
+ <html style="color: green">
34
+ <!-- this is a comment -->
35
+ <head>
36
+ <title>Mixed HTML Example</title>
37
+ <style type="text/css">
38
+ h1 {font-family: comic sans; color: #f0f;}
39
+ div {background: yellow !important;}
40
+ body {
41
+ max-width: 50em;
42
+ margin: 1em 2em 1em 5em;
43
+ }
44
+ </style>
45
+ </head>
46
+ <body>
47
+ <h1>Mixed HTML Example</h1>
48
+ <script>
49
+ function jsFunc(arg1, arg2) {
50
+ if (arg1 && arg2) document.body.innerHTML = "achoo";
51
+ }
52
+ </script>
53
+ </body>
54
+ </html>
55
+ </textarea></form>
56
+ <script>
57
+ // Define an extended mixed-mode that understands vbscript and
58
+ // leaves mustache/handlebars embedded templates in html mode
59
+ var mixedMode = {
60
+ name: "htmlmixed",
61
+ scriptTypes: [{matches: /\/x-handlebars-template|\/x-mustache/i,
62
+ mode: null},
63
+ {matches: /(text|application)\/(x-)?vb(a|script)/i,
64
+ mode: "vbscript"}]
65
+ };
66
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
67
+ mode: mixedMode,
68
+ selectionPointer: true
69
+ });
70
+ </script>
71
+
72
+ <p>The HTML mixed mode depends on the XML, JavaScript, and CSS modes.</p>
73
+
74
+ <p>It takes an optional mode configuration
75
+ option, <code>tags</code>, which can be used to add custom
76
+ behavior for specific tags. When given, it should be an object
77
+ mapping tag names (for example <code>script</code>) to arrays or
78
+ three-element arrays. Those inner arrays indicate [attributeName,
79
+ valueRegexp, <a href="../../doc/manual.html#option_mode">modeSpec</a>]
80
+ specifications. For example, you could use <code>["type", /^foo$/,
81
+ "foo"]</code> to map the attribute <code>type="foo"</code> to
82
+ the <code>foo</code> mode. When the first two fields are null
83
+ (<code>[null, null, "mode"]</code>), the given mode is used for
84
+ any such tag that doesn't match any of the previously given
85
+ attributes. For example:</p>
86
+
87
+ <pre>var myModeSpec = {
88
+ name: "htmlmixed",
89
+ tags: {
90
+ style: [["type", /^text\/(x-)?scss$/, "text/x-scss"],
91
+ [null, null, "css"]],
92
+ custom: [[null, null, "customMode"]]
93
+ }
94
+ }</pre>
95
+
96
+ <p><strong>MIME types defined:</strong> <code>text/html</code>
97
+ (redefined, only takes effect if you load this parser after the
98
+ XML parser).</p>
99
+
100
+ </article>
inc/lib/codemirror/mode/index.html ADDED
@@ -0,0 +1,165 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: Language Modes</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../doc/docs.css">
6
+
7
+ <div id=nav>
8
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../doc/logo.png"></a>
9
+
10
+ <ul>
11
+ <li><a href="../index.html">Home</a>
12
+ <li><a href="../doc/manual.html">Manual</a>
13
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
14
+ </ul>
15
+ <ul>
16
+ <li><a class=active href="#">Language modes</a>
17
+ </ul>
18
+ </div>
19
+
20
+ <article>
21
+
22
+ <h2>Language modes</h2>
23
+
24
+ <p>This is a list of every mode in the distribution. Each mode lives
25
+ in a subdirectory of the <code>mode/</code> directory, and typically
26
+ defines a single JavaScript file that implements the mode. Loading
27
+ such file will make the language available to CodeMirror, through
28
+ the <a href="../doc/manual.html#option_mode"><code>mode</code></a>
29
+ option.</p>
30
+
31
+ <div style="-webkit-columns: 100px 2; -moz-columns: 100px 2; columns: 100px 2;">
32
+ <ul style="margin-top: 0">
33
+ <li><a href="apl/index.html">APL</a></li>
34
+ <li><a href="asn.1/index.html">ASN.1</a></li>
35
+ <li><a href="asterisk/index.html">Asterisk dialplan</a></li>
36
+ <li><a href="brainfuck/index.html">Brainfuck</a></li>
37
+ <li><a href="clike/index.html">C, C++, C#</a></li>
38
+ <li><a href="clike/index.html">Ceylon</a></li>
39
+ <li><a href="clojure/index.html">Clojure</a></li>
40
+ <li><a href="css/gss.html">Closure Stylesheets (GSS)</a></li>
41
+ <li><a href="cmake/index.html">CMake</a></li>
42
+ <li><a href="cobol/index.html">COBOL</a></li>
43
+ <li><a href="coffeescript/index.html">CoffeeScript</a></li>
44
+ <li><a href="commonlisp/index.html">Common Lisp</a></li>
45
+ <li><a href="crystal/index.html">Crystal</a></li>
46
+ <li><a href="css/index.html">CSS</a></li>
47
+ <li><a href="cypher/index.html">Cypher</a></li>
48
+ <li><a href="python/index.html">Cython</a></li>
49
+ <li><a href="d/index.html">D</a></li>
50
+ <li><a href="dart/index.html">Dart</a></li>
51
+ <li><a href="django/index.html">Django</a> (templating language)</li>
52
+ <li><a href="dockerfile/index.html">Dockerfile</a></li>
53
+ <li><a href="diff/index.html">diff</a></li>
54
+ <li><a href="dtd/index.html">DTD</a></li>
55
+ <li><a href="dylan/index.html">Dylan</a></li>
56
+ <li><a href="ebnf/index.html">EBNF</a></li>
57
+ <li><a href="ecl/index.html">ECL</a></li>
58
+ <li><a href="eiffel/index.html">Eiffel</a></li>
59
+ <li><a href="https://github.com/optick/codemirror-mode-elixir">Elixir</a></li>
60
+ <li><a href="elm/index.html">Elm</a></li>
61
+ <li><a href="erlang/index.html">Erlang</a></li>
62
+ <li><a href="factor/index.html">Factor</a></li>
63
+ <li><a href="fcl/index.html">FCL</a></li>
64
+ <li><a href="forth/index.html">Forth</a></li>
65
+ <li><a href="fortran/index.html">Fortran</a></li>
66
+ <li><a href="mllike/index.html">F#</a></li>
67
+ <li><a href="gas/index.html">Gas</a> (AT&amp;T-style assembly)</li>
68
+ <li><a href="gherkin/index.html">Gherkin</a></li>
69
+ <li><a href="go/index.html">Go</a></li>
70
+ <li><a href="groovy/index.html">Groovy</a></li>
71
+ <li><a href="haml/index.html">HAML</a></li>
72
+ <li><a href="handlebars/index.html">Handlebars</a></li>
73
+ <li><a href="haskell/index.html">Haskell</a> (<a href="haskell-literate/index.html">Literate</a>)</li>
74
+ <li><a href="haxe/index.html">Haxe</a></li>
75
+ <li><a href="htmlembedded/index.html">HTML embedded</a> (JSP, ASP.NET)</li>
76
+ <li><a href="htmlmixed/index.html">HTML mixed-mode</a></li>
77
+ <li><a href="http/index.html">HTTP</a></li>
78
+ <li><a href="idl/index.html">IDL</a></li>
79
+ <li><a href="clike/index.html">Java</a></li>
80
+ <li><a href="javascript/index.html">JavaScript</a> (<a href="jsx/index.html">JSX</a>)</li>
81
+ <li><a href="jinja2/index.html">Jinja2</a></li>
82
+ <li><a href="julia/index.html">Julia</a></li>
83
+ <li><a href="clike/index.html">Kotlin</a></li>
84
+ <li><a href="css/less.html">LESS</a></li>
85
+ <li><a href="livescript/index.html">LiveScript</a></li>
86
+ <li><a href="lua/index.html">Lua</a></li>
87
+ <li><a href="markdown/index.html">Markdown</a> (<a href="gfm/index.html">GitHub-flavour</a>)</li>
88
+ <li><a href="mathematica/index.html">Mathematica</a></li>
89
+ <li><a href="mbox/index.html">mbox</a></li>
90
+ <li><a href="mirc/index.html">mIRC</a></li>
91
+ <li><a href="modelica/index.html">Modelica</a></li>
92
+ <li><a href="mscgen/index.html">MscGen</a></li>
93
+ <li><a href="mumps/index.html">MUMPS</a></li>
94
+ <li><a href="nginx/index.html">Nginx</a></li>
95
+ <li><a href="nsis/index.html">NSIS</a></li>
96
+ <li><a href="ntriples/index.html">N-Triples/N-Quads</a></li>
97
+ <li><a href="clike/index.html">Objective C</a></li>
98
+ <li><a href="mllike/index.html">OCaml</a></li>
99
+ <li><a href="octave/index.html">Octave</a> (MATLAB)</li>
100
+ <li><a href="oz/index.html">Oz</a></li>
101
+ <li><a href="pascal/index.html">Pascal</a></li>
102
+ <li><a href="pegjs/index.html">PEG.js</a></li>
103
+ <li><a href="perl/index.html">Perl</a></li>
104
+ <li><a href="asciiarmor/index.html">PGP (ASCII armor)</a></li>
105
+ <li><a href="php/index.html">PHP</a></li>
106
+ <li><a href="pig/index.html">Pig Latin</a></li>
107
+ <li><a href="powershell/index.html">PowerShell</a></li>
108
+ <li><a href="properties/index.html">Properties files</a></li>
109
+ <li><a href="protobuf/index.html">ProtoBuf</a></li>
110
+ <li><a href="pug/index.html">Pug</a></li>
111
+ <li><a href="puppet/index.html">Puppet</a></li>
112
+ <li><a href="python/index.html">Python</a></li>
113
+ <li><a href="q/index.html">Q</a></li>
114
+ <li><a href="r/index.html">R</a></li>
115
+ <li><a href="rpm/index.html">RPM</a></li>
116
+ <li><a href="rst/index.html">reStructuredText</a></li>
117
+ <li><a href="ruby/index.html">Ruby</a></li>
118
+ <li><a href="rust/index.html">Rust</a></li>
119
+ <li><a href="sas/index.html">SAS</a></li>
120
+ <li><a href="sass/index.html">Sass</a></li>
121
+ <li><a href="spreadsheet/index.html">Spreadsheet</a></li>
122
+ <li><a href="clike/scala.html">Scala</a></li>
123
+ <li><a href="scheme/index.html">Scheme</a></li>
124
+ <li><a href="css/scss.html">SCSS</a></li>
125
+ <li><a href="shell/index.html">Shell</a></li>
126
+ <li><a href="sieve/index.html">Sieve</a></li>
127
+ <li><a href="slim/index.html">Slim</a></li>
128
+ <li><a href="smalltalk/index.html">Smalltalk</a></li>
129
+ <li><a href="smarty/index.html">Smarty</a></li>
130
+ <li><a href="solr/index.html">Solr</a></li>
131
+ <li><a href="soy/index.html">Soy</a></li>
132
+ <li><a href="stylus/index.html">Stylus</a></li>
133
+ <li><a href="sql/index.html">SQL</a> (several dialects)</li>
134
+ <li><a href="sparql/index.html">SPARQL</a></li>
135
+ <li><a href="clike/index.html">Squirrel</a></li>
136
+ <li><a href="swift/index.html">Swift</a></li>
137
+ <li><a href="stex/index.html">sTeX, LaTeX</a></li>
138
+ <li><a href="tcl/index.html">Tcl</a></li>
139
+ <li><a href="textile/index.html">Textile</a></li>
140
+ <li><a href="tiddlywiki/index.html">Tiddlywiki</a></li>
141
+ <li><a href="tiki/index.html">Tiki wiki</a></li>
142
+ <li><a href="toml/index.html">TOML</a></li>
143
+ <li><a href="tornado/index.html">Tornado</a> (templating language)</li>
144
+ <li><a href="troff/index.html">troff</a> (for manpages)</li>
145
+ <li><a href="ttcn/index.html">TTCN</a></li>
146
+ <li><a href="ttcn-cfg/index.html">TTCN Configuration</a></li>
147
+ <li><a href="turtle/index.html">Turtle</a></li>
148
+ <li><a href="twig/index.html">Twig</a></li>
149
+ <li><a href="vb/index.html">VB.NET</a></li>
150
+ <li><a href="vbscript/index.html">VBScript</a></li>
151
+ <li><a href="velocity/index.html">Velocity</a></li>
152
+ <li><a href="verilog/index.html">Verilog/SystemVerilog</a></li>
153
+ <li><a href="vhdl/index.html">VHDL</a></li>
154
+ <li><a href="vue/index.html">Vue.js app</a></li>
155
+ <li><a href="webidl/index.html">Web IDL</a></li>
156
+ <li><a href="xml/index.html">XML/HTML</a></li>
157
+ <li><a href="xquery/index.html">XQuery</a></li>
158
+ <li><a href="yacas/index.html">Yacas</a></li>
159
+ <li><a href="yaml/index.html">YAML</a></li>
160
+ <li><a href="yaml-frontmatter/index.html">YAML frontmatter</a></li>
161
+ <li><a href="z80/index.html">Z80</a></li>
162
+ </ul>
163
+ </div>
164
+
165
+ </article>
inc/lib/codemirror/mode/javascript/index.html ADDED
@@ -0,0 +1,114 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: JavaScript mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <script src="../../lib/codemirror.js"></script>
9
+ <script src="../../addon/edit/matchbrackets.js"></script>
10
+ <script src="../../addon/comment/continuecomment.js"></script>
11
+ <script src="../../addon/comment/comment.js"></script>
12
+ <script src="javascript.js"></script>
13
+ <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
14
+ <div id=nav>
15
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
16
+
17
+ <ul>
18
+ <li><a href="../../index.html">Home</a>
19
+ <li><a href="../../doc/manual.html">Manual</a>
20
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
21
+ </ul>
22
+ <ul>
23
+ <li><a href="../index.html">Language modes</a>
24
+ <li><a class=active href="#">JavaScript</a>
25
+ </ul>
26
+ </div>
27
+
28
+ <article>
29
+ <h2>JavaScript mode</h2>
30
+
31
+
32
+ <div><textarea id="code" name="code">
33
+ // Demo code (the actual new parser character stream implementation)
34
+
35
+ function StringStream(string) {
36
+ this.pos = 0;
37
+ this.string = string;
38
+ }
39
+
40
+ StringStream.prototype = {
41
+ done: function() {return this.pos >= this.string.length;},
42
+ peek: function() {return this.string.charAt(this.pos);},
43
+ next: function() {
44
+ if (this.pos &lt; this.string.length)
45
+ return this.string.charAt(this.pos++);
46
+ },
47
+ eat: function(match) {
48
+ var ch = this.string.charAt(this.pos);
49
+ if (typeof match == "string") var ok = ch == match;
50
+ else var ok = ch &amp;&amp; match.test ? match.test(ch) : match(ch);
51
+ if (ok) {this.pos++; return ch;}
52
+ },
53
+ eatWhile: function(match) {
54
+ var start = this.pos;
55
+ while (this.eat(match));
56
+ if (this.pos > start) return this.string.slice(start, this.pos);
57
+ },
58
+ backUp: function(n) {this.pos -= n;},
59
+ column: function() {return this.pos;},
60
+ eatSpace: function() {
61
+ var start = this.pos;
62
+ while (/\s/.test(this.string.charAt(this.pos))) this.pos++;
63
+ return this.pos - start;
64
+ },
65
+ match: function(pattern, consume, caseInsensitive) {
66
+ if (typeof pattern == "string") {
67
+ function cased(str) {return caseInsensitive ? str.toLowerCase() : str;}
68
+ if (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) {
69
+ if (consume !== false) this.pos += str.length;
70
+ return true;
71
+ }
72
+ }
73
+ else {
74
+ var match = this.string.slice(this.pos).match(pattern);
75
+ if (match &amp;&amp; consume !== false) this.pos += match[0].length;
76
+ return match;
77
+ }
78
+ }
79
+ };
80
+ </textarea></div>
81
+
82
+ <script>
83
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
84
+ lineNumbers: true,
85
+ matchBrackets: true,
86
+ continueComments: "Enter",
87
+ extraKeys: {"Ctrl-Q": "toggleComment"}
88
+ });
89
+ </script>
90
+
91
+ <p>
92
+ JavaScript mode supports several configuration options:
93
+ <ul>
94
+ <li><code>json</code> which will set the mode to expect JSON
95
+ data rather than a JavaScript program.</li>
96
+ <li><code>jsonld</code> which will set the mode to expect
97
+ <a href="http://json-ld.org">JSON-LD</a> linked data rather
98
+ than a JavaScript program (<a href="json-ld.html">demo</a>).</li>
99
+ <li><code>typescript</code> which will activate additional
100
+ syntax highlighting and some other things for TypeScript code
101
+ (<a href="typescript.html">demo</a>).</li>
102
+ <li><code>statementIndent</code> which (given a number) will
103
+ determine the amount of indentation to use for statements
104
+ continued on a new line.</li>
105
+ <li><code>wordCharacters</code>, a regexp that indicates which
106
+ characters should be considered part of an identifier.
107
+ Defaults to <code>/[\w$]/</code>, which does not handle
108
+ non-ASCII identifiers. Can be set to something more elaborate
109
+ to improve Unicode support.</li>
110
+ </ul>
111
+ </p>
112
+
113
+ <p><strong>MIME types defined:</strong> <code>text/javascript</code>, <code>application/json</code>, <code>application/ld+json</code>, <code>text/typescript</code>, <code>application/typescript</code>.</p>
114
+ </article>
inc/lib/codemirror/mode/{javascript.js → javascript/javascript.js} RENAMED
@@ -1,8 +1,6 @@
1
  // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
  // Distributed under an MIT license: http://codemirror.net/LICENSE
3
 
4
- // TODO actually recognize syntax of TypeScript constructs
5
-
6
  (function(mod) {
7
  if (typeof exports == "object" && typeof module == "object") // CommonJS
8
  mod(require("../../lib/codemirror"));
@@ -13,11 +11,6 @@
13
  })(function(CodeMirror) {
14
  "use strict";
15
 
16
- function expressionAllowed(stream, state, backUp) {
17
- return /^(?:operator|sof|keyword c|case|new|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
18
- (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
19
- }
20
-
21
  CodeMirror.defineMode("javascript", function(config, parserConfig) {
22
  var indentUnit = config.indentUnit;
23
  var statementIndent = parserConfig.statementIndent;
@@ -30,55 +23,24 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
30
 
31
  var keywords = function(){
32
  function kw(type) {return {type: type, style: "keyword"};}
33
- var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
34
  var operator = kw("operator"), atom = {type: "atom", style: "atom"};
35
 
36
- var jsKeywords = {
37
  "if": kw("if"), "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
38
- "return": C, "break": C, "continue": C, "new": kw("new"), "delete": C, "throw": C, "debugger": C,
39
- "var": kw("var"), "const": kw("var"), "let": kw("var"),
40
  "function": kw("function"), "catch": kw("catch"),
41
  "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
42
  "in": operator, "typeof": operator, "instanceof": operator,
43
  "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom,
44
  "this": kw("this"), "class": kw("class"), "super": kw("atom"),
45
  "yield": C, "export": kw("export"), "import": kw("import"), "extends": C,
46
- "await": C, "async": kw("async")
47
  };
48
-
49
- // Extend the 'normal' keywords with the TypeScript language extensions
50
- if (isTS) {
51
- var type = {type: "variable", style: "variable-3"};
52
- var tsKeywords = {
53
- // object-like things
54
- "interface": kw("class"),
55
- "implements": C,
56
- "namespace": C,
57
- "module": kw("module"),
58
- "enum": kw("module"),
59
-
60
- // scope modifiers
61
- "public": kw("modifier"),
62
- "private": kw("modifier"),
63
- "protected": kw("modifier"),
64
- "abstract": kw("modifier"),
65
-
66
- // operators
67
- "as": operator,
68
-
69
- // types
70
- "string": type, "number": type, "boolean": type, "any": type
71
- };
72
-
73
- for (var attr in tsKeywords) {
74
- jsKeywords[attr] = tsKeywords[attr];
75
- }
76
- }
77
-
78
- return jsKeywords;
79
  }();
80
 
81
- var isOperatorChar = /[+\-*&%=<>!?|~^]/;
82
  var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/;
83
 
84
  function readRegexp(stream) {
@@ -113,17 +75,10 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
113
  return ret(ch);
114
  } else if (ch == "=" && stream.eat(">")) {
115
  return ret("=>", "operator");
116
- } else if (ch == "0" && stream.eat(/x/i)) {
117
- stream.eatWhile(/[\da-f]/i);
118
- return ret("number", "number");
119
- } else if (ch == "0" && stream.eat(/o/i)) {
120
- stream.eatWhile(/[0-7]/i);
121
- return ret("number", "number");
122
- } else if (ch == "0" && stream.eat(/b/i)) {
123
- stream.eatWhile(/[01]/i);
124
  return ret("number", "number");
125
  } else if (/\d/.test(ch)) {
126
- stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
127
  return ret("number", "number");
128
  } else if (ch == "/") {
129
  if (stream.eat("*")) {
@@ -134,10 +89,10 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
134
  return ret("comment", "comment");
135
  } else if (expressionAllowed(stream, state, 1)) {
136
  readRegexp(stream);
137
- stream.match(/^\b(([gimyu])(?![gimyu]*\2))+\b/);
138
  return ret("regexp", "string-2");
139
  } else {
140
- stream.eatWhile(isOperatorChar);
141
  return ret("operator", "operator", stream.current());
142
  }
143
  } else if (ch == "`") {
@@ -147,13 +102,27 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
147
  stream.skipToEnd();
148
  return ret("error", "error");
149
  } else if (isOperatorChar.test(ch)) {
150
- stream.eatWhile(isOperatorChar);
 
 
 
 
 
 
 
151
  return ret("operator", "operator", stream.current());
152
  } else if (wordRE.test(ch)) {
153
  stream.eatWhile(wordRE);
154
- var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
155
- return (known && state.lastType != ".") ? ret(known.type, known.style, word) :
156
- ret("variable", "variable", word);
 
 
 
 
 
 
 
157
  }
158
  }
159
 
@@ -210,13 +179,18 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
210
  var arrow = stream.string.indexOf("=>", stream.start);
211
  if (arrow < 0) return;
212
 
 
 
 
 
 
213
  var depth = 0, sawSomething = false;
214
  for (var pos = arrow - 1; pos >= 0; --pos) {
215
  var ch = stream.string.charAt(pos);
216
  var bracket = brackets.indexOf(ch);
217
  if (bracket >= 0 && bracket < 3) {
218
  if (!depth) { ++pos; break; }
219
- if (--depth == 0) break;
220
  } else if (bracket >= 3 && bracket < 6) {
221
  ++depth;
222
  } else if (wordRE.test(ch)) {
@@ -284,35 +258,68 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
284
  pass.apply(null, arguments);
285
  return true;
286
  }
 
 
 
 
287
  function register(varname) {
288
- function inList(list) {
289
- for (var v = list; v; v = v.next)
290
- if (v.name == varname) return true;
291
- return false;
292
- }
293
  var state = cx.state;
294
  cx.marked = "def";
295
  if (state.context) {
296
- if (inList(state.localVars)) return;
297
- state.localVars = {name: varname, next: state.localVars};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
298
  } else {
299
- if (inList(state.globalVars)) return;
300
- if (parserConfig.globalVars)
301
- state.globalVars = {name: varname, next: state.globalVars};
302
  }
303
  }
304
 
 
 
 
 
305
  // Combinators
306
 
307
- var defaultVars = {name: "this", next: {name: "arguments"}};
 
 
 
308
  function pushcontext() {
309
- cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
310
- cx.state.localVars = defaultVars;
 
 
 
 
311
  }
312
  function popcontext() {
313
- cx.state.localVars = cx.state.context.vars;
314
- cx.state.context = cx.state.context.prev;
315
  }
 
316
  function pushlex(type, info) {
317
  var result = function() {
318
  var state = cx.state, indent = state.indented;
@@ -344,65 +351,89 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
344
  }
345
 
346
  function statement(type, value) {
347
- if (type == "var") return cont(pushlex("vardef", value.length), vardef, expect(";"), poplex);
348
- if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
349
  if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
350
- if (type == "{") return cont(pushlex("}"), block, poplex);
 
 
351
  if (type == ";") return cont();
352
  if (type == "if") {
353
  if (cx.state.lexical.info == "else" && cx.state.cc[cx.state.cc.length - 1] == poplex)
354
  cx.state.cc.pop()();
355
- return cont(pushlex("form"), expression, statement, poplex, maybeelse);
356
  }
357
  if (type == "function") return cont(functiondef);
358
  if (type == "for") return cont(pushlex("form"), forspec, statement, poplex);
359
- if (type == "variable") return cont(pushlex("stat"), maybelabel);
360
- if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
361
- block, poplex, poplex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
362
  if (type == "case") return cont(expression, expect(":"));
363
  if (type == "default") return cont(expect(":"));
364
- if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
365
- statement, poplex, popcontext);
366
- if (type == "class") return cont(pushlex("form"), className, poplex);
367
  if (type == "export") return cont(pushlex("stat"), afterExport, poplex);
368
  if (type == "import") return cont(pushlex("stat"), afterImport, poplex);
369
- if (type == "module") return cont(pushlex("form"), pattern, pushlex("}"), expect("{"), block, poplex, poplex)
370
  if (type == "async") return cont(statement)
 
371
  return pass(pushlex("stat"), expression, expect(";"), poplex);
372
  }
373
- function expression(type) {
374
- return expressionInner(type, false);
 
 
 
375
  }
376
- function expressionNoComma(type) {
377
- return expressionInner(type, true);
378
  }
379
- function expressionInner(type, noComma) {
 
 
 
 
380
  if (cx.state.fatArrowAt == cx.stream.start) {
381
  var body = noComma ? arrowBodyNoComma : arrowBody;
382
- if (type == "(") return cont(pushcontext, pushlex(")"), commasep(pattern, ")"), poplex, expect("=>"), body, popcontext);
383
  else if (type == "variable") return pass(pushcontext, pattern, expect("=>"), body, popcontext);
384
  }
385
 
386
  var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;
387
  if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);
388
  if (type == "function") return cont(functiondef, maybeop);
389
- if (type == "keyword c" || type == "async") return cont(noComma ? maybeexpressionNoComma : maybeexpression);
 
390
  if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeop);
391
  if (type == "operator" || type == "spread") return cont(noComma ? expressionNoComma : expression);
392
  if (type == "[") return cont(pushlex("]"), arrayLiteral, poplex, maybeop);
393
  if (type == "{") return contCommasep(objprop, "}", null, maybeop);
394
  if (type == "quasi") return pass(quasi, maybeop);
395
  if (type == "new") return cont(maybeTarget(noComma));
 
396
  return cont();
397
  }
398
  function maybeexpression(type) {
399
  if (type.match(/[;\}\)\],]/)) return pass();
400
  return pass(expression);
401
  }
402
- function maybeexpressionNoComma(type) {
403
- if (type.match(/[;\}\)\],]/)) return pass();
404
- return pass(expressionNoComma);
405
- }
406
 
407
  function maybeoperatorComma(type, value) {
408
  if (type == ",") return cont(expression);
@@ -413,7 +444,9 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
413
  var expr = noComma == false ? expression : expressionNoComma;
414
  if (type == "=>") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);
415
  if (type == "operator") {
416
- if (/\+\+|--/.test(value)) return cont(me);
 
 
417
  if (value == "?") return cont(expression, expect(":"), expr);
418
  return cont(expr);
419
  }
@@ -422,6 +455,12 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
422
  if (type == "(") return contCommasep(expressionNoComma, ")", "call", me);
423
  if (type == ".") return cont(property, me);
424
  if (type == "[") return cont(pushlex("]"), maybeexpression, expect("]"), poplex, me);
 
 
 
 
 
 
425
  }
426
  function quasi(type, value) {
427
  if (type != "quasi") return pass();
@@ -446,6 +485,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
446
  function maybeTarget(noComma) {
447
  return function(type) {
448
  if (type == ".") return cont(noComma ? targetNoComma : target);
 
449
  else return pass(noComma ? expressionNoComma : expression);
450
  };
451
  }
@@ -463,22 +503,33 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
463
  if (type == "variable") {cx.marked = "property"; return cont();}
464
  }
465
  function objprop(type, value) {
466
- if (type == "async") return cont(objprop);
467
- if (type == "variable" || cx.style == "keyword") {
 
 
468
  cx.marked = "property";
469
  if (value == "get" || value == "set") return cont(getterSetter);
 
 
 
470
  return cont(afterprop);
471
  } else if (type == "number" || type == "string") {
472
  cx.marked = jsonldMode ? "property" : (cx.style + " property");
473
  return cont(afterprop);
474
  } else if (type == "jsonld-keyword") {
475
  return cont(afterprop);
476
- } else if (type == "modifier") {
 
477
  return cont(objprop)
478
  } else if (type == "[") {
479
- return cont(expression, expect("]"), afterprop);
480
  } else if (type == "spread") {
481
- return cont(expression);
 
 
 
 
 
482
  }
483
  }
484
  function getterSetter(type) {
@@ -490,9 +541,9 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
490
  if (type == ":") return cont(expressionNoComma);
491
  if (type == "(") return pass(functiondef);
492
  }
493
- function commasep(what, end) {
494
  function proceed(type, value) {
495
- if (type == ",") {
496
  var lex = cx.state.lexical;
497
  if (lex.info == "call") lex.pos = (lex.pos || 0) + 1;
498
  return cont(function(type, value) {
@@ -517,24 +568,80 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
517
  if (type == "}") return cont();
518
  return pass(statement, block);
519
  }
520
- function maybetype(type) {
521
- if (isTS && type == ":") return cont(typeexpr);
 
 
 
522
  }
523
- function maybedefault(_, value) {
524
- if (value == "=") return cont(expressionNoComma);
 
 
 
525
  }
526
- function typeexpr(type) {
527
- if (type == "variable") {cx.marked = "variable-3"; return cont(afterType);}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
528
  }
529
  function afterType(type, value) {
530
- if (value == "<") return cont(commasep(typeexpr, ">"), afterType)
 
531
  if (type == "[") return cont(expect("]"), afterType)
 
 
 
 
 
 
 
532
  }
533
- function vardef() {
 
 
 
 
534
  return pass(pattern, maybetype, maybeAssign, vardefCont);
535
  }
536
  function pattern(type, value) {
537
- if (type == "modifier") return cont(pattern)
538
  if (type == "variable") { register(value); return cont(); }
539
  if (type == "spread") return cont(pattern);
540
  if (type == "[") return contCommasep(pattern, "]");
@@ -559,7 +666,8 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
559
  function maybeelse(type, value) {
560
  if (type == "keyword b" && value == "else") return cont(pushlex("form", "else"), statement, poplex);
561
  }
562
- function forspec(type) {
 
563
  if (type == "(") return cont(pushlex(")"), forspec1, expect(")"), poplex);
564
  }
565
  function forspec1(type) {
@@ -583,49 +691,73 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
583
  function functiondef(type, value) {
584
  if (value == "*") {cx.marked = "keyword"; return cont(functiondef);}
585
  if (type == "variable") {register(value); return cont(functiondef);}
586
- if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, maybetype, statement, popcontext);
 
587
  }
588
- function funarg(type) {
 
589
  if (type == "spread") return cont(funarg);
590
- return pass(pattern, maybetype, maybedefault);
 
 
 
 
 
 
591
  }
592
  function className(type, value) {
593
  if (type == "variable") {register(value); return cont(classNameAfter);}
594
  }
595
  function classNameAfter(type, value) {
596
- if (value == "extends") return cont(expression, classNameAfter);
 
 
 
 
597
  if (type == "{") return cont(pushlex("}"), classBody, poplex);
598
  }
599
  function classBody(type, value) {
 
 
 
 
 
 
 
600
  if (type == "variable" || cx.style == "keyword") {
601
- if (value == "static") {
602
- cx.marked = "keyword";
603
- return cont(classBody);
604
- }
605
  cx.marked = "property";
606
- if (value == "get" || value == "set") return cont(classGetterSetter, functiondef, classBody);
607
- return cont(functiondef, classBody);
608
  }
 
 
609
  if (value == "*") {
610
  cx.marked = "keyword";
611
  return cont(classBody);
612
  }
613
  if (type == ";") return cont(classBody);
614
  if (type == "}") return cont();
 
615
  }
616
- function classGetterSetter(type) {
617
- if (type != "variable") return pass();
618
- cx.marked = "property";
619
- return cont();
 
620
  }
621
- function afterExport(_type, value) {
622
  if (value == "*") { cx.marked = "keyword"; return cont(maybeFrom, expect(";")); }
623
  if (value == "default") { cx.marked = "keyword"; return cont(expression, expect(";")); }
 
624
  return pass(statement);
625
  }
 
 
 
 
626
  function afterImport(type) {
627
  if (type == "string") return cont();
628
- return pass(importSpec, maybeFrom);
 
629
  }
630
  function importSpec(type, value) {
631
  if (type == "{") return contCommasep(importSpec, "}");
@@ -633,6 +765,9 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
633
  if (value == "*") cx.marked = "keyword";
634
  return cont(maybeAs);
635
  }
 
 
 
636
  function maybeAs(_type, value) {
637
  if (value == "as") { cx.marked = "keyword"; return cont(importSpec); }
638
  }
@@ -641,7 +776,13 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
641
  }
642
  function arrayLiteral(type) {
643
  if (type == "]") return cont();
644
- return pass(expressionNoComma, commasep(expressionNoComma, "]"));
 
 
 
 
 
 
645
  }
646
 
647
  function isContinuedStatement(state, textAfter) {
@@ -650,6 +791,12 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
650
  /[,.]/.test(textAfter.charAt(0));
651
  }
652
 
 
 
 
 
 
 
653
  // Interface
654
 
655
  return {
@@ -660,7 +807,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
660
  cc: [],
661
  lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
662
  localVars: parserConfig.localVars,
663
- context: parserConfig.localVars && {vars: parserConfig.localVars},
664
  indented: basecolumn || 0
665
  };
666
  if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
@@ -685,19 +832,23 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
685
  indent: function(state, textAfter) {
686
  if (state.tokenize == tokenComment) return CodeMirror.Pass;
687
  if (state.tokenize != tokenBase) return 0;
688
- var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;
689
  // Kludge to prevent 'maybelse' from blocking lexical scope pops
690
  if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {
691
  var c = state.cc[i];
692
  if (c == poplex) lexical = lexical.prev;
693
  else if (c != maybeelse) break;
694
  }
695
- if (lexical.type == "stat" && firstChar == "}") lexical = lexical.prev;
 
 
 
 
696
  if (statementIndent && lexical.type == ")" && lexical.prev.type == "stat")
697
  lexical = lexical.prev;
698
  var type = lexical.type, closing = firstChar == type;
699
 
700
- if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info + 1 : 0);
701
  else if (type == "form" && firstChar == "{") return lexical.indented;
702
  else if (type == "form") return lexical.indented + indentUnit;
703
  else if (type == "stat")
@@ -711,6 +862,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
711
  electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
712
  blockCommentStart: jsonMode ? null : "/*",
713
  blockCommentEnd: jsonMode ? null : "*/",
 
714
  lineComment: jsonMode ? null : "//",
715
  fold: "brace",
716
  closeBrackets: "()[]{}''\"\"``",
@@ -720,6 +872,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
720
  jsonMode: jsonMode,
721
 
722
  expressionAllowed: expressionAllowed,
 
723
  skipExpression: function(state) {
724
  var top = state.cc[state.cc.length - 1]
725
  if (top == expression || top == expressionNoComma) state.cc.pop()
1
  // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
  // Distributed under an MIT license: http://codemirror.net/LICENSE
3
 
 
 
4
  (function(mod) {
5
  if (typeof exports == "object" && typeof module == "object") // CommonJS
6
  mod(require("../../lib/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;
23
 
24
  var keywords = function(){
25
  function kw(type) {return {type: type, style: "keyword"};}
26
+ var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c"), D = kw("keyword d");
27
  var operator = kw("operator"), atom = {type: "atom", style: "atom"};
28
 
29
+ return {
30
  "if": kw("if"), "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
31
+ "return": D, "break": D, "continue": D, "new": kw("new"), "delete": C, "void": C, "throw": C,
32
+ "debugger": kw("debugger"), "var": kw("var"), "const": kw("var"), "let": kw("var"),
33
  "function": kw("function"), "catch": kw("catch"),
34
  "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
35
  "in": operator, "typeof": operator, "instanceof": operator,
36
  "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom,
37
  "this": kw("this"), "class": kw("class"), "super": kw("atom"),
38
  "yield": C, "export": kw("export"), "import": kw("import"), "extends": C,
39
+ "await": C
40
  };
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
41
  }();
42
 
43
+ var isOperatorChar = /[+\-*&%=<>!?|~^@]/;
44
  var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/;
45
 
46
  function readRegexp(stream) {
75
  return ret(ch);
76
  } else if (ch == "=" && stream.eat(">")) {
77
  return ret("=>", "operator");
78
+ } else if (ch == "0" && stream.match(/^(?:x[\da-f]+|o[0-7]+|b[01]+)n?/i)) {
 
 
 
 
 
 
 
79
  return ret("number", "number");
80
  } else if (/\d/.test(ch)) {
81
+ stream.match(/^\d*(?:n|(?:\.\d*)?(?:[eE][+\-]?\d+)?)?/);
82
  return ret("number", "number");
83
  } else if (ch == "/") {
84
  if (stream.eat("*")) {
89
  return ret("comment", "comment");
90
  } else if (expressionAllowed(stream, state, 1)) {
91
  readRegexp(stream);
92
+ stream.match(/^\b(([gimyus])(?![gimyus]*\2))+\b/);
93
  return ret("regexp", "string-2");
94
  } else {
95
+ stream.eat("=");
96
  return ret("operator", "operator", stream.current());
97
  }
98
  } else if (ch == "`") {
102
  stream.skipToEnd();
103
  return ret("error", "error");
104
  } else if (isOperatorChar.test(ch)) {
105
+ if (ch != ">" || !state.lexical || state.lexical.type != ">") {
106
+ if (stream.eat("=")) {
107
+ if (ch == "!" || ch == "=") stream.eat("=")
108
+ } else if (/[<>*+\-]/.test(ch)) {
109
+ stream.eat(ch)
110
+ if (ch == ">") stream.eat(ch)
111
+ }
112
+ }
113
  return ret("operator", "operator", stream.current());
114
  } else if (wordRE.test(ch)) {
115
  stream.eatWhile(wordRE);
116
+ var word = stream.current()
117
+ if (state.lastType != ".") {
118
+ if (keywords.propertyIsEnumerable(word)) {
119
+ var kw = keywords[word]
120
+ return ret(kw.type, kw.style, word)
121
+ }
122
+ if (word == "async" && stream.match(/^(\s|\/\*.*?\*\/)*[\[\(\w]/, false))
123
+ return ret("async", "keyword", word)
124
+ }
125
+ return ret("variable", "variable", word)
126
  }
127
  }
128
 
179
  var arrow = stream.string.indexOf("=>", stream.start);
180
  if (arrow < 0) return;
181
 
182
+ if (isTS) { // Try to skip TypeScript return type declarations after the arguments
183
+ var m = /:\s*(?:\w+(?:<[^>]*>|\[\])?|\{[^}]*\})\s*$/.exec(stream.string.slice(stream.start, arrow))
184
+ if (m) arrow = m.index
185
+ }
186
+
187
  var depth = 0, sawSomething = false;
188
  for (var pos = arrow - 1; pos >= 0; --pos) {
189
  var ch = stream.string.charAt(pos);
190
  var bracket = brackets.indexOf(ch);
191
  if (bracket >= 0 && bracket < 3) {
192
  if (!depth) { ++pos; break; }
193
+ if (--depth == 0) { if (ch == "(") sawSomething = true; break; }
194
  } else if (bracket >= 3 && bracket < 6) {
195
  ++depth;
196
  } else if (wordRE.test(ch)) {
258
  pass.apply(null, arguments);
259
  return true;
260
  }
261
+ function inList(name, list) {
262
+ for (var v = list; v; v = v.next) if (v.name == name) return true
263
+ return false;
264
+ }
265
  function register(varname) {
 
 
 
 
 
266
  var state = cx.state;
267
  cx.marked = "def";
268
  if (state.context) {
269
+ if (state.lexical.info == "var" && state.context && state.context.block) {
270
+ // FIXME function decls are also not block scoped
271
+ var newContext = registerVarScoped(varname, state.context)
272
+ if (newContext != null) {
273
+ state.context = newContext
274
+ return
275
+ }
276
+ } else if (!inList(varname, state.localVars)) {
277
+ state.localVars = new Var(varname, state.localVars)
278
+ return
279
+ }
280
+ }
281
+ // Fall through means this is global
282
+ if (parserConfig.globalVars && !inList(varname, state.globalVars))
283
+ state.globalVars = new Var(varname, state.globalVars)
284
+ }
285
+ function registerVarScoped(varname, context) {
286
+ if (!context) {
287
+ return null
288
+ } else if (context.block) {
289
+ var inner = registerVarScoped(varname, context.prev)
290
+ if (!inner) return null
291
+ if (inner == context.prev) return context
292
+ return new Context(inner, context.vars, true)
293
+ } else if (inList(varname, context.vars)) {
294
+ return context
295
  } else {
296
+ return new Context(context.prev, new Var(varname, context.vars), false)
 
 
297
  }
298
  }
299
 
300
+ function isModifier(name) {
301
+ return name == "public" || name == "private" || name == "protected" || name == "abstract" || name == "readonly"
302
+ }
303
+
304
  // Combinators
305
 
306
+ function Context(prev, vars, block) { this.prev = prev; this.vars = vars; this.block = block }
307
+ function Var(name, next) { this.name = name; this.next = next }
308
+
309
+ var defaultVars = new Var("this", new Var("arguments", null))
310
  function pushcontext() {
311
+ cx.state.context = new Context(cx.state.context, cx.state.localVars, false)
312
+ cx.state.localVars = defaultVars
313
+ }
314
+ function pushblockcontext() {
315
+ cx.state.context = new Context(cx.state.context, cx.state.localVars, true)
316
+ cx.state.localVars = null
317
  }
318
  function popcontext() {
319
+ cx.state.localVars = cx.state.context.vars
320
+ cx.state.context = cx.state.context.prev
321
  }
322
+ popcontext.lex = true
323
  function pushlex(type, info) {
324
  var result = function() {
325
  var state = cx.state, indent = state.indented;
351
  }
352
 
353
  function statement(type, value) {
354
+ if (type == "var") return cont(pushlex("vardef", value), vardef, expect(";"), poplex);
355
+ if (type == "keyword a") return cont(pushlex("form"), parenExpr, statement, poplex);
356
  if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
357
+ if (type == "keyword d") return cx.stream.match(/^\s*$/, false) ? cont() : cont(pushlex("stat"), maybeexpression, expect(";"), poplex);
358
+ if (type == "debugger") return cont(expect(";"));
359
+ if (type == "{") return cont(pushlex("}"), pushblockcontext, block, poplex, popcontext);
360
  if (type == ";") return cont();
361
  if (type == "if") {
362
  if (cx.state.lexical.info == "else" && cx.state.cc[cx.state.cc.length - 1] == poplex)
363
  cx.state.cc.pop()();
364
+ return cont(pushlex("form"), parenExpr, statement, poplex, maybeelse);
365
  }
366
  if (type == "function") return cont(functiondef);
367
  if (type == "for") return cont(pushlex("form"), forspec, statement, poplex);
368
+ if (type == "class" || (isTS && value == "interface")) { cx.marked = "keyword"; return cont(pushlex("form"), className, poplex); }
369
+ if (type == "variable") {
370
+ if (isTS && value == "declare") {
371
+ cx.marked = "keyword"
372
+ return cont(statement)
373
+ } else if (isTS && (value == "module" || value == "enum" || value == "type") && cx.stream.match(/^\s*\w/, false)) {
374
+ cx.marked = "keyword"
375
+ if (value == "enum") return cont(enumdef);
376
+ else if (value == "type") return cont(typeexpr, expect("operator"), typeexpr, expect(";"));
377
+ else return cont(pushlex("form"), pattern, expect("{"), pushlex("}"), block, poplex, poplex)
378
+ } else if (isTS && value == "namespace") {
379
+ cx.marked = "keyword"
380
+ return cont(pushlex("form"), expression, block, poplex)
381
+ } else if (isTS && value == "abstract") {
382
+ cx.marked = "keyword"
383
+ return cont(statement)
384
+ } else {
385
+ return cont(pushlex("stat"), maybelabel);
386
+ }
387
+ }
388
+ if (type == "switch") return cont(pushlex("form"), parenExpr, expect("{"), pushlex("}", "switch"), pushblockcontext,
389
+ block, poplex, poplex, popcontext);
390
  if (type == "case") return cont(expression, expect(":"));
391
  if (type == "default") return cont(expect(":"));
392
+ if (type == "catch") return cont(pushlex("form"), pushcontext, maybeCatchBinding, statement, poplex, popcontext);
 
 
393
  if (type == "export") return cont(pushlex("stat"), afterExport, poplex);
394
  if (type == "import") return cont(pushlex("stat"), afterImport, poplex);
 
395
  if (type == "async") return cont(statement)
396
+ if (value == "@") return cont(expression, statement)
397
  return pass(pushlex("stat"), expression, expect(";"), poplex);
398
  }
399
+ function maybeCatchBinding(type) {
400
+ if (type == "(") return cont(funarg, expect(")"))
401
+ }
402
+ function expression(type, value) {
403
+ return expressionInner(type, value, false);
404
  }
405
+ function expressionNoComma(type, value) {
406
+ return expressionInner(type, value, true);
407
  }
408
+ function parenExpr(type) {
409
+ if (type != "(") return pass()
410
+ return cont(pushlex(")"), expression, expect(")"), poplex)
411
+ }
412
+ function expressionInner(type, value, noComma) {
413
  if (cx.state.fatArrowAt == cx.stream.start) {
414
  var body = noComma ? arrowBodyNoComma : arrowBody;
415
+ if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, expect("=>"), body, popcontext);
416
  else if (type == "variable") return pass(pushcontext, pattern, expect("=>"), body, popcontext);
417
  }
418
 
419
  var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;
420
  if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);
421
  if (type == "function") return cont(functiondef, maybeop);
422
+ if (type == "class" || (isTS && value == "interface")) { cx.marked = "keyword"; return cont(pushlex("form"), classExpression, poplex); }
423
+ if (type == "keyword c" || type == "async") return cont(noComma ? expressionNoComma : expression);
424
  if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeop);
425
  if (type == "operator" || type == "spread") return cont(noComma ? expressionNoComma : expression);
426
  if (type == "[") return cont(pushlex("]"), arrayLiteral, poplex, maybeop);
427
  if (type == "{") return contCommasep(objprop, "}", null, maybeop);
428
  if (type == "quasi") return pass(quasi, maybeop);
429
  if (type == "new") return cont(maybeTarget(noComma));
430
+ if (type == "import") return cont(expression);
431
  return cont();
432
  }
433
  function maybeexpression(type) {
434
  if (type.match(/[;\}\)\],]/)) return pass();
435
  return pass(expression);
436
  }
 
 
 
 
437
 
438
  function maybeoperatorComma(type, value) {
439
  if (type == ",") return cont(expression);
444
  var expr = noComma == false ? expression : expressionNoComma;
445
  if (type == "=>") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);
446
  if (type == "operator") {
447
+ if (/\+\+|--/.test(value) || isTS && value == "!") return cont(me);
448
+ if (isTS && value == "<" && cx.stream.match(/^([^>]|<.*?>)*>\s*\(/, false))
449
+ return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, me);
450
  if (value == "?") return cont(expression, expect(":"), expr);
451
  return cont(expr);
452
  }
455
  if (type == "(") return contCommasep(expressionNoComma, ")", "call", me);
456
  if (type == ".") return cont(property, me);
457
  if (type == "[") return cont(pushlex("]"), maybeexpression, expect("]"), poplex, me);
458
+ if (isTS && value == "as") { cx.marked = "keyword"; return cont(typeexpr, me) }
459
+ if (type == "regexp") {
460
+ cx.state.lastType = cx.marked = "operator"
461
+ cx.stream.backUp(cx.stream.pos - cx.stream.start - 1)
462
+ return cont(expr)
463
+ }
464
  }
465
  function quasi(type, value) {
466
  if (type != "quasi") return pass();
485
  function maybeTarget(noComma) {
486
  return function(type) {
487
  if (type == ".") return cont(noComma ? targetNoComma : target);
488
+ else if (type == "variable" && isTS) return cont(maybeTypeArgs, noComma ? maybeoperatorNoComma : maybeoperatorComma)
489
  else return pass(noComma ? expressionNoComma : expression);
490
  };
491
  }
503
  if (type == "variable") {cx.marked = "property"; return cont();}
504
  }
505
  function objprop(type, value) {
506
+ if (type == "async") {
507
+ cx.marked = "property";
508
+ return cont(objprop);
509
+ } else if (type == "variable" || cx.style == "keyword") {
510
  cx.marked = "property";
511
  if (value == "get" || value == "set") return cont(getterSetter);
512
+ var m // Work around fat-arrow-detection complication for detecting typescript typed arrow params
513
+ if (isTS && cx.state.fatArrowAt == cx.stream.start && (m = cx.stream.match(/^\s*:\s*/, false)))
514
+ cx.state.fatArrowAt = cx.stream.pos + m[0].length
515
  return cont(afterprop);
516
  } else if (type == "number" || type == "string") {
517
  cx.marked = jsonldMode ? "property" : (cx.style + " property");
518
  return cont(afterprop);
519
  } else if (type == "jsonld-keyword") {
520
  return cont(afterprop);
521
+ } else if (isTS && isModifier(value)) {
522
+ cx.marked = "keyword"
523
  return cont(objprop)
524
  } else if (type == "[") {
525
+ return cont(expression, maybetype, expect("]"), afterprop);
526
  } else if (type == "spread") {
527
+ return cont(expressionNoComma, afterprop);
528
+ } else if (value == "*") {
529
+ cx.marked = "keyword";
530
+ return cont(objprop);
531
+ } else if (type == ":") {
532
+ return pass(afterprop)
533
  }
534
  }
535
  function getterSetter(type) {
541
  if (type == ":") return cont(expressionNoComma);
542
  if (type == "(") return pass(functiondef);
543
  }
544
+ function commasep(what, end, sep) {
545
  function proceed(type, value) {
546
+ if (sep ? sep.indexOf(type) > -1 : type == ",") {
547
  var lex = cx.state.lexical;
548
  if (lex.info == "call") lex.pos = (lex.pos || 0) + 1;
549
  return cont(function(type, value) {
568
  if (type == "}") return cont();
569
  return pass(statement, block);
570
  }
571
+ function maybetype(type, value) {
572
+ if (isTS) {
573
+ if (type == ":") return cont(typeexpr);
574
+ if (value == "?") return cont(maybetype);
575
+ }
576
  }
577
+ function mayberettype(type) {
578
+ if (isTS && type == ":") {
579
+ if (cx.stream.match(/^\s*\w+\s+is\b/, false)) return cont(expression, isKW, typeexpr)
580
+ else return cont(typeexpr)
581
+ }
582
  }
583
+ function isKW(_, value) {
584
+ if (value == "is") {
585
+ cx.marked = "keyword"
586
+ return cont()
587
+ }
588
+ }
589
+ function typeexpr(type, value) {
590
+ if (value == "keyof" || value == "typeof") {
591
+ cx.marked = "keyword"
592
+ return cont(value == "keyof" ? typeexpr : expressionNoComma)
593
+ }
594
+ if (type == "variable" || value == "void") {
595
+ cx.marked = "type"
596
+ return cont(afterType)
597
+ }
598
+ if (type == "string" || type == "number" || type == "atom") return cont(afterType);
599
+ if (type == "[") return cont(pushlex("]"), commasep(typeexpr, "]", ","), poplex, afterType)
600
+ if (type == "{") return cont(pushlex("}"), commasep(typeprop, "}", ",;"), poplex, afterType)
601
+ if (type == "(") return cont(commasep(typearg, ")"), maybeReturnType)
602
+ if (type == "<") return cont(commasep(typeexpr, ">"), typeexpr)
603
+ }
604
+ function maybeReturnType(type) {
605
+ if (type == "=>") return cont(typeexpr)
606
+ }
607
+ function typeprop(type, value) {
608
+ if (type == "variable" || cx.style == "keyword") {
609
+ cx.marked = "property"
610
+ return cont(typeprop)
611
+ } else if (value == "?") {
612
+ return cont(typeprop)
613
+ } else if (type == ":") {
614
+ return cont(typeexpr)
615
+ } else if (type == "[") {
616
+ return cont(expression, maybetype, expect("]"), typeprop)
617
+ }
618
+ }
619
+ function typearg(type, value) {
620
+ if (type == "variable" && cx.stream.match(/^\s*[?:]/, false) || value == "?") return cont(typearg)
621
+ if (type == ":") return cont(typeexpr)
622
+ return pass(typeexpr)
623
  }
624
  function afterType(type, value) {
625
+ if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
626
+ if (value == "|" || type == "." || value == "&") return cont(typeexpr)
627
  if (type == "[") return cont(expect("]"), afterType)
628
+ if (value == "extends" || value == "implements") { cx.marked = "keyword"; return cont(typeexpr) }
629
+ }
630
+ function maybeTypeArgs(_, value) {
631
+ if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
632
+ }
633
+ function typeparam() {
634
+ return pass(typeexpr, maybeTypeDefault)
635
  }
636
+ function maybeTypeDefault(_, value) {
637
+ if (value == "=") return cont(typeexpr)
638
+ }
639
+ function vardef(_, value) {
640
+ if (value == "enum") {cx.marked = "keyword"; return cont(enumdef)}
641
  return pass(pattern, maybetype, maybeAssign, vardefCont);
642
  }
643
  function pattern(type, value) {
644
+ if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(pattern) }
645
  if (type == "variable") { register(value); return cont(); }
646
  if (type == "spread") return cont(pattern);
647
  if (type == "[") return contCommasep(pattern, "]");
666
  function maybeelse(type, value) {
667
  if (type == "keyword b" && value == "else") return cont(pushlex("form", "else"), statement, poplex);
668
  }
669
+ function forspec(type, value) {
670
+ if (value == "await") return cont(forspec);
671
  if (type == "(") return cont(pushlex(")"), forspec1, expect(")"), poplex);
672
  }
673
  function forspec1(type) {
691
  function functiondef(type, value) {
692
  if (value == "*") {cx.marked = "keyword"; return cont(functiondef);}
693
  if (type == "variable") {register(value); return cont(functiondef);}
694
+ if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, statement, popcontext);
695
+ if (isTS && value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, functiondef)
696
  }
697
+ function funarg(type, value) {
698
+ if (value == "@") cont(expression, funarg)
699
  if (type == "spread") return cont(funarg);
700
+ if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(funarg); }
701
+ return pass(pattern, maybetype, maybeAssign);
702
+ }
703
+ function classExpression(type, value) {
704
+ // Class expressions may have an optional name.
705
+ if (type == "variable") return className(type, value);
706
+ return classNameAfter(type, value);
707
  }
708
  function className(type, value) {
709
  if (type == "variable") {register(value); return cont(classNameAfter);}
710
  }
711
  function classNameAfter(type, value) {
712
+ if (value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, classNameAfter)
713
+ if (value == "extends" || value == "implements" || (isTS && type == ",")) {
714
+ if (value == "implements") cx.marked = "keyword";
715
+ return cont(isTS ? typeexpr : expression, classNameAfter);
716
+ }
717
  if (type == "{") return cont(pushlex("}"), classBody, poplex);
718
  }
719
  function classBody(type, value) {
720
+ if (type == "async" ||
721
+ (type == "variable" &&
722
+ (value == "static" || value == "get" || value == "set" || (isTS && isModifier(value))) &&
723
+ cx.stream.match(/^\s+[\w$\xa1-\uffff]/, false))) {
724
+ cx.marked = "keyword";
725
+ return cont(classBody);
726
+ }
727
  if (type == "variable" || cx.style == "keyword") {
 
 
 
 
728
  cx.marked = "property";
729
+ return cont(isTS ? classfield : functiondef, classBody);
 
730
  }
731
+ if (type == "[")
732
+ return cont(expression, maybetype, expect("]"), isTS ? classfield : functiondef, classBody)
733
  if (value == "*") {
734
  cx.marked = "keyword";
735
  return cont(classBody);
736
  }
737
  if (type == ";") return cont(classBody);
738
  if (type == "}") return cont();
739
+ if (value == "@") return cont(expression, classBody)
740
  }
741
+ function classfield(type, value) {
742
+ if (value == "?") return cont(classfield)
743
+ if (type == ":") return cont(typeexpr, maybeAssign)
744
+ if (value == "=") return cont(expressionNoComma)
745
+ return pass(functiondef)
746
  }
747
+ function afterExport(type, value) {
748
  if (value == "*") { cx.marked = "keyword"; return cont(maybeFrom, expect(";")); }
749
  if (value == "default") { cx.marked = "keyword"; return cont(expression, expect(";")); }
750
+ if (type == "{") return cont(commasep(exportField, "}"), maybeFrom, expect(";"));
751
  return pass(statement);
752
  }
753
+ function exportField(type, value) {
754
+ if (value == "as") { cx.marked = "keyword"; return cont(expect("variable")); }
755
+ if (type == "variable") return pass(expressionNoComma, exportField);
756
+ }
757
  function afterImport(type) {
758
  if (type == "string") return cont();
759
+ if (type == "(") return pass(expression);
760
+ return pass(importSpec, maybeMoreImports, maybeFrom);
761
  }
762
  function importSpec(type, value) {
763
  if (type == "{") return contCommasep(importSpec, "}");
765
  if (value == "*") cx.marked = "keyword";
766
  return cont(maybeAs);
767
  }
768
+ function maybeMoreImports(type) {
769
+ if (type == ",") return cont(importSpec, maybeMoreImports)
770
+ }
771
  function maybeAs(_type, value) {
772
  if (value == "as") { cx.marked = "keyword"; return cont(importSpec); }
773
  }
776
  }
777
  function arrayLiteral(type) {
778
  if (type == "]") return cont();
779
+ return pass(commasep(expressionNoComma, "]"));
780
+ }
781
+ function enumdef() {
782
+ return pass(pushlex("form"), pattern, expect("{"), pushlex("}"), commasep(enummember, "}"), poplex, poplex)
783
+ }
784
+ function enummember() {
785
+ return pass(pattern, maybeAssign);
786
  }
787
 
788
  function isContinuedStatement(state, textAfter) {
791
  /[,.]/.test(textAfter.charAt(0));
792
  }
793
 
794
+ function expressionAllowed(stream, state, backUp) {
795
+ return state.tokenize == tokenBase &&
796
+ /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
797
+ (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
798
+ }
799
+
800
  // Interface
801
 
802
  return {
807
  cc: [],
808
  lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
809
  localVars: parserConfig.localVars,
810
+ context: parserConfig.localVars && new Context(null, null, false),
811
  indented: basecolumn || 0
812
  };
813
  if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
832
  indent: function(state, textAfter) {
833
  if (state.tokenize == tokenComment) return CodeMirror.Pass;
834
  if (state.tokenize != tokenBase) return 0;
835
+ var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top
836
  // Kludge to prevent 'maybelse' from blocking lexical scope pops
837
  if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {
838
  var c = state.cc[i];
839
  if (c == poplex) lexical = lexical.prev;
840
  else if (c != maybeelse) break;
841
  }
842
+ while ((lexical.type == "stat" || lexical.type == "form") &&
843
+ (firstChar == "}" || ((top = state.cc[state.cc.length - 1]) &&
844
+ (top == maybeoperatorComma || top == maybeoperatorNoComma) &&
845
+ !/^[,\.=+\-*:?[\(]/.test(textAfter))))
846
+ lexical = lexical.prev;
847
  if (statementIndent && lexical.type == ")" && lexical.prev.type == "stat")
848
  lexical = lexical.prev;
849
  var type = lexical.type, closing = firstChar == type;
850
 
851
+ if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info.length + 1 : 0);
852
  else if (type == "form" && firstChar == "{") return lexical.indented;
853
  else if (type == "form") return lexical.indented + indentUnit;
854
  else if (type == "stat")
862
  electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
863
  blockCommentStart: jsonMode ? null : "/*",
864
  blockCommentEnd: jsonMode ? null : "*/",
865
+ blockCommentContinue: jsonMode ? null : " * ",
866
  lineComment: jsonMode ? null : "//",
867
  fold: "brace",
868
  closeBrackets: "()[]{}''\"\"``",
872
  jsonMode: jsonMode,
873
 
874
  expressionAllowed: expressionAllowed,
875
+
876
  skipExpression: function(state) {
877
  var top = state.cc[state.cc.length - 1]
878
  if (top == expression || top == expressionNoComma) state.cc.pop()
inc/lib/codemirror/mode/javascript/json-ld.html ADDED
@@ -0,0 +1,72 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: JSON-LD mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <script src="../../lib/codemirror.js"></script>
9
+ <script src="../../addon/edit/matchbrackets.js"></script>
10
+ <script src="../../addon/comment/continuecomment.js"></script>
11
+ <script src="../../addon/comment/comment.js"></script>
12
+ <script src="javascript.js"></script>
13
+ <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
14
+ <div id="nav">
15
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"/></a>
16
+
17
+ <ul>
18
+ <li><a href="../../index.html">Home</a>
19
+ <li><a href="../../doc/manual.html">Manual</a>
20
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
21
+ </ul>
22
+ <ul>
23
+ <li><a href="../index.html">Language modes</a>
24
+ <li><a class=active href="#">JSON-LD</a>
25
+ </ul>
26
+ </div>
27
+
28
+ <article>
29
+ <h2>JSON-LD mode</h2>
30
+
31
+
32
+ <div><textarea id="code" name="code">
33
+ {
34
+ "@context": {
35
+ "name": "http://schema.org/name",
36
+ "description": "http://schema.org/description",
37
+ "image": {
38
+ "@id": "http://schema.org/image",
39
+ "@type": "@id"
40
+ },
41
+ "geo": "http://schema.org/geo",
42
+ "latitude": {
43
+ "@id": "http://schema.org/latitude",
44
+ "@type": "xsd:float"
45
+ },
46
+ "longitude": {
47
+ "@id": "http://schema.org/longitude",
48
+ "@type": "xsd:float"
49
+ },
50
+ "xsd": "http://www.w3.org/2001/XMLSchema#"
51
+ },
52
+ "name": "The Empire State Building",
53
+ "description": "The Empire State Building is a 102-story landmark in New York City.",
54
+ "image": "http://www.civil.usherbrooke.ca/cours/gci215a/empire-state-building.jpg",
55
+ "geo": {
56
+ "latitude": "40.75",
57
+ "longitude": "73.98"
58
+ }
59
+ }
60
+ </textarea></div>
61
+
62
+ <script>
63
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
64
+ matchBrackets: true,
65
+ autoCloseBrackets: true,
66
+ mode: "application/ld+json",
67
+ lineWrapping: true
68
+ });
69
+ </script>
70
+
71
+ <p>This is a specialization of the <a href="index.html">JavaScript mode</a>.</p>
72
+ </article>
inc/lib/codemirror/mode/javascript/test.js ADDED
@@ -0,0 +1,482 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://codemirror.net/LICENSE
3
+
4
+ (function() {
5
+ var mode = CodeMirror.getMode({indentUnit: 2}, "javascript");
6
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
7
+
8
+ MT("locals",
9
+ "[keyword function] [def foo]([def a], [def b]) { [keyword var] [def c] [operator =] [number 10]; [keyword return] [variable-2 a] [operator +] [variable-2 c] [operator +] [variable d]; }");
10
+
11
+ MT("comma-and-binop",
12
+ "[keyword function](){ [keyword var] [def x] [operator =] [number 1] [operator +] [number 2], [def y]; }");
13
+
14
+ MT("destructuring",
15
+ "([keyword function]([def a], [[[def b], [def c] ]]) {",
16
+ " [keyword let] {[def d], [property foo]: [def c][operator =][number 10], [def x]} [operator =] [variable foo]([variable-2 a]);",
17
+ " [[[variable-2 c], [variable y] ]] [operator =] [variable-2 c];",
18
+ "})();");
19
+
20
+ MT("destructure_trailing_comma",
21
+ "[keyword let] {[def a], [def b],} [operator =] [variable foo];",
22
+ "[keyword let] [def c];"); // Parser still in good state?
23
+
24
+ MT("class_body",
25
+ "[keyword class] [def Foo] {",
26
+ " [property constructor]() {}",
27
+ " [property sayName]() {",
28
+ " [keyword return] [string-2 `foo${][variable foo][string-2 }oo`];",
29
+ " }",
30
+ "}");
31
+
32
+ MT("class",
33
+ "[keyword class] [def Point] [keyword extends] [variable SuperThing] {",
34
+ " [keyword get] [property prop]() { [keyword return] [number 24]; }",
35
+ " [property constructor]([def x], [def y]) {",
36
+ " [keyword super]([string 'something']);",
37
+ " [keyword this].[property x] [operator =] [variable-2 x];",
38
+ " }",
39
+ "}");
40
+
41
+ MT("anonymous_class_expression",
42
+ "[keyword const] [def Adder] [operator =] [keyword class] [keyword extends] [variable Arithmetic] {",
43
+ " [property add]([def a], [def b]) {}",
44
+ "};");
45
+
46
+ MT("named_class_expression",
47
+ "[keyword const] [def Subber] [operator =] [keyword class] [def Subtract] {",
48
+ " [property sub]([def a], [def b]) {}",
49
+ "};");
50
+
51
+ MT("class_async_method",
52
+ "[keyword class] [def Foo] {",
53
+ " [property sayName1]() {}",
54
+ " [keyword async] [property sayName2]() {}",
55
+ "}");
56
+
57
+ MT("import",
58
+ "[keyword function] [def foo]() {",
59
+ " [keyword import] [def $] [keyword from] [string 'jquery'];",
60
+ " [keyword import] { [def encrypt], [def decrypt] } [keyword from] [string 'crypto'];",
61
+ "}");
62
+
63
+ MT("import_trailing_comma",
64
+ "[keyword import] {[def foo], [def bar],} [keyword from] [string 'baz']")
65
+
66
+ MT("import_dynamic",
67
+ "[keyword import]([string 'baz']).[property then]")
68
+
69
+ MT("import_dynamic",
70
+ "[keyword const] [def t] [operator =] [keyword import]([string 'baz']).[property then]")
71
+
72
+ MT("const",
73
+ "[keyword function] [def f]() {",
74
+ " [keyword const] [[ [def a], [def b] ]] [operator =] [[ [number 1], [number 2] ]];",
75
+ "}");
76
+
77
+ MT("for/of",
78
+ "[keyword for]([keyword let] [def of] [keyword of] [variable something]) {}");
79
+
80
+ MT("for await",
81
+ "[keyword for] [keyword await]([keyword let] [def of] [keyword of] [variable something]) {}");
82
+
83
+ MT("generator",
84
+ "[keyword function*] [def repeat]([def n]) {",
85
+ " [keyword for]([keyword var] [def i] [operator =] [number 0]; [variable-2 i] [operator <] [variable-2 n]; [operator ++][variable-2 i])",
86
+ " [keyword yield] [variable-2 i];",
87
+ "}");
88
+
89
+ MT("let_scoping",
90
+ "[keyword function] [def scoped]([def n]) {",
91
+ " { [keyword var] [def i]; } [variable-2 i];",
92
+ " { [keyword let] [def j]; [variable-2 j]; } [variable j];",
93
+ " [keyword if] ([atom true]) { [keyword const] [def k]; [variable-2 k]; } [variable k];",
94
+ "}");
95
+
96
+ MT("switch_scoping",
97
+ "[keyword switch] ([variable x]) {",
98
+ " [keyword default]:",
99
+ " [keyword let] [def j];",
100
+ " [keyword return] [variable-2 j]",
101
+ "}",
102
+ "[variable j];")
103
+
104
+ MT("leaving_scope",
105
+ "[keyword function] [def a]() {",
106
+ " {",
107
+ " [keyword const] [def x] [operator =] [number 1]",
108
+ " [keyword if] ([atom true]) {",
109
+ " [keyword let] [def y] [operator =] [number 2]",
110
+ " [keyword var] [def z] [operator =] [number 3]",
111
+ " [variable console].[property log]([variable-2 x], [variable-2 y], [variable-2 z])",
112
+ " }",
113
+ " [variable console].[property log]([variable-2 x], [variable y], [variable-2 z])",
114
+ " }",
115
+ " [variable console].[property log]([variable x], [variable y], [variable-2 z])",
116
+ "}")
117
+
118
+ MT("quotedStringAddition",
119
+ "[keyword let] [def f] [operator =] [variable a] [operator +] [string 'fatarrow'] [operator +] [variable c];");
120
+
121
+ MT("quotedFatArrow",
122
+ "[keyword let] [def f] [operator =] [variable a] [operator +] [string '=>'] [operator +] [variable c];");
123
+
124
+ MT("fatArrow",
125
+ "[variable array].[property filter]([def a] [operator =>] [variable-2 a] [operator +] [number 1]);",
126
+ "[variable a];", // No longer in scope
127
+ "[keyword let] [def f] [operator =] ([[ [def a], [def b] ]], [def c]) [operator =>] [variable-2 a] [operator +] [variable-2 c];",
128
+ "[variable c];");
129
+
130
+ MT("spread",
131
+ "[keyword function] [def f]([def a], [meta ...][def b]) {",
132
+ " [variable something]([variable-2 a], [meta ...][variable-2 b]);",
133
+ "}");
134
+
135
+ MT("quasi",
136
+ "[variable re][string-2 `fofdlakj${][variable x] [operator +] ([variable re][string-2 `foo`]) [operator +] [number 1][string-2 }fdsa`] [operator +] [number 2]");
137
+
138
+ MT("quasi_no_function",
139
+ "[variable x] [operator =] [string-2 `fofdlakj${][variable x] [operator +] [string-2 `foo`] [operator +] [number 1][string-2 }fdsa`] [operator +] [number 2]");
140
+
141
+ MT("indent_statement",
142
+ "[keyword var] [def x] [operator =] [number 10]",
143
+ "[variable x] [operator +=] [variable y] [operator +]",
144
+ " [atom Infinity]",
145
+ "[keyword debugger];");
146
+
147
+ MT("indent_if",
148
+ "[keyword if] ([number 1])",
149
+ " [keyword break];",
150
+ "[keyword else] [keyword if] ([number 2])",
151
+ " [keyword continue];",
152
+ "[keyword else]",
153
+ " [number 10];",
154
+ "[keyword if] ([number 1]) {",
155
+ " [keyword break];",
156
+ "} [keyword else] [keyword if] ([number 2]) {",
157
+ " [keyword continue];",
158
+ "} [keyword else] {",
159
+ " [number 10];",
160
+ "}");
161
+
162
+ MT("indent_for",
163
+ "[keyword for] ([keyword var] [def i] [operator =] [number 0];",
164
+ " [variable i] [operator <] [number 100];",
165
+ " [variable i][operator ++])",
166
+ " [variable doSomething]([variable i]);",
167
+ "[keyword debugger];");
168
+
169
+ MT("indent_c_style",
170
+ "[keyword function] [def foo]()",
171
+ "{",
172
+ " [keyword debugger];",
173
+ "}");
174
+
175
+ MT("indent_else",
176
+ "[keyword for] (;;)",
177
+ " [keyword if] ([variable foo])",
178
+ " [keyword if] ([variable bar])",
179
+ " [number 1];",
180
+ " [keyword else]",
181
+ " [number 2];",
182
+ " [keyword else]",
183
+ " [number 3];");
184
+
185
+ MT("indent_funarg",
186
+ "[variable foo]([number 10000],",
187
+ " [keyword function]([def a]) {",
188
+ " [keyword debugger];",
189
+ "};");
190
+
191
+ MT("indent_below_if",
192
+ "[keyword for] (;;)",
193
+ " [keyword if] ([variable foo])",
194
+ " [number 1];",
195
+ "[number 2];");
196
+
197
+ MT("indent_semicolonless_if",
198
+ "[keyword function] [def foo]() {",
199
+ " [keyword if] ([variable x])",
200
+ " [variable foo]()",
201
+ "}")
202
+
203
+ MT("indent_semicolonless_if_with_statement",
204
+ "[keyword function] [def foo]() {",
205
+ " [keyword if] ([variable x])",
206
+ " [variable foo]()",
207
+ " [variable bar]()",
208
+ "}")
209
+
210
+ MT("multilinestring",
211
+ "[keyword var] [def x] [operator =] [string 'foo\\]",
212
+ "[string bar'];");
213
+
214
+ MT("scary_regexp",
215
+ "[string-2 /foo[[/]]bar/];");
216
+
217
+ MT("indent_strange_array",
218
+ "[keyword var] [def x] [operator =] [[",
219
+ " [number 1],,",
220
+ " [number 2],",
221
+ "]];",
222
+ "[number 10];");
223
+
224
+ MT("param_default",
225
+ "[keyword function] [def foo]([def x] [operator =] [string-2 `foo${][number 10][string-2 }bar`]) {",
226
+ " [keyword return] [variable-2 x];",
227
+ "}");
228
+
229
+ MT("new_target",
230
+ "[keyword function] [def F]([def target]) {",
231
+ " [keyword if] ([variable-2 target] [operator &&] [keyword new].[keyword target].[property name]) {",
232
+ " [keyword return] [keyword new]",
233
+ " .[keyword target];",
234
+ " }",
235
+ "}");
236
+
237
+ MT("async",
238
+ "[keyword async] [keyword function] [def foo]([def args]) { [keyword return] [atom true]; }");
239
+
240
+ MT("async_assignment",
241
+ "[keyword const] [def foo] [operator =] [keyword async] [keyword function] ([def args]) { [keyword return] [atom true]; };");
242
+
243
+ MT("async_object",
244
+ "[keyword let] [def obj] [operator =] { [property async]: [atom false] };");
245
+
246
+ // async be highlighet as keyword and foo as def, but it requires potentially expensive look-ahead. See #4173
247
+ MT("async_object_function",
248
+ "[keyword let] [def obj] [operator =] { [property async] [property foo]([def args]) { [keyword return] [atom true]; } };");
249
+
250
+ MT("async_object_properties",
251
+ "[keyword let] [def obj] [operator =] {",
252
+ " [property prop1]: [keyword async] [keyword function] ([def args]) { [keyword return] [atom true]; },",
253
+ " [property prop2]: [keyword async] [keyword function] ([def args]) { [keyword return] [atom true]; },",
254
+ " [property prop3]: [keyword async] [keyword function] [def prop3]([def args]) { [keyword return] [atom true]; },",
255
+ "};");
256
+
257
+ MT("async_arrow",
258
+ "[keyword const] [def foo] [operator =] [keyword async] ([def args]) [operator =>] { [keyword return] [atom true]; };");
259
+
260
+ MT("async_jquery",
261
+ "[variable $].[property ajax]({",
262
+ " [property url]: [variable url],",
263
+ " [property async]: [atom true],",
264
+ " [property method]: [string 'GET']",
265
+ "});");
266
+
267
+ MT("async_variable",
268
+ "[keyword const] [def async] [operator =] {[property a]: [number 1]};",
269
+ "[keyword const] [def foo] [operator =] [string-2 `bar ${][variable async].[property a][string-2 }`];")
270
+
271
+ MT("bigint", "[number 1n] [operator +] [number 0x1afn] [operator +] [number 0o064n] [operator +] [number 0b100n];")
272
+
273
+ MT("async_comment",
274
+ "[keyword async] [comment /**/] [keyword function] [def foo]([def args]) { [keyword return] [atom true]; }");
275
+
276
+ MT("indent_switch",
277
+ "[keyword switch] ([variable x]) {",
278
+ " [keyword default]:",
279
+ " [keyword return] [number 2]",
280
+ "}")
281
+
282
+ MT("regexp_corner_case",
283
+ "[operator +]{} [operator /] [atom undefined];",
284
+ "[[[meta ...][string-2 /\\//] ]];",
285
+ "[keyword void] [string-2 /\\//];",
286
+ "[keyword do] [string-2 /\\//]; [keyword while] ([number 0]);",
287
+ "[keyword if] ([number 0]) {} [keyword else] [string-2 /\\//];",
288
+ "[string-2 `${][variable async][operator ++][string-2 }//`];",
289
+ "[string-2 `${]{} [operator /] [string-2 /\\//}`];")
290
+
291
+ MT("return_eol",
292
+ "[keyword return]",
293
+ "{} [string-2 /5/]")
294
+
295
+ var ts_mode = CodeMirror.getMode({indentUnit: 2}, "application/typescript")
296
+ function TS(name) {
297
+ test.mode(name, ts_mode, Array.prototype.slice.call(arguments, 1))
298
+ }
299
+
300
+ TS("typescript_extend_type",
301
+ "[keyword class] [def Foo] [keyword extends] [type Some][operator <][type Type][operator >] {}")
302
+
303
+ TS("typescript_arrow_type",
304
+ "[keyword let] [def x]: ([variable arg]: [type Type]) [operator =>] [type ReturnType]")
305
+
306
+ TS("typescript_class",
307
+ "[keyword class] [def Foo] {",
308
+ " [keyword public] [keyword static] [property main]() {}",
309
+ " [keyword private] [property _foo]: [type string];",
310
+ "}")
311
+
312
+ TS("typescript_literal_types",
313
+ "[keyword import] [keyword *] [keyword as] [def Sequelize] [keyword from] [string 'sequelize'];",
314
+ "[keyword interface] [def MyAttributes] {",
315
+ " [property truthy]: [string 'true'] [operator |] [number 1] [operator |] [atom true];",
316
+ " [property falsy]: [string 'false'] [operator |] [number 0] [operator |] [atom false];",
317
+ "}",
318
+ "[keyword interface] [def MyInstance] [keyword extends] [type Sequelize].[type Instance] [operator <] [type MyAttributes] [operator >] {",
319
+ " [property rawAttributes]: [type MyAttributes];",
320
+ " [property truthy]: [string 'true'] [operator |] [number 1] [operator |] [atom true];",
321
+ " [property falsy]: [string 'false'] [operator |] [number 0] [operator |] [atom false];",
322
+ "}")
323
+
324
+ TS("typescript_extend_operators",
325
+ "[keyword export] [keyword interface] [def UserModel] [keyword extends]",
326
+ " [type Sequelize].[type Model] [operator <] [type UserInstance], [type UserAttributes] [operator >] {",
327
+ " [property findById]: (",
328
+ " [variable userId]: [type number]",
329
+ " ) [operator =>] [type Promise] [operator <] [type Array] [operator <] { [property id], [property name] } [operator >>];",
330
+ " [property updateById]: (",
331
+ " [variable userId]: [type number],",
332
+ " [variable isActive]: [type boolean]",
333
+ " ) [operator =>] [type Promise] [operator <] [type AccountHolderNotificationPreferenceInstance] [operator >];",
334
+ " }")
335
+
336
+ TS("typescript_interface_with_const",
337
+ "[keyword const] [def hello]: {",
338
+ " [property prop1][operator ?]: [type string];",
339
+ " [property prop2][operator ?]: [type string];",
340
+ "} [operator =] {};")
341
+
342
+ TS("typescript_double_extend",
343
+ "[keyword export] [keyword interface] [def UserAttributes] {",
344
+ " [property id][operator ?]: [type number];",
345
+ " [property createdAt][operator ?]: [type Date];",
346
+ "}",
347
+ "[keyword export] [keyword interface] [def UserInstance] [keyword extends] [type Sequelize].[type Instance][operator <][type UserAttributes][operator >], [type UserAttributes] {",
348
+ " [property id]: [type number];",
349
+ " [property createdAt]: [type Date];",
350
+ "}");
351
+
352
+ TS("typescript_index_signature",
353
+ "[keyword interface] [def A] {",
354
+ " [[ [variable prop]: [type string] ]]: [type any];",
355
+ " [property prop1]: [type any];",
356
+ "}");
357
+
358
+ TS("typescript_generic_class",
359
+ "[keyword class] [def Foo][operator <][type T][operator >] {",
360
+ " [property bar]() {}",
361
+ " [property foo](): [type Foo] {}",
362
+ "}")
363
+
364
+ TS("typescript_type_when_keyword",
365
+ "[keyword export] [keyword type] [type AB] [operator =] [type A] [operator |] [type B];",
366
+ "[keyword type] [type Flags] [operator =] {",
367
+ " [property p1]: [type string];",
368
+ " [property p2]: [type boolean];",
369
+ "};")
370
+
371
+ TS("typescript_type_when_not_keyword",
372
+ "[keyword class] [def HasType] {",
373
+ " [property type]: [type string];",
374
+ " [property constructor]([def type]: [type string]) {",
375
+ " [keyword this].[property type] [operator =] [variable-2 type];",
376
+ " }",
377
+ " [property setType]({ [def type] }: { [property type]: [type string]; }) {",
378
+ " [keyword this].[property type] [operator =] [variable-2 type];",
379
+ " }",
380
+ "}")
381
+
382
+ TS("typescript_function_generics",
383
+ "[keyword function] [def a]() {}",
384
+ "[keyword function] [def b][operator <][type IA] [keyword extends] [type object], [type IB] [keyword extends] [type object][operator >]() {}",
385
+ "[keyword function] [def c]() {}")
386
+
387
+ TS("typescript_complex_return_type",
388
+ "[keyword function] [def A]() {",
389
+ " [keyword return] [keyword this].[property property];",
390
+ "}",
391
+ "[keyword function] [def B](): [type Promise][operator <]{ [[ [variable key]: [type string] ]]: [type any] } [operator |] [atom null][operator >] {",
392
+ " [keyword return] [keyword this].[property property];",
393
+ "}")
394
+
395
+ TS("typescript_complex_type_casting",
396
+ "[keyword const] [def giftpay] [operator =] [variable config].[property get]([string 'giftpay']) [keyword as] { [[ [variable platformUuid]: [type string] ]]: { [property version]: [type number]; [property apiCode]: [type string]; } };")
397
+
398
+ TS("typescript_keyof",
399
+ "[keyword function] [def x][operator <][type T] [keyword extends] [keyword keyof] [type X][operator >]([def a]: [type T]) {",
400
+ " [keyword return]")
401
+
402
+ TS("typescript_new_typeargs",
403
+ "[keyword let] [def x] [operator =] [keyword new] [variable Map][operator <][type string], [type Date][operator >]([string-2 `foo${][variable bar][string-2 }`])")
404
+
405
+ TS("modifiers",
406
+ "[keyword class] [def Foo] {",
407
+ " [keyword public] [keyword abstract] [property bar]() {}",
408
+ " [property constructor]([keyword readonly] [keyword private] [def x]) {}",
409
+ "}")
410
+
411
+ TS("arrow prop",
412
+ "({[property a]: [def p] [operator =>] [variable-2 p]})")
413
+
414
+ TS("generic in function call",
415
+ "[keyword this].[property a][operator <][type Type][operator >]([variable foo]);",
416
+ "[keyword this].[property a][operator <][variable Type][operator >][variable foo];")
417
+
418
+ TS("type guard",
419
+ "[keyword class] [def Appler] {",
420
+ " [keyword static] [property assertApple]([def fruit]: [type Fruit]): [variable-2 fruit] [keyword is] [type Apple] {",
421
+ " [keyword if] ([operator !]([variable-2 fruit] [keyword instanceof] [variable Apple]))",
422
+ " [keyword throw] [keyword new] [variable Error]();",
423
+ " }",
424
+ "}")
425
+
426
+ TS("type as variable",
427
+ "[variable type] [operator =] [variable x] [keyword as] [type Bar];");
428
+
429
+ TS("enum body",
430
+ "[keyword export] [keyword const] [keyword enum] [def CodeInspectionResultType] {",
431
+ " [def ERROR] [operator =] [string 'problem_type_error'],",
432
+ " [def WARNING] [operator =] [string 'problem_type_warning'],",
433
+ " [def META],",
434
+ "}")
435
+
436
+ TS("parenthesized type",
437
+ "[keyword class] [def Foo] {",
438
+ " [property x] [operator =] [keyword new] [variable A][operator <][type B], [type string][operator |](() [operator =>] [type void])[operator >]();",
439
+ " [keyword private] [property bar]();",
440
+ "}")
441
+
442
+ TS("abstract class",
443
+ "[keyword export] [keyword abstract] [keyword class] [def Foo] {}")
444
+
445
+ var jsonld_mode = CodeMirror.getMode(
446
+ {indentUnit: 2},
447
+ {name: "javascript", jsonld: true}
448
+ );
449
+ function LD(name) {
450
+ test.mode(name, jsonld_mode, Array.prototype.slice.call(arguments, 1));
451
+ }
452
+
453
+ LD("json_ld_keywords",
454
+ '{',
455
+ ' [meta "@context"]: {',
456
+ ' [meta "@base"]: [string "http://example.com"],',
457
+ ' [meta "@vocab"]: [string "http://xmlns.com/foaf/0.1/"],',
458
+ ' [property "likesFlavor"]: {',
459
+ ' [meta "@container"]: [meta "@list"]',
460
+ ' [meta "@reverse"]: [string "@beFavoriteOf"]',
461
+ ' },',
462
+ ' [property "nick"]: { [meta "@container"]: [meta "@set"] },',
463
+ ' [property "nick"]: { [meta "@container"]: [meta "@index"] }',
464
+ ' },',
465
+ ' [meta "@graph"]: [[ {',
466
+ ' [meta "@id"]: [string "http://dbpedia.org/resource/John_Lennon"],',
467
+ ' [property "name"]: [string "John Lennon"],',
468
+ ' [property "modified"]: {',
469
+ ' [meta "@value"]: [string "2010-05-29T14:17:39+02:00"],',
470
+ ' [meta "@type"]: [string "http://www.w3.org/2001/XMLSchema#dateTime"]',
471
+ ' }',
472
+ ' } ]]',
473
+ '}');
474
+
475
+ LD("json_ld_fake",
476
+ '{',
477
+ ' [property "@fake"]: [string "@fake"],',
478
+ ' [property "@contextual"]: [string "@identifier"],',
479
+ ' [property "user@domain.com"]: [string "@graphical"],',
480
+ ' [property "@ID"]: [string "@@ID"]',
481
+ '}');
482
+ })();
inc/lib/codemirror/mode/javascript/typescript.html ADDED
@@ -0,0 +1,61 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: TypeScript mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <script src="../../lib/codemirror.js"></script>
9
+ <script src="javascript.js"></script>
10
+ <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
11
+ <div id=nav>
12
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
13
+
14
+ <ul>
15
+ <li><a href="../../index.html">Home</a>
16
+ <li><a href="../../doc/manual.html">Manual</a>
17
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
18
+ </ul>
19
+ <ul>
20
+ <li><a href="../index.html">Language modes</a>
21
+ <li><a class=active href="#">TypeScript</a>
22
+ </ul>
23
+ </div>
24
+
25
+ <article>
26
+ <h2>TypeScript mode</h2>
27
+
28
+
29
+ <div><textarea id="code" name="code">
30
+ class Greeter {
31
+ greeting: string;
32
+ constructor (message: string) {
33
+ this.greeting = message;
34
+ }
35
+ greet() {
36
+ return "Hello, " + this.greeting;
37
+ }
38
+ }
39
+
40
+ var greeter = new Greeter("world");
41
+
42
+ var button = document.createElement('button')
43
+ button.innerText = "Say Hello"
44
+ button.onclick = function() {
45
+ alert(greeter.greet())
46
+ }
47
+
48
+ document.body.appendChild(button)
49
+
50
+ </textarea></div>
51
+
52
+ <script>
53
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
54
+ lineNumbers: true,
55
+ matchBrackets: true,
56
+ mode: "text/typescript"
57
+ });
58
+ </script>
59
+
60
+ <p>This is a specialization of the <a href="index.html">JavaScript mode</a>.</p>
61
+ </article>
inc/lib/codemirror/mode/meta.js ADDED
@@ -0,0 +1,217 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://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.modeInfo = [
15
+ {name: "APL", mime: "text/apl", mode: "apl", ext: ["dyalog", "apl"]},
16
+ {name: "PGP", mimes: ["application/pgp", "application/pgp-encrypted", "application/pgp-keys", "application/pgp-signature"], mode: "asciiarmor", ext: ["asc", "pgp", "sig"]},
17
+ {name: "ASN.1", mime: "text/x-ttcn-asn", mode: "asn.1", ext: ["asn", "asn1"]},
18
+ {name: "Asterisk", mime: "text/x-asterisk", mode: "asterisk", file: /^extensions\.conf$/i},
19
+ {name: "Brainfuck", mime: "text/x-brainfuck", mode: "brainfuck", ext: ["b", "bf"]},
20
+ {name: "C", mime: "text/x-csrc", mode: "clike", ext: ["c", "h", "ino"]},
21
+ {name: "C++", mime: "text/x-c++src", mode: "clike", ext: ["cpp", "c++", "cc", "cxx", "hpp", "h++", "hh", "hxx"], alias: ["cpp"]},
22
+ {name: "Cobol", mime: "text/x-cobol", mode: "cobol", ext: ["cob", "cpy"]},
23
+ {name: "C#", mime: "text/x-csharp", mode: "clike", ext: ["cs"], alias: ["csharp"]},
24
+ {name: "Clojure", mime: "text/x-clojure", mode: "clojure", ext: ["clj", "cljc", "cljx"]},
25
+ {name: "ClojureScript", mime: "text/x-clojurescript", mode: "clojure", ext: ["cljs"]},
26
+ {name: "Closure Stylesheets (GSS)", mime: "text/x-gss", mode: "css", ext: ["gss"]},
27
+ {name: "CMake", mime: "text/x-cmake", mode: "cmake", ext: ["cmake", "cmake.in"], file: /^CMakeLists.txt$/},
28
+ {name: "CoffeeScript", mimes: ["application/vnd.coffeescript", "text/coffeescript", "text/x-coffeescript"], mode: "coffeescript", ext: ["coffee"], alias: ["coffee", "coffee-script"]},
29
+ {name: "Common Lisp", mime: "text/x-common-lisp", mode: "commonlisp", ext: ["cl", "lisp", "el"], alias: ["lisp"]},
30
+ {name: "Cypher", mime: "application/x-cypher-query", mode: "cypher", ext: ["cyp", "cypher"]},
31
+ {name: "Cython", mime: "text/x-cython", mode: "python", ext: ["pyx", "pxd", "pxi"]},
32
+ {name: "Crystal", mime: "text/x-crystal", mode: "crystal", ext: ["cr"]},
33
+ {name: "CSS", mime: "text/css", mode: "css", ext: ["css"]},
34
+ {name: "CQL", mime: "text/x-cassandra", mode: "sql", ext: ["cql"]},
35
+ {name: "D", mime: "text/x-d", mode: "d", ext: ["d"]},
36
+ {name: "Dart", mimes: ["application/dart", "text/x-dart"], mode: "dart", ext: ["dart"]},
37
+ {name: "diff", mime: "text/x-diff", mode: "diff", ext: ["diff", "patch"]},
38
+ {name: "Django", mime: "text/x-django", mode: "django"},
39
+ {name: "Dockerfile", mime: "text/x-dockerfile", mode: "dockerfile", file: /^Dockerfile$/},
40
+ {name: "DTD", mime: "application/xml-dtd", mode: "dtd", ext: ["dtd"]},
41
+ {name: "Dylan", mime: "text/x-dylan", mode: "dylan", ext: ["dylan", "dyl", "intr"]},
42
+ {name: "EBNF", mime: "text/x-ebnf", mode: "ebnf"},
43
+ {name: "ECL", mime: "text/x-ecl", mode: "ecl", ext: ["ecl"]},
44
+ {name: "edn", mime: "application/edn", mode: "clojure", ext: ["edn"]},
45
+ {name: "Eiffel", mime: "text/x-eiffel", mode: "eiffel", ext: ["e"]},
46
+ {name: "Elm", mime: "text/x-elm", mode: "elm", ext: ["elm"]},
47
+ {name: "Embedded Javascript", mime: "application/x-ejs", mode: "htmlembedded", ext: ["ejs"]},
48
+ {name: "Embedded Ruby", mime: "application/x-erb", mode: "htmlembedded", ext: ["erb"]},
49
+ {name: "Erlang", mime: "text/x-erlang", mode: "erlang", ext: ["erl"]},
50
+ {name: "Esper", mime: "text/x-esper", mode: "sql"},
51
+ {name: "Factor", mime: "text/x-factor", mode: "factor", ext: ["factor"]},
52
+ {name: "FCL", mime: "text/x-fcl", mode: "fcl"},
53
+ {name: "Forth", mime: "text/x-forth", mode: "forth", ext: ["forth", "fth", "4th"]},
54
+ {name: "Fortran", mime: "text/x-fortran", mode: "fortran", ext: ["f", "for", "f77", "f90"]},
55
+ {name: "F#", mime: "text/x-fsharp", mode: "mllike", ext: ["fs"], alias: ["fsharp"]},
56
+ {name: "Gas", mime: "text/x-gas", mode: "gas", ext: ["s"]},
57
+ {name: "Gherkin", mime: "text/x-feature", mode: "gherkin", ext: ["feature"]},
58
+ {name: "GitHub Flavored Markdown", mime: "text/x-gfm", mode: "gfm", file: /^(readme|contributing|history).md$/i},
59
+ {name: "Go", mime: "text/x-go", mode: "go", ext: ["go"]},
60
+ {name: "Groovy", mime: "text/x-groovy", mode: "groovy", ext: ["groovy", "gradle"], file: /^Jenkinsfile$/},
61
+ {name: "HAML", mime: "text/x-haml", mode: "haml", ext: ["haml"]},
62
+ {name: "Haskell", mime: "text/x-haskell", mode: "haskell", ext: ["hs"]},
63
+ {name: "Haskell (Literate)", mime: "text/x-literate-haskell", mode: "haskell-literate", ext: ["lhs"]},
64
+ {name: "Haxe", mime: "text/x-haxe", mode: "haxe", ext: ["hx"]},
65
+ {name: "HXML", mime: "text/x-hxml", mode: "haxe", ext: ["hxml"]},
66
+ {name: "ASP.NET", mime: "application/x-aspx", mode: "htmlembedded", ext: ["aspx"], alias: ["asp", "aspx"]},
67
+ {name: "HTML", mime: "text/html", mode: "htmlmixed", ext: ["html", "htm", "handlebars", "hbs"], alias: ["xhtml"]},
68
+ {name: "HTTP", mime: "message/http", mode: "http"},
69
+ {name: "IDL", mime: "text/x-idl", mode: "idl", ext: ["pro"]},
70
+ {name: "Pug", mime: "text/x-pug", mode: "pug", ext: ["jade", "pug"], alias: ["jade"]},
71
+ {name: "Java", mime: "text/x-java", mode: "clike", ext: ["java"]},
72
+ {name: "Java Server Pages", mime: "application/x-jsp", mode: "htmlembedded", ext: ["jsp"], alias: ["jsp"]},
73
+ {name: "JavaScript", mimes: ["text/javascript", "text/ecmascript", "application/javascript", "application/x-javascript", "application/ecmascript"],
74
+ mode: "javascript", ext: ["js"], alias: ["ecmascript", "js", "node"]},
75
+ {name: "JSON", mimes: ["application/json", "application/x-json"], mode: "javascript", ext: ["json", "map"], alias: ["json5"]},
76
+ {name: "JSON-LD", mime: "application/ld+json", mode: "javascript", ext: ["jsonld"], alias: ["jsonld"]},
77
+ {name: "JSX", mime: "text/jsx", mode: "jsx", ext: ["jsx"]},
78
+ {name: "Jinja2", mime: "null", mode: "jinja2"},
79
+ {name: "Julia", mime: "text/x-julia", mode: "julia", ext: ["jl"]},
80
+ {name: "Kotlin", mime: "text/x-kotlin", mode: "clike", ext: ["kt"]},
81
+ {name: "LESS", mime: "text/x-less", mode: "css", ext: ["less"]},
82
+ {name: "LiveScript", mime: "text/x-livescript", mode: "livescript", ext: ["ls"], alias: ["ls"]},
83
+ {name: "Lua", mime: "text/x-lua", mode: "lua", ext: ["lua"]},
84
+ {name: "Markdown", mime: "text/x-markdown", mode: "markdown", ext: ["markdown", "md", "mkd"]},
85
+ {name: "mIRC", mime: "text/mirc", mode: "mirc"},
86
+ {name: "MariaDB SQL", mime: "text/x-mariadb", mode: "sql"},
87
+ {name: "Mathematica", mime: "text/x-mathematica", mode: "mathematica", ext: ["m", "nb"]},
88
+ {name: "Modelica", mime: "text/x-modelica", mode: "modelica", ext: ["mo"]},
89
+ {name: "MUMPS", mime: "text/x-mumps", mode: "mumps", ext: ["mps"]},
90
+ {name: "MS SQL", mime: "text/x-mssql", mode: "sql"},
91
+ {name: "mbox", mime: "application/mbox", mode: "mbox", ext: ["mbox"]},
92
+ {name: "MySQL", mime: "text/x-mysql", mode: "sql"},
93
+ {name: "Nginx", mime: "text/x-nginx-conf", mode: "nginx", file: /nginx.*\.conf$/i},
94
+ {name: "NSIS", mime: "text/x-nsis", mode: "nsis", ext: ["nsh", "nsi"]},
95
+ {name: "NTriples", mimes: ["application/n-triples", "application/n-quads", "text/n-triples"],
96
+ mode: "ntriples", ext: ["nt", "nq"]},
97
+ {name: "Objective-C", mime: "text/x-objectivec", mode: "clike", ext: ["m", "mm"], alias: ["objective-c", "objc"]},
98
+ {name: "OCaml", mime: "text/x-ocaml", mode: "mllike", ext: ["ml", "mli", "mll", "mly"]},
99
+ {name: "Octave", mime: "text/x-octave", mode: "octave", ext: ["m"]},
100
+ {name: "Oz", mime: "text/x-oz", mode: "oz", ext: ["oz"]},
101
+ {name: "Pascal", mime: "text/x-pascal", mode: "pascal", ext: ["p", "pas"]},
102
+ {name: "PEG.js", mime: "null", mode: "pegjs", ext: ["jsonld"]},
103
+ {name: "Perl", mime: "text/x-perl", mode: "perl", ext: ["pl", "pm"]},
104
+ {name: "PHP", mimes: ["text/x-php", "application/x-httpd-php", "application/x-httpd-php-open"], mode: "php", ext: ["php", "php3", "php4", "php5", "php7", "phtml"]},
105
+ {name: "Pig", mime: "text/x-pig", mode: "pig", ext: ["pig"]},
106
+ {name: "Plain Text", mime: "text/plain", mode: "null", ext: ["txt", "text", "conf", "def", "list", "log"]},
107
+ {name: "PLSQL", mime: "text/x-plsql", mode: "sql", ext: ["pls"]},
108
+ {name: "PowerShell", mime: "application/x-powershell", mode: "powershell", ext: ["ps1", "psd1", "psm1"]},
109
+ {name: "Properties files", mime: "text/x-properties", mode: "properties", ext: ["properties", "ini", "in"], alias: ["ini", "properties"]},
110
+ {name: "ProtoBuf", mime: "text/x-protobuf", mode: "protobuf", ext: ["proto"]},
111
+ {name: "Python", mime: "text/x-python", mode: "python", ext: ["BUILD", "bzl", "py", "pyw"], file: /^(BUCK|BUILD)$/},
112
+ {name: "Puppet", mime: "text/x-puppet", mode: "puppet", ext: ["pp"]},
113
+ {name: "Q", mime: "text/x-q", mode: "q", ext: ["q"]},
114
+ {name: "R", mime: "text/x-rsrc", mode: "r", ext: ["r", "R"], alias: ["rscript"]},
115
+ {name: "reStructuredText", mime: "text/x-rst", mode: "rst", ext: ["rst"], alias: ["rst"]},
116
+ {name: "RPM Changes", mime: "text/x-rpm-changes", mode: "rpm"},
117
+ {name: "RPM Spec", mime: "text/x-rpm-spec", mode: "rpm", ext: ["spec"]},
118
+ {name: "Ruby", mime: "text/x-ruby", mode: "ruby", ext: ["rb"], alias: ["jruby", "macruby", "rake", "rb", "rbx"]},
119
+ {name: "Rust", mime: "text/x-rustsrc", mode: "rust", ext: ["rs"]},
120
+ {name: "SAS", mime: "text/x-sas", mode: "sas", ext: ["sas"]},
121
+ {name: "Sass", mime: "text/x-sass", mode: "sass", ext: ["sass"]},
122
+ {name: "Scala", mime: "text/x-scala", mode: "clike", ext: ["scala"]},
123
+ {name: "Scheme", mime: "text/x-scheme", mode: "scheme", ext: ["scm", "ss"]},
124
+ {name: "SCSS", mime: "text/x-scss", mode: "css", ext: ["scss"]},
125
+ {name: "Shell", mimes: ["text/x-sh", "application/x-sh"], mode: "shell", ext: ["sh", "ksh", "bash"], alias: ["bash", "sh", "zsh"], file: /^PKGBUILD$/},
126
+ {name: "Sieve", mime: "application/sieve", mode: "sieve", ext: ["siv", "sieve"]},
127
+ {name: "Slim", mimes: ["text/x-slim", "application/x-slim"], mode: "slim", ext: ["slim"]},
128
+ {name: "Smalltalk", mime: "text/x-stsrc", mode: "smalltalk", ext: ["st"]},
129
+ {name: "Smarty", mime: "text/x-smarty", mode: "smarty", ext: ["tpl"]},
130
+ {name: "Solr", mime: "text/x-solr", mode: "solr"},
131
+ {name: "SML", mime: "text/x-sml", mode: "mllike", ext: ["sml", "sig", "fun", "smackspec"]},
132
+ {name: "Soy", mime: "text/x-soy", mode: "soy", ext: ["soy"], alias: ["closure template"]},
133
+ {name: "SPARQL", mime: "application/sparql-query", mode: "sparql", ext: ["rq", "sparql"], alias: ["sparul"]},
134
+ {name: "Spreadsheet", mime: "text/x-spreadsheet", mode: "spreadsheet", alias: ["excel", "formula"]},
135
+ {name: "SQL", mime: "text/x-sql", mode: "sql", ext: ["sql"]},
136
+ {name: "SQLite", mime: "text/x-sqlite", mode: "sql"},
137
+ {name: "Squirrel", mime: "text/x-squirrel", mode: "clike", ext: ["nut"]},
138
+ {name: "Stylus", mime: "text/x-styl", mode: "stylus", ext: ["styl"]},
139
+ {name: "Swift", mime: "text/x-swift", mode: "swift", ext: ["swift"]},
140
+ {name: "sTeX", mime: "text/x-stex", mode: "stex"},
141
+ {name: "LaTeX", mime: "text/x-latex", mode: "stex", ext: ["text", "ltx", "tex"], alias: ["tex"]},
142
+ {name: "SystemVerilog", mime: "text/x-systemverilog", mode: "verilog", ext: ["v", "sv", "svh"]},
143
+ {name: "Tcl", mime: "text/x-tcl", mode: "tcl", ext: ["tcl"]},
144
+ {name: "Textile", mime: "text/x-textile", mode: "textile", ext: ["textile"]},
145
+ {name: "TiddlyWiki ", mime: "text/x-tiddlywiki", mode: "tiddlywiki"},
146
+ {name: "Tiki wiki", mime: "text/tiki", mode: "tiki"},
147
+ {name: "TOML", mime: "text/x-toml", mode: "toml", ext: ["toml"]},
148
+ {name: "Tornado", mime: "text/x-tornado", mode: "tornado"},
149
+ {name: "troff", mime: "text/troff", mode: "troff", ext: ["1", "2", "3", "4", "5", "6", "7", "8", "9"]},
150
+ {name: "TTCN", mime: "text/x-ttcn", mode: "ttcn", ext: ["ttcn", "ttcn3", "ttcnpp"]},
151
+ {name: "TTCN_CFG", mime: "text/x-ttcn-cfg", mode: "ttcn-cfg", ext: ["cfg"]},
152
+ {name: "Turtle", mime: "text/turtle", mode: "turtle", ext: ["ttl"]},
153
+ {name: "TypeScript", mime: "application/typescript", mode: "javascript", ext: ["ts"], alias: ["ts"]},
154
+ {name: "TypeScript-JSX", mime: "text/typescript-jsx", mode: "jsx", ext: ["tsx"], alias: ["tsx"]},
155
+ {name: "Twig", mime: "text/x-twig", mode: "twig"},
156
+ {name: "Web IDL", mime: "text/x-webidl", mode: "webidl", ext: ["webidl"]},
157
+ {name: "VB.NET", mime: "text/x-vb", mode: "vb", ext: ["vb"]},
158
+ {name: "VBScript", mime: "text/vbscript", mode: "vbscript", ext: ["vbs"]},
159
+ {name: "Velocity", mime: "text/velocity", mode: "velocity", ext: ["vtl"]},
160
+ {name: "Verilog", mime: "text/x-verilog", mode: "verilog", ext: ["v"]},
161
+ {name: "VHDL", mime: "text/x-vhdl", mode: "vhdl", ext: ["vhd", "vhdl"]},
162
+ {name: "Vue.js Component", mimes: ["script/x-vue", "text/x-vue"], mode: "vue", ext: ["vue"]},
163
+ {name: "XML", mimes: ["application/xml", "text/xml"], mode: "xml", ext: ["xml", "xsl", "xsd", "svg"], alias: ["rss", "wsdl", "xsd"]},
164
+ {name: "XQuery", mime: "application/xquery", mode: "xquery", ext: ["xy", "xquery"]},
165
+ {name: "Yacas", mime: "text/x-yacas", mode: "yacas", ext: ["ys"]},
166
+ {name: "YAML", mimes: ["text/x-yaml", "text/yaml"], mode: "yaml", ext: ["yaml", "yml"], alias: ["yml"]},
167
+ {name: "Z80", mime: "text/x-z80", mode: "z80", ext: ["z80"]},
168
+ {name: "mscgen", mime: "text/x-mscgen", mode: "mscgen", ext: ["mscgen", "mscin", "msc"]},
169
+ {name: "xu", mime: "text/x-xu", mode: "mscgen", ext: ["xu"]},
170
+ {name: "msgenny", mime: "text/x-msgenny", mode: "mscgen", ext: ["msgenny"]}
171
+ ];
172
+ // Ensure all modes have a mime property for backwards compatibility
173
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
174
+ var info = CodeMirror.modeInfo[i];
175
+ if (info.mimes) info.mime = info.mimes[0];
176
+ }
177
+
178
+ CodeMirror.findModeByMIME = function(mime) {
179
+ mime = mime.toLowerCase();
180
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
181
+ var info = CodeMirror.modeInfo[i];
182
+ if (info.mime == mime) return info;
183
+ if (info.mimes) for (var j = 0; j < info.mimes.length; j++)
184
+ if (info.mimes[j] == mime) return info;
185
+ }
186
+ if (/\+xml$/.test(mime)) return CodeMirror.findModeByMIME("application/xml")
187
+ if (/\+json$/.test(mime)) return CodeMirror.findModeByMIME("application/json")
188
+ };
189
+
190
+ CodeMirror.findModeByExtension = function(ext) {
191
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
192
+ var info = CodeMirror.modeInfo[i];
193
+ if (info.ext) for (var j = 0; j < info.ext.length; j++)
194
+ if (info.ext[j] == ext) return info;
195
+ }
196
+ };
197
+
198
+ CodeMirror.findModeByFileName = function(filename) {
199
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
200
+ var info = CodeMirror.modeInfo[i];
201
+ if (info.file && info.file.test(filename)) return info;
202
+ }
203
+ var dot = filename.lastIndexOf(".");
204
+ var ext = dot > -1 && filename.substring(dot + 1, filename.length);
205
+ if (ext) return CodeMirror.findModeByExtension(ext);
206
+ };
207
+
208
+ CodeMirror.findModeByName = function(name) {
209
+ name = name.toLowerCase();
210
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
211
+ var info = CodeMirror.modeInfo[i];
212
+ if (info.name.toLowerCase() == name) return info;
213
+ if (info.alias) for (var j = 0; j < info.alias.length; j++)
214
+ if (info.alias[j].toLowerCase() == name) return info;
215
+ }
216
+ };
217
+ });
inc/lib/codemirror/mode/xml/index.html ADDED
@@ -0,0 +1,61 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!doctype html>
2
+
3
+ <title>CodeMirror: XML mode</title>
4
+ <meta charset="utf-8"/>
5
+ <link rel=stylesheet href="../../doc/docs.css">
6
+
7
+ <link rel="stylesheet" href="../../lib/codemirror.css">
8
+ <script src="../../lib/codemirror.js"></script>
9
+ <script src="xml.js"></script>
10
+ <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
11
+ <div id=nav>
12
+ <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
13
+
14
+ <ul>
15
+ <li><a href="../../index.html">Home</a>
16
+ <li><a href="../../doc/manual.html">Manual</a>
17
+ <li><a href="https://github.com/codemirror/codemirror">Code</a>
18
+ </ul>
19
+ <ul>
20
+ <li><a href="../index.html">Language modes</a>
21
+ <li><a class=active href="#">XML</a>
22
+ </ul>
23
+ </div>
24
+
25
+ <article>
26
+ <h2>XML mode</h2>
27
+ <form><textarea id="code" name="code">
28
+ &lt;html style="color: green"&gt;
29
+ &lt;!-- this is a comment --&gt;
30
+ &lt;head&gt;
31
+ &lt;title&gt;HTML Example&lt;/title&gt;
32
+ &lt;/head&gt;
33
+ &lt;body&gt;
34
+ The indentation tries to be &lt;em&gt;somewhat &amp;quot;do what
35
+ I mean&amp;quot;&lt;/em&gt;... but might not match your style.
36
+ &lt;/body&gt;
37
+ &lt;/html&gt;
38
+ </textarea></form>
39
+ <script>
40
+ var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
41
+ mode: "text/html",
42
+ lineNumbers: true
43
+ });
44
+ </script>
45
+ <p>The XML mode supports these configuration parameters:</p>
46
+ <dl>
47
+ <dt><code>htmlMode (boolean)</code></dt>
48
+ <dd>This switches the mode to parse HTML instead of XML. This
49
+ means attributes do not have to be quoted, and some elements
50
+ (such as <code>br</code>) do not require a closing tag.</dd>
51
+ <dt><code>matchClosing (boolean)</code></dt>
52
+ <dd>Controls whether the mode checks that close tags match the
53
+ corresponding opening tag, and highlights mismatches as errors.
54
+ Defaults to true.</dd>
55
+ <dt><code>alignCDATA (boolean)</code></dt>
56
+ <dd>Setting this to true will force the opening tag of CDATA
57
+ blocks to not be indented.</dd>
58
+ </dl>
59
+
60
+ <p><strong>MIME types defined:</strong> <code>application/xml</code>, <code>text/html</code>.</p>
61
+ </article>
inc/lib/codemirror/mode/xml/test.js ADDED
@@ -0,0 +1,51 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // CodeMirror, copyright (c) by Marijn Haverbeke and others
2
+ // Distributed under an MIT license: http://codemirror.net/LICENSE
3
+
4
+ (function() {
5
+ var mode = CodeMirror.getMode({indentUnit: 2}, "xml"), mname = "xml";
6
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1), mname); }
7
+
8
+ MT("matching",
9
+ "[tag&bracket <][tag top][tag&bracket >]",
10
+ " text",
11
+ " [tag&bracket <][tag inner][tag&bracket />]",
12
+ "[tag&bracket </][tag top][tag&bracket >]");
13
+
14
+ MT("nonmatching",
15
+ "[tag&bracket <][tag top][tag&bracket >]",
16
+ " [tag&bracket <][tag inner][tag&bracket />]",
17
+ " [tag&bracket </][tag&error tip][tag&bracket&error >]");
18
+
19
+ MT("doctype",
20
+ "[meta <!doctype foobar>]",
21
+ "[tag&bracket <][tag top][tag&bracket />]");
22
+
23
+ MT("cdata",
24
+ "[tag&bracket <][tag top][tag&bracket >]",
25
+ " [atom <![CDATA[foo]",
26
+ "[atom barbazguh]]]]>]",
27
+ "[tag&bracket </][tag top][tag&bracket >]");
28
+
29
+ // HTML tests
30
+ mode = CodeMirror.getMode({indentUnit: 2}, "text/html");
31
+
32
+ MT("selfclose",
33
+ "[tag&bracket <][tag html][tag&bracket >]",
34
+ " [tag&bracket <][tag link] [attribute rel]=[string stylesheet] [attribute href]=[string \"/foobar\"][tag&bracket >]",
35
+ "[tag&bracket </][tag html][tag&bracket >]");
36
+
37
+ MT("list",
38
+ "[tag&bracket <][tag ol][tag&bracket >]",
39
+ " [tag&bracket <][tag li][tag&bracket >]one",
40
+ " [tag&bracket <][tag li][tag&bracket >]two",
41
+ "[tag&bracket </][tag ol][tag&bracket >]");
42
+
43
+ MT("valueless",
44
+ "[tag&bracket <][tag input] [attribute type]=[string checkbox] [attribute checked][tag&bracket />]");
45
+
46
+ MT("pThenArticle",
47
+ "[tag&bracket <][tag p][tag&bracket >]",
48
+ " foo",
49
+ "[tag&bracket <][tag article][tag&bracket >]bar");
50
+
51
+ })();
inc/lib/codemirror/mode/{xml.js → xml/xml.js} RENAMED
@@ -52,6 +52,7 @@ var xmlConfig = {
52
  doNotIndent: {},
53
  allowUnquoted: false,
54
  allowMissing: false,
 
55
  caseFold: false
56
  }
57
 
@@ -226,6 +227,9 @@ CodeMirror.defineMode("xml", function(editorConf, config_) {
226
  state.tagName = stream.current();
227
  setStyle = "tag";
228
  return attrState;
 
 
 
229
  } else {
230
  setStyle = "error";
231
  return tagNameState;
@@ -244,6 +248,9 @@ CodeMirror.defineMode("xml", function(editorConf, config_) {
244
  setStyle = "tag error";
245
  return closeStateErr;
246
  }
 
 
 
247
  } else {
248
  setStyle = "error";
249
  return closeStateErr;
52
  doNotIndent: {},
53
  allowUnquoted: false,
54
  allowMissing: false,
55
+ allowMissingTagName: false,
56
  caseFold: false
57
  }
58
 
227
  state.tagName = stream.current();
228
  setStyle = "tag";
229
  return attrState;
230
+ } else if (config.allowMissingTagName && type == "endTag") {
231
+ setStyle = "tag bracket";
232
+ return attrState(type, stream, state);
233
  } else {
234
  setStyle = "error";
235
  return tagNameState;
248
  setStyle = "tag error";
249
  return closeStateErr;
250
  }
251
+ } else if (config.allowMissingTagName && type == "endTag") {
252
+ setStyle = "tag bracket";
253
+ return closeState(type, stream, state);
254
  } else {
255
  setStyle = "error";
256
  return closeStateErr;
inc/lib/codemirror/package.json ADDED
@@ -0,0 +1,49 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "name": "codemirror",
3
+ "version": "5.38.0",
4
+ "main": "lib/codemirror.js",
5
+ "style": "lib/codemirror.css",
6
+ "description": "Full-featured in-browser code editor",
7
+ "license": "MIT",
8
+ "directories": {
9
+ "lib": "./lib"
10
+ },
11
+ "scripts": {
12
+ "build": "rollup -c",
13
+ "watch": "rollup -w -c",
14
+ "prepare": "npm run-script build",
15
+ "test": "node ./test/run.js",
16
+ "lint": "bin/lint"
17
+ },
18
+ "devDependencies": {
19
+ "blint": "^1",
20
+ "node-static": "0.6.0",
21
+ "phantomjs-prebuilt": "^2.1.12",
22
+ "rollup": "^0.41.0",
23
+ "rollup-plugin-buble": "^0.15.0",
24
+ "rollup-watch": "^3.2.0"
25
+ },
26
+ "bugs": "http://github.com/codemirror/CodeMirror/issues",
27
+ "keywords": [
28
+ "JavaScript",
29
+ "CodeMirror",
30
+ "Editor"
31
+ ],
32
+ "homepage": "http://codemirror.net",
33
+ "maintainers": [
34
+ {
35
+ "name": "Marijn Haverbeke",
36
+ "email": "marijnh@gmail.com",
37
+ "web": "http://marijnhaverbeke.nl"
38
+ }
39
+ ],
40
+ "repository": {
41
+ "type": "git",
42
+ "url": "https://github.com/codemirror/CodeMirror.git"
43
+ },
44
+ "jspm": {
45
+ "directories": {},
46
+ "dependencies": {},
47
+ "devDependencies": {}
48
+ }
49
+ }
inc/php/enqueue.php CHANGED
@@ -32,13 +32,16 @@ function spacexchimp_p006_load_scripts_admin( $hook ) {
32
  wp_enqueue_style( $prefix . '-font-awesome-css', $url . 'inc/lib/font-awesome/css/font-awesome.css', array(), $version, 'screen' );
33
 
34
  // CodeMirror library
35
- wp_enqueue_style( $prefix . '-codemirror-css', $url . 'inc/lib/codemirror/codemirror.css', array(), $version, 'all' );
36
- wp_enqueue_script( $prefix . '-codemirror-js', $url . 'inc/lib/codemirror/codemirror.js', array(), $version, false );
37
- wp_enqueue_script( $prefix . '-codemirror-mode-htmlmixed-js', $url . 'inc/lib/codemirror/mode/htmlmixed.js', array(), $version, false );
38
- wp_enqueue_script( $prefix . '-codemirror-mode-javascript-js', $url . 'inc/lib/codemirror/mode/javascript.js', array(), $version, false );
39
- wp_enqueue_script( $prefix . '-codemirror-mode-xml-js', $url . 'inc/lib/codemirror/mode/xml.js', array(), $version, false );
40
- wp_enqueue_script( $prefix . '-codemirror-mode-css-js', $url . 'inc/lib/codemirror/mode/css.js', array(), $version, false );
41
- wp_enqueue_script( $prefix . '-codemirror-mode-active-line-js', $url . 'inc/lib/codemirror/addons/active-line.js', array(), $version, false );
 
 
 
42
 
43
  // Style sheet
44
  wp_enqueue_style( $prefix . '-admin-css', $url . 'inc/css/admin.css', array(), $version, 'all' );
32
  wp_enqueue_style( $prefix . '-font-awesome-css', $url . 'inc/lib/font-awesome/css/font-awesome.css', array(), $version, 'screen' );
33
 
34
  // CodeMirror library
35
+ wp_enqueue_style( $prefix . '-codemirror-css', $url . 'inc/lib/codemirror/lib/codemirror.css', array(), $version, 'all' );
36
+ wp_enqueue_script( $prefix . '-codemirror-js', $url . 'inc/lib/codemirror/lib/codemirror.js', array(), $version, false );
37
+ $modes = array( 'css', 'htmlmixed', 'javascript', 'xml' );
38
+ foreach ( $modes as $mode ) {
39
+ wp_enqueue_script( $prefix . '-codemirror-mode-' . $mode . '-js', $url . 'inc/lib/codemirror/mode/' . $mode . '/' . $mode . '.js', array(), $version, true );
40
+ }
41
+ $addons = array( 'active-line' );
42
+ foreach ( $addons as $addon ) {
43
+ wp_enqueue_script( $prefix . '-codemirror-addon-' . $addon . '-js', $url . 'inc/lib/codemirror/addon/selection/' . $addon . '.js', array(), $version, false );
44
+ }
45
 
46
  // Style sheet
47
  wp_enqueue_style( $prefix . '-admin-css', $url . 'inc/css/admin.css', array(), $version, 'all' );
readme.txt CHANGED
@@ -4,7 +4,7 @@ Tags: inject, insert, insert scripts, insert javascript, insert js, insert html,
4
  Donate link: https://www.spacexchimp.com/donate.html
5
  Requires at least: 3.9
6
  Tested up to: 4.9
7
- Stable tag: 4.20
8
  License: GPL3
9
  License URI: http://www.gnu.org/licenses/gpl-3.0.html
10
 
@@ -187,9 +187,13 @@ Commercial licensing (e.g. for projects that can’t use an open-source license)
187
 
188
  == Changelog ==
189
 
 
 
 
 
190
  = 4.20 =
191
  * Fixed a bug due to which the plugin data that stored in the database to not be deleted during the uninstallation of the plugin.
192
- * The contents of the file 'uninstall.php is moved to the file 'core.php'. The file 'uninstall.php' is deleted.
193
 
194
  = 4.19 =
195
  * Added new constant "_FILE".
4
  Donate link: https://www.spacexchimp.com/donate.html
5
  Requires at least: 3.9
6
  Tested up to: 4.9
7
+ Stable tag: 4.21
8
  License: GPL3
9
  License URI: http://www.gnu.org/licenses/gpl-3.0.html
10
 
187
 
188
  == Changelog ==
189
 
190
+ = 4.21 =
191
+ * CodeMirror library updated to the latest version v5.38.0. The directory structure is changed (files are better organized). Added a test files for the CodeMirror modes.
192
+ * Updated the method of loading the modes and addons of the CodeMirror library.
193
+
194
  = 4.20 =
195
  * Fixed a bug due to which the plugin data that stored in the database to not be deleted during the uninstallation of the plugin.
196
+ * The contents of the file 'uninstall.php' is moved to the file 'core.php'. The file 'uninstall.php' is deleted.
197
 
198
  = 4.19 =
199
  * Added new constant "_FILE".