aae36dfe5316d050aa4fac5f79333851133882dc
[redakcja.git] / src / redakcja / static / js / lib / codemirror-5.49.0 / searchcursor.js
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
2 // Distributed under an MIT license: https://codemirror.net/LICENSE
3
4 (function(mod) {
5   if (typeof exports == "object" && typeof module == "object") // CommonJS
6     mod(require("../../lib/codemirror"))
7   else if (typeof define == "function" && define.amd) // AMD
8     define(["../../lib/codemirror"], mod)
9   else // Plain browser env
10     mod(CodeMirror)
11 })(function(CodeMirror) {
12   "use strict"
13   var Pos = CodeMirror.Pos
14
15   function regexpFlags(regexp) {
16     var flags = regexp.flags
17     return flags != null ? flags : (regexp.ignoreCase ? "i" : "")
18       + (regexp.global ? "g" : "")
19       + (regexp.multiline ? "m" : "")
20   }
21
22   function ensureFlags(regexp, flags) {
23     var current = regexpFlags(regexp), target = current
24     for (var i = 0; i < flags.length; i++) if (target.indexOf(flags.charAt(i)) == -1)
25       target += flags.charAt(i)
26     return current == target ? regexp : new RegExp(regexp.source, target)
27   }
28
29   function maybeMultiline(regexp) {
30     return /\\s|\\n|\n|\\W|\\D|\[\^/.test(regexp.source)
31   }
32
33   function searchRegexpForward(doc, regexp, start) {
34     regexp = ensureFlags(regexp, "g")
35     for (var line = start.line, ch = start.ch, last = doc.lastLine(); line <= last; line++, ch = 0) {
36       regexp.lastIndex = ch
37       var string = doc.getLine(line), match = regexp.exec(string)
38       if (match)
39         return {from: Pos(line, match.index),
40                 to: Pos(line, match.index + match[0].length),
41                 match: match}
42     }
43   }
44
45   function searchRegexpForwardMultiline(doc, regexp, start) {
46     if (!maybeMultiline(regexp)) return searchRegexpForward(doc, regexp, start)
47
48     regexp = ensureFlags(regexp, "gm")
49     var string, chunk = 1
50     for (var line = start.line, last = doc.lastLine(); line <= last;) {
51       // This grows the search buffer in exponentially-sized chunks
52       // between matches, so that nearby matches are fast and don't
53       // require concatenating the whole document (in case we're
54       // searching for something that has tons of matches), but at the
55       // same time, the amount of retries is limited.
56       for (var i = 0; i < chunk; i++) {
57         if (line > last) break
58         var curLine = doc.getLine(line++)
59         string = string == null ? curLine : string + "\n" + curLine
60       }
61       chunk = chunk * 2
62       regexp.lastIndex = start.ch
63       var match = regexp.exec(string)
64       if (match) {
65         var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n")
66         var startLine = start.line + before.length - 1, startCh = before[before.length - 1].length
67         return {from: Pos(startLine, startCh),
68                 to: Pos(startLine + inside.length - 1,
69                         inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length),
70                 match: match}
71       }
72     }
73   }
74
75   function lastMatchIn(string, regexp) {
76     var cutOff = 0, match
77     for (;;) {
78       regexp.lastIndex = cutOff
79       var newMatch = regexp.exec(string)
80       if (!newMatch) return match
81       match = newMatch
82       cutOff = match.index + (match[0].length || 1)
83       if (cutOff == string.length) return match
84     }
85   }
86
87   function searchRegexpBackward(doc, regexp, start) {
88     regexp = ensureFlags(regexp, "g")
89     for (var line = start.line, ch = start.ch, first = doc.firstLine(); line >= first; line--, ch = -1) {
90       var string = doc.getLine(line)
91       if (ch > -1) string = string.slice(0, ch)
92       var match = lastMatchIn(string, regexp)
93       if (match)
94         return {from: Pos(line, match.index),
95                 to: Pos(line, match.index + match[0].length),
96                 match: match}
97     }
98   }
99
100   function searchRegexpBackwardMultiline(doc, regexp, start) {
101     regexp = ensureFlags(regexp, "gm")
102     var string, chunk = 1
103     for (var line = start.line, first = doc.firstLine(); line >= first;) {
104       for (var i = 0; i < chunk; i++) {
105         var curLine = doc.getLine(line--)
106         string = string == null ? curLine.slice(0, start.ch) : curLine + "\n" + string
107       }
108       chunk *= 2
109
110       var match = lastMatchIn(string, regexp)
111       if (match) {
112         var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n")
113         var startLine = line + before.length, startCh = before[before.length - 1].length
114         return {from: Pos(startLine, startCh),
115                 to: Pos(startLine + inside.length - 1,
116                         inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length),
117                 match: match}
118       }
119     }
120   }
121
122   var doFold, noFold
123   if (String.prototype.normalize) {
124     doFold = function(str) { return str.normalize("NFD").toLowerCase() }
125     noFold = function(str) { return str.normalize("NFD") }
126   } else {
127     doFold = function(str) { return str.toLowerCase() }
128     noFold = function(str) { return str }
129   }
130
131   // Maps a position in a case-folded line back to a position in the original line
132   // (compensating for codepoints increasing in number during folding)
133   function adjustPos(orig, folded, pos, foldFunc) {
134     if (orig.length == folded.length) return pos
135     for (var min = 0, max = pos + Math.max(0, orig.length - folded.length);;) {
136       if (min == max) return min
137       var mid = (min + max) >> 1
138       var len = foldFunc(orig.slice(0, mid)).length
139       if (len == pos) return mid
140       else if (len > pos) max = mid
141       else min = mid + 1
142     }
143   }
144
145   function searchStringForward(doc, query, start, caseFold) {
146     // Empty string would match anything and never progress, so we
147     // define it to match nothing instead.
148     if (!query.length) return null
149     var fold = caseFold ? doFold : noFold
150     var lines = fold(query).split(/\r|\n\r?/)
151
152     search: for (var line = start.line, ch = start.ch, last = doc.lastLine() + 1 - lines.length; line <= last; line++, ch = 0) {
153       var orig = doc.getLine(line).slice(ch), string = fold(orig)
154       if (lines.length == 1) {
155         var found = string.indexOf(lines[0])
156         if (found == -1) continue search
157         var start = adjustPos(orig, string, found, fold) + ch
158         return {from: Pos(line, adjustPos(orig, string, found, fold) + ch),
159                 to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold) + ch)}
160       } else {
161         var cutFrom = string.length - lines[0].length
162         if (string.slice(cutFrom) != lines[0]) continue search
163         for (var i = 1; i < lines.length - 1; i++)
164           if (fold(doc.getLine(line + i)) != lines[i]) continue search
165         var end = doc.getLine(line + lines.length - 1), endString = fold(end), lastLine = lines[lines.length - 1]
166         if (endString.slice(0, lastLine.length) != lastLine) continue search
167         return {from: Pos(line, adjustPos(orig, string, cutFrom, fold) + ch),
168                 to: Pos(line + lines.length - 1, adjustPos(end, endString, lastLine.length, fold))}
169       }
170     }
171   }
172
173   function searchStringBackward(doc, query, start, caseFold) {
174     if (!query.length) return null
175     var fold = caseFold ? doFold : noFold
176     var lines = fold(query).split(/\r|\n\r?/)
177
178     search: for (var line = start.line, ch = start.ch, first = doc.firstLine() - 1 + lines.length; line >= first; line--, ch = -1) {
179       var orig = doc.getLine(line)
180       if (ch > -1) orig = orig.slice(0, ch)
181       var string = fold(orig)
182       if (lines.length == 1) {
183         var found = string.lastIndexOf(lines[0])
184         if (found == -1) continue search
185         return {from: Pos(line, adjustPos(orig, string, found, fold)),
186                 to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold))}
187       } else {
188         var lastLine = lines[lines.length - 1]
189         if (string.slice(0, lastLine.length) != lastLine) continue search
190         for (var i = 1, start = line - lines.length + 1; i < lines.length - 1; i++)
191           if (fold(doc.getLine(start + i)) != lines[i]) continue search
192         var top = doc.getLine(line + 1 - lines.length), topString = fold(top)
193         if (topString.slice(topString.length - lines[0].length) != lines[0]) continue search
194         return {from: Pos(line + 1 - lines.length, adjustPos(top, topString, top.length - lines[0].length, fold)),
195                 to: Pos(line, adjustPos(orig, string, lastLine.length, fold))}
196       }
197     }
198   }
199
200   function SearchCursor(doc, query, pos, options) {
201     this.atOccurrence = false
202     this.doc = doc
203     pos = pos ? doc.clipPos(pos) : Pos(0, 0)
204     this.pos = {from: pos, to: pos}
205
206     var caseFold
207     if (typeof options == "object") {
208       caseFold = options.caseFold
209     } else { // Backwards compat for when caseFold was the 4th argument
210       caseFold = options
211       options = null
212     }
213
214     if (typeof query == "string") {
215       if (caseFold == null) caseFold = false
216       this.matches = function(reverse, pos) {
217         return (reverse ? searchStringBackward : searchStringForward)(doc, query, pos, caseFold)
218       }
219     } else {
220       query = ensureFlags(query, "gm")
221       if (!options || options.multiline !== false)
222         this.matches = function(reverse, pos) {
223           return (reverse ? searchRegexpBackwardMultiline : searchRegexpForwardMultiline)(doc, query, pos)
224         }
225       else
226         this.matches = function(reverse, pos) {
227           return (reverse ? searchRegexpBackward : searchRegexpForward)(doc, query, pos)
228         }
229     }
230   }
231
232   SearchCursor.prototype = {
233     findNext: function() {return this.find(false)},
234     findPrevious: function() {return this.find(true)},
235
236     find: function(reverse) {
237       var result = this.matches(reverse, this.doc.clipPos(reverse ? this.pos.from : this.pos.to))
238
239       // Implements weird auto-growing behavior on null-matches for
240       // backwards-compatiblity with the vim code (unfortunately)
241       while (result && CodeMirror.cmpPos(result.from, result.to) == 0) {
242         if (reverse) {
243           if (result.from.ch) result.from = Pos(result.from.line, result.from.ch - 1)
244           else if (result.from.line == this.doc.firstLine()) result = null
245           else result = this.matches(reverse, this.doc.clipPos(Pos(result.from.line - 1)))
246         } else {
247           if (result.to.ch < this.doc.getLine(result.to.line).length) result.to = Pos(result.to.line, result.to.ch + 1)
248           else if (result.to.line == this.doc.lastLine()) result = null
249           else result = this.matches(reverse, Pos(result.to.line + 1, 0))
250         }
251       }
252
253       if (result) {
254         this.pos = result
255         this.atOccurrence = true
256         return this.pos.match || true
257       } else {
258         var end = Pos(reverse ? this.doc.firstLine() : this.doc.lastLine() + 1, 0)
259         this.pos = {from: end, to: end}
260         return this.atOccurrence = false
261       }
262     },
263
264     from: function() {if (this.atOccurrence) return this.pos.from},
265     to: function() {if (this.atOccurrence) return this.pos.to},
266
267     replace: function(newText, origin) {
268       if (!this.atOccurrence) return
269       var lines = CodeMirror.splitLines(newText)
270       this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin)
271       this.pos.to = Pos(this.pos.from.line + lines.length - 1,
272                         lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0))
273     }
274   }
275
276   CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
277     return new SearchCursor(this.doc, query, pos, caseFold)
278   })
279   CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) {
280     return new SearchCursor(this, query, pos, caseFold)
281   })
282
283   CodeMirror.defineExtension("selectMatches", function(query, caseFold) {
284     var ranges = []
285     var cur = this.getSearchCursor(query, this.getCursor("from"), caseFold)
286     while (cur.findNext()) {
287       if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0) break
288       ranges.push({anchor: cur.from(), head: cur.to()})
289     }
290     if (ranges.length)
291       this.setSelections(ranges, 0)
292   })
293 });