File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/filemanager.zip
Back
PK �S�Z=��< < src/util/browser.jsnu �[��� // Kludges for bugs and behavior differences that can't be feature // detected are enabled based on userAgent etc sniffing. let userAgent = navigator.userAgent let platform = navigator.platform export let gecko = /gecko\/\d/i.test(userAgent) let ie_upto10 = /MSIE \d/.test(userAgent) let ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent) let edge = /Edge\/(\d+)/.exec(userAgent) export let ie = ie_upto10 || ie_11up || edge export let ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]) export let webkit = !edge && /WebKit\//.test(userAgent) let qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent) export let chrome = !edge && /Chrome\//.test(userAgent) export let presto = /Opera\//.test(userAgent) export let safari = /Apple Computer/.test(navigator.vendor) export let mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent) export let phantom = /PhantomJS/.test(userAgent) export let ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent) export let android = /Android/.test(userAgent) // This is woefully incomplete. Suggestions for alternative methods welcome. export let mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent) export let mac = ios || /Mac/.test(platform) export let chromeOS = /\bCrOS\b/.test(userAgent) export let windows = /win/i.test(platform) let presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/) if (presto_version) presto_version = Number(presto_version[1]) if (presto_version && presto_version >= 15) { presto = false; webkit = true } // Some browsers use the wrong event properties to signal cmd/ctrl on OS X export let flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11)) export let captureRightClick = gecko || (ie && ie_version >= 9) PK �S�ZZ:�� � src/util/event.jsnu �[��� import { mac } from "./browser.js" import { indexOf } from "./misc.js" // EVENT HANDLING // Lightweight event framework. on/off also work on DOM nodes, // registering native DOM handlers. const noHandlers = [] export let on = function(emitter, type, f) { if (emitter.addEventListener) { emitter.addEventListener(type, f, false) } else if (emitter.attachEvent) { emitter.attachEvent("on" + type, f) } else { let map = emitter._handlers || (emitter._handlers = {}) map[type] = (map[type] || noHandlers).concat(f) } } export function getHandlers(emitter, type) { return emitter._handlers && emitter._handlers[type] || noHandlers } export function off(emitter, type, f) { if (emitter.removeEventListener) { emitter.removeEventListener(type, f, false) } else if (emitter.detachEvent) { emitter.detachEvent("on" + type, f) } else { let map = emitter._handlers, arr = map && map[type] if (arr) { let index = indexOf(arr, f) if (index > -1) map[type] = arr.slice(0, index).concat(arr.slice(index + 1)) } } } export function signal(emitter, type /*, values...*/) { let handlers = getHandlers(emitter, type) if (!handlers.length) return let args = Array.prototype.slice.call(arguments, 2) for (let i = 0; i < handlers.length; ++i) handlers[i].apply(null, args) } // The DOM events that CodeMirror handles can be overridden by // registering a (non-DOM) handler on the editor for the event name, // and preventDefault-ing the event in that handler. export function signalDOMEvent(cm, e, override) { if (typeof e == "string") e = {type: e, preventDefault: function() { this.defaultPrevented = true }} signal(cm, override || e.type, cm, e) return e_defaultPrevented(e) || e.codemirrorIgnore } export function signalCursorActivity(cm) { let arr = cm._handlers && cm._handlers.cursorActivity if (!arr) return let set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []) for (let i = 0; i < arr.length; ++i) if (indexOf(set, arr[i]) == -1) set.push(arr[i]) } export function hasHandler(emitter, type) { return getHandlers(emitter, type).length > 0 } // Add on and off methods to a constructor's prototype, to make // registering events on such objects more convenient. export function eventMixin(ctor) { ctor.prototype.on = function(type, f) {on(this, type, f)} ctor.prototype.off = function(type, f) {off(this, type, f)} } // Due to the fact that we still support jurassic IE versions, some // compatibility wrappers are needed. export function e_preventDefault(e) { if (e.preventDefault) e.preventDefault() else e.returnValue = false } export function e_stopPropagation(e) { if (e.stopPropagation) e.stopPropagation() else e.cancelBubble = true } export function e_defaultPrevented(e) { return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false } export function e_stop(e) {e_preventDefault(e); e_stopPropagation(e)} export function e_target(e) {return e.target || e.srcElement} export function e_button(e) { let b = e.which if (b == null) { if (e.button & 1) b = 1 else if (e.button & 2) b = 3 else if (e.button & 4) b = 2 } if (mac && e.ctrlKey && b == 1) b = 3 return b } PK �S�ZP|0 � � src/util/dom.jsnu �[��� import { ie, ios } from "./browser.js" export function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") } export let rmClass = function(node, cls) { let current = node.className let match = classTest(cls).exec(current) if (match) { let after = current.slice(match.index + match[0].length) node.className = current.slice(0, match.index) + (after ? match[1] + after : "") } } export function removeChildren(e) { for (let count = e.childNodes.length; count > 0; --count) e.removeChild(e.firstChild) return e } export function removeChildrenAndAdd(parent, e) { return removeChildren(parent).appendChild(e) } export function elt(tag, content, className, style) { let e = document.createElement(tag) if (className) e.className = className if (style) e.style.cssText = style if (typeof content == "string") e.appendChild(document.createTextNode(content)) else if (content) for (let i = 0; i < content.length; ++i) e.appendChild(content[i]) return e } // wrapper for elt, which removes the elt from the accessibility tree export function eltP(tag, content, className, style) { let e = elt(tag, content, className, style) e.setAttribute("role", "presentation") return e } export let range if (document.createRange) range = function(node, start, end, endNode) { let r = document.createRange() r.setEnd(endNode || node, end) r.setStart(node, start) return r } else range = function(node, start, end) { let r = document.body.createTextRange() try { r.moveToElementText(node.parentNode) } catch(e) { return r } r.collapse(true) r.moveEnd("character", end) r.moveStart("character", start) return r } export function contains(parent, child) { if (child.nodeType == 3) // Android browser always returns false when child is a textnode child = child.parentNode if (parent.contains) return parent.contains(child) do { if (child.nodeType == 11) child = child.host if (child == parent) return true } while (child = child.parentNode) } export function activeElt() { // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement. // IE < 10 will throw when accessed while the page is loading or in an iframe. // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable. let activeElement try { activeElement = document.activeElement } catch(e) { activeElement = document.body || null } while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement) activeElement = activeElement.shadowRoot.activeElement return activeElement } export function addClass(node, cls) { let current = node.className if (!classTest(cls).test(current)) node.className += (current ? " " : "") + cls } export function joinClasses(a, b) { let as = a.split(" ") for (let i = 0; i < as.length; i++) if (as[i] && !classTest(as[i]).test(b)) b += " " + as[i] return b } export let selectInput = function(node) { node.select() } if (ios) // Mobile Safari apparently has a bug where select() is broken. selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length } else if (ie) // Suppress mysterious IE10 errors selectInput = function(node) { try { node.select() } catch(_e) {} } PK �S�Z�~ˣ � src/util/misc.jsnu �[��� export function bind(f) { let args = Array.prototype.slice.call(arguments, 1) return function(){return f.apply(null, args)} } export function copyObj(obj, target, overwrite) { if (!target) target = {} for (let prop in obj) if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop))) target[prop] = obj[prop] return target } // Counts the column offset in a string, taking tabs into account. // Used mostly to find indentation. export function countColumn(string, end, tabSize, startIndex, startValue) { if (end == null) { end = string.search(/[^\s\u00a0]/) if (end == -1) end = string.length } for (let i = startIndex || 0, n = startValue || 0;;) { let nextTab = string.indexOf("\t", i) if (nextTab < 0 || nextTab >= end) return n + (end - i) n += nextTab - i n += tabSize - (n % tabSize) i = nextTab + 1 } } export class Delayed { constructor() { this.id = null this.f = null this.time = 0 this.handler = bind(this.onTimeout, this) } onTimeout(self) { self.id = 0 if (self.time <= +new Date) { self.f() } else { setTimeout(self.handler, self.time - +new Date) } } set(ms, f) { this.f = f const time = +new Date + ms if (!this.id || time < this.time) { clearTimeout(this.id) this.id = setTimeout(this.handler, ms) this.time = time } } } export function indexOf(array, elt) { for (let i = 0; i < array.length; ++i) if (array[i] == elt) return i return -1 } // Number of pixels added to scroller and sizer to hide scrollbar export let scrollerGap = 50 // Returned or thrown by various protocols to signal 'I'm not // handling this'. export let Pass = {toString: function(){return "CodeMirror.Pass"}} // Reused option objects for setSelection & friends export let sel_dontScroll = {scroll: false}, sel_mouse = {origin: "*mouse"}, sel_move = {origin: "+move"} // The inverse of countColumn -- find the offset that corresponds to // a particular column. export function findColumn(string, goal, tabSize) { for (let pos = 0, col = 0;;) { let nextTab = string.indexOf("\t", pos) if (nextTab == -1) nextTab = string.length let skipped = nextTab - pos if (nextTab == string.length || col + skipped >= goal) return pos + Math.min(skipped, goal - col) col += nextTab - pos col += tabSize - (col % tabSize) pos = nextTab + 1 if (col >= goal) return pos } } let spaceStrs = [""] export function spaceStr(n) { while (spaceStrs.length <= n) spaceStrs.push(lst(spaceStrs) + " ") return spaceStrs[n] } export function lst(arr) { return arr[arr.length-1] } export function map(array, f) { let out = [] for (let i = 0; i < array.length; i++) out[i] = f(array[i], i) return out } export function insertSorted(array, value, score) { let pos = 0, priority = score(value) while (pos < array.length && score(array[pos]) <= priority) pos++ array.splice(pos, 0, value) } function nothing() {} export function createObj(base, props) { let inst if (Object.create) { inst = Object.create(base) } else { nothing.prototype = base inst = new nothing() } if (props) copyObj(props, inst) return inst } let nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/ export function isWordCharBasic(ch) { return /\w/.test(ch) || ch > "\x80" && (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch)) } export function isWordChar(ch, helper) { if (!helper) return isWordCharBasic(ch) if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) return true return helper.test(ch) } export function isEmpty(obj) { for (let n in obj) if (obj.hasOwnProperty(n) && obj[n]) return false return true } // Extending unicode characters. A series of a non-extending char + // any number of extending chars is treated as a single unit as far // as editing and measuring is concerned. This is not fully correct, // since some scripts/fonts/browsers also treat other configurations // of code points as a group. let 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]/ export function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) } // Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range. export function skipExtendingChars(str, pos, dir) { while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) pos += dir return pos } // Returns the value from the range [`from`; `to`] that satisfies // `pred` and is closest to `from`. Assumes that at least `to` // satisfies `pred`. Supports `from` being greater than `to`. export function findFirst(pred, from, to) { // At any point we are certain `to` satisfies `pred`, don't know // whether `from` does. let dir = from > to ? -1 : 1 for (;;) { if (from == to) return from let midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF) if (mid == from) return pred(mid) ? from : to if (pred(mid)) to = mid else from = mid + dir } } PK �S�Z�<�j j src/util/operation_group.jsnu �[��� import { getHandlers } from "./event.js" let operationGroup = null export function pushOperation(op) { if (operationGroup) { operationGroup.ops.push(op) } else { op.ownsGroup = operationGroup = { ops: [op], delayedCallbacks: [] } } } function fireCallbacksForOps(group) { // Calls delayed callbacks and cursorActivity handlers until no // new ones appear let callbacks = group.delayedCallbacks, i = 0 do { for (; i < callbacks.length; i++) callbacks[i].call(null) for (let j = 0; j < group.ops.length; j++) { let op = group.ops[j] if (op.cursorActivityHandlers) while (op.cursorActivityCalled < op.cursorActivityHandlers.length) op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm) } } while (i < callbacks.length) } export function finishOperation(op, endCb) { let group = op.ownsGroup if (!group) return try { fireCallbacksForOps(group) } finally { operationGroup = null endCb(group) } } let orphanDelayedCallbacks = null // Often, we want to signal events at a point where we are in the // middle of some work, but don't want the handler to start calling // other methods on the editor, which might be in an inconsistent // state or simply not expect any other events to happen. // signalLater looks whether there are any handlers, and schedules // them to be executed when the last operation ends, or, if no // operation is active, when a timeout fires. export function signalLater(emitter, type /*, values...*/) { let arr = getHandlers(emitter, type) if (!arr.length) return let args = Array.prototype.slice.call(arguments, 2), list if (operationGroup) { list = operationGroup.delayedCallbacks } else if (orphanDelayedCallbacks) { list = orphanDelayedCallbacks } else { list = orphanDelayedCallbacks = [] setTimeout(fireOrphanDelayed, 0) } for (let i = 0; i < arr.length; ++i) list.push(() => arr[i].apply(null, args)) } function fireOrphanDelayed() { let delayed = orphanDelayedCallbacks orphanDelayedCallbacks = null for (let i = 0; i < delayed.length; ++i) delayed[i]() } PK �S�Z���<! <! src/util/bidi.jsnu �[��� import { lst } from "./misc.js" // BIDI HELPERS export function iterateBidiSections(order, from, to, f) { if (!order) return f(from, to, "ltr", 0) let found = false for (let i = 0; i < order.length; ++i) { let part = order[i] if (part.from < to && part.to > from || from == to && part.to == from) { f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr", i) found = true } } if (!found) f(from, to, "ltr") } export let bidiOther = null export function getBidiPartAt(order, ch, sticky) { let found bidiOther = null for (let i = 0; i < order.length; ++i) { let cur = order[i] if (cur.from < ch && cur.to > ch) return i if (cur.to == ch) { if (cur.from != cur.to && sticky == "before") found = i else bidiOther = i } if (cur.from == ch) { if (cur.from != cur.to && sticky != "before") found = i else bidiOther = i } } return found != null ? found : bidiOther } // Bidirectional ordering algorithm // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm // that this (partially) implements. // One-char codes used for character types: // L (L): Left-to-Right // R (R): Right-to-Left // r (AL): Right-to-Left Arabic // 1 (EN): European Number // + (ES): European Number Separator // % (ET): European Number Terminator // n (AN): Arabic Number // , (CS): Common Number Separator // m (NSM): Non-Spacing Mark // b (BN): Boundary Neutral // s (B): Paragraph Separator // t (S): Segment Separator // w (WS): Whitespace // N (ON): Other Neutrals // Returns null if characters are ordered as they appear // (left-to-right), or an array of sections ({from, to, level} // objects) in the order in which they occur visually. let bidiOrdering = (function() { // Character types for codepoints 0 to 0xff let lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN" // Character types for codepoints 0x600 to 0x6f9 let arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111" function charType(code) { if (code <= 0xf7) return lowTypes.charAt(code) else if (0x590 <= code && code <= 0x5f4) return "R" else if (0x600 <= code && code <= 0x6f9) return arabicTypes.charAt(code - 0x600) else if (0x6ee <= code && code <= 0x8ac) return "r" else if (0x2000 <= code && code <= 0x200b) return "w" else if (code == 0x200c) return "b" else return "L" } let bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/ let isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/ function BidiSpan(level, from, to) { this.level = level this.from = from; this.to = to } return function(str, direction) { let outerType = direction == "ltr" ? "L" : "R" if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) return false let len = str.length, types = [] for (let i = 0; i < len; ++i) types.push(charType(str.charCodeAt(i))) // W1. Examine each non-spacing mark (NSM) in the level run, and // change the type of the NSM to the type of the previous // character. If the NSM is at the start of the level run, it will // get the type of sor. for (let i = 0, prev = outerType; i < len; ++i) { let type = types[i] if (type == "m") types[i] = prev else prev = type } // W2. Search backwards from each instance of a European number // until the first strong type (R, L, AL, or sor) is found. If an // AL is found, change the type of the European number to Arabic // number. // W3. Change all ALs to R. for (let i = 0, cur = outerType; i < len; ++i) { let type = types[i] if (type == "1" && cur == "r") types[i] = "n" else if (isStrong.test(type)) { cur = type; if (type == "r") types[i] = "R" } } // W4. A single European separator between two European numbers // changes to a European number. A single common separator between // two numbers of the same type changes to that type. for (let i = 1, prev = types[0]; i < len - 1; ++i) { let type = types[i] if (type == "+" && prev == "1" && types[i+1] == "1") types[i] = "1" else if (type == "," && prev == types[i+1] && (prev == "1" || prev == "n")) types[i] = prev prev = type } // W5. A sequence of European terminators adjacent to European // numbers changes to all European numbers. // W6. Otherwise, separators and terminators change to Other // Neutral. for (let i = 0; i < len; ++i) { let type = types[i] if (type == ",") types[i] = "N" else if (type == "%") { let end for (end = i + 1; end < len && types[end] == "%"; ++end) {} let replace = (i && types[i-1] == "!") || (end < len && types[end] == "1") ? "1" : "N" for (let j = i; j < end; ++j) types[j] = replace i = end - 1 } } // W7. Search backwards from each instance of a European number // until the first strong type (R, L, or sor) is found. If an L is // found, then change the type of the European number to L. for (let i = 0, cur = outerType; i < len; ++i) { let type = types[i] if (cur == "L" && type == "1") types[i] = "L" else if (isStrong.test(type)) cur = type } // N1. A sequence of neutrals takes the direction of the // surrounding strong text if the text on both sides has the same // direction. European and Arabic numbers act as if they were R in // terms of their influence on neutrals. Start-of-level-run (sor) // and end-of-level-run (eor) are used at level run boundaries. // N2. Any remaining neutrals take the embedding direction. for (let i = 0; i < len; ++i) { if (isNeutral.test(types[i])) { let end for (end = i + 1; end < len && isNeutral.test(types[end]); ++end) {} let before = (i ? types[i-1] : outerType) == "L" let after = (end < len ? types[end] : outerType) == "L" let replace = before == after ? (before ? "L" : "R") : outerType for (let j = i; j < end; ++j) types[j] = replace i = end - 1 } } // Here we depart from the documented algorithm, in order to avoid // building up an actual levels array. Since there are only three // levels (0, 1, 2) in an implementation that doesn't take // explicit embedding into account, we can build up the order on // the fly, without following the level-based algorithm. let order = [], m for (let i = 0; i < len;) { if (countsAsLeft.test(types[i])) { let start = i for (++i; i < len && countsAsLeft.test(types[i]); ++i) {} order.push(new BidiSpan(0, start, i)) } else { let pos = i, at = order.length, isRTL = direction == "rtl" ? 1 : 0 for (++i; i < len && types[i] != "L"; ++i) {} for (let j = pos; j < i;) { if (countsAsNum.test(types[j])) { if (pos < j) { order.splice(at, 0, new BidiSpan(1, pos, j)); at += isRTL } let nstart = j for (++j; j < i && countsAsNum.test(types[j]); ++j) {} order.splice(at, 0, new BidiSpan(2, nstart, j)) at += isRTL pos = j } else ++j } if (pos < i) order.splice(at, 0, new BidiSpan(1, pos, i)) } } if (direction == "ltr") { if (order[0].level == 1 && (m = str.match(/^\s+/))) { order[0].from = m[0].length order.unshift(new BidiSpan(0, 0, m[0].length)) } if (lst(order).level == 1 && (m = str.match(/\s+$/))) { lst(order).to -= m[0].length order.push(new BidiSpan(0, len - m[0].length, len)) } } return direction == "rtl" ? order.reverse() : order } })() // Get the bidi ordering for the given line (and cache it). Returns // false for lines that are fully left-to-right, and an array of // BidiSpan objects otherwise. export function getOrder(line, direction) { let order = line.order if (order == null) order = line.order = bidiOrdering(line.text, direction) return order } PK �S�ZO�� � src/util/StringStream.jsnu �[��� import { countColumn } from "./misc.js" // STRING STREAM // Fed to the mode parsers, provides helper functions to make // parsers more succinct. class StringStream { constructor(string, tabSize, lineOracle) { this.pos = this.start = 0 this.string = string this.tabSize = tabSize || 8 this.lastColumnPos = this.lastColumnValue = 0 this.lineStart = 0 this.lineOracle = lineOracle } eol() {return this.pos >= this.string.length} sol() {return this.pos == this.lineStart} peek() {return this.string.charAt(this.pos) || undefined} next() { if (this.pos < this.string.length) return this.string.charAt(this.pos++) } eat(match) { let ch = this.string.charAt(this.pos) let ok if (typeof match == "string") ok = ch == match else ok = ch && (match.test ? match.test(ch) : match(ch)) if (ok) {++this.pos; return ch} } eatWhile(match) { let start = this.pos while (this.eat(match)){} return this.pos > start } eatSpace() { let start = this.pos while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos return this.pos > start } skipToEnd() {this.pos = this.string.length} skipTo(ch) { let found = this.string.indexOf(ch, this.pos) if (found > -1) {this.pos = found; return true} } backUp(n) {this.pos -= n} column() { if (this.lastColumnPos < this.start) { this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue) this.lastColumnPos = this.start } return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0) } indentation() { return countColumn(this.string, null, this.tabSize) - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0) } match(pattern, consume, caseInsensitive) { if (typeof pattern == "string") { let cased = str => caseInsensitive ? str.toLowerCase() : str let substr = this.string.substr(this.pos, pattern.length) if (cased(substr) == cased(pattern)) { if (consume !== false) this.pos += pattern.length return true } } else { let match = this.string.slice(this.pos).match(pattern) if (match && match.index > 0) return null if (match && consume !== false) this.pos += match[0].length return match } } current(){return this.string.slice(this.start, this.pos)} hideFirstChars(n, inner) { this.lineStart += n try { return inner() } finally { this.lineStart -= n } } lookAhead(n) { let oracle = this.lineOracle return oracle && oracle.lookAhead(n) } baseToken() { let oracle = this.lineOracle return oracle && oracle.baseToken(this.pos) } } export default StringStream PK �S�Z�~��� � src/util/feature_detection.jsnu �[��� import { elt, range, removeChildren, removeChildrenAndAdd } from "./dom.js" import { ie, ie_version } from "./browser.js" // Detect drag-and-drop export let dragAndDrop = function() { // There is *some* kind of drag-and-drop support in IE6-8, but I // couldn't get it to work yet. if (ie && ie_version < 9) return false let div = elt('div') return "draggable" in div || "dragDrop" in div }() let zwspSupported export function zeroWidthElement(measure) { if (zwspSupported == null) { let test = elt("span", "\u200b") removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")])) if (measure.firstChild.offsetHeight != 0) zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8) } let node = zwspSupported ? elt("span", "\u200b") : elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px") node.setAttribute("cm-text", "") return node } // Feature-detect IE's crummy client rect reporting for bidi text let badBidiRects export function hasBadBidiRects(measure) { if (badBidiRects != null) return badBidiRects let txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA")) let r0 = range(txt, 0, 1).getBoundingClientRect() let r1 = range(txt, 1, 2).getBoundingClientRect() removeChildren(measure) if (!r0 || r0.left == r0.right) return false // Safari returns null in some cases (#2780) return badBidiRects = (r1.right - r0.right < 3) } // See if "".split is the broken IE version, if so, provide an // alternative way to split lines. export let splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? string => { let pos = 0, result = [], l = string.length while (pos <= l) { let nl = string.indexOf("\n", pos) if (nl == -1) nl = string.length let line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl) let rt = line.indexOf("\r") if (rt != -1) { result.push(line.slice(0, rt)) pos += rt + 1 } else { result.push(line) pos = nl + 1 } } return result } : string => string.split(/\r\n?|\n/) export let hasSelection = window.getSelection ? te => { try { return te.selectionStart != te.selectionEnd } catch(e) { return false } } : te => { let range try {range = te.ownerDocument.selection.createRange()} catch(e) {} if (!range || range.parentElement() != te) return false return range.compareEndPoints("StartToEnd", range) != 0 } export let hasCopyEvent = (() => { let e = elt("div") if ("oncopy" in e) return true e.setAttribute("oncopy", "return;") return typeof e.oncopy == "function" })() let badZoomedRects = null export function hasBadZoomedRects(measure) { if (badZoomedRects != null) return badZoomedRects let node = removeChildrenAndAdd(measure, elt("span", "x")) let normal = node.getBoundingClientRect() let fromRange = range(node, 0, 1).getBoundingClientRect() return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1 } PK �S�ZL���� � src/model/document_data.jsnu �[��� import { loadMode } from "../display/mode_state.js" import { runInOp } from "../display/operations.js" import { regChange } from "../display/view_tracking.js" import { Line, updateLine } from "../line/line_data.js" import { findMaxLine } from "../line/spans.js" import { getLine } from "../line/utils_line.js" import { estimateLineHeights } from "../measurement/position_measurement.js" import { addClass, rmClass } from "../util/dom.js" import { lst } from "../util/misc.js" import { signalLater } from "../util/operation_group.js" // DOCUMENT DATA STRUCTURE // By default, updates that start and end at the beginning of a line // are treated specially, in order to make the association of line // widgets and marker elements with the text behave more intuitive. export function isWholeLineUpdate(doc, change) { return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" && (!doc.cm || doc.cm.options.wholeLineUpdateBefore) } // Perform a change on the document data structure. export function updateDoc(doc, change, markedSpans, estimateHeight) { function spansFor(n) {return markedSpans ? markedSpans[n] : null} function update(line, text, spans) { updateLine(line, text, spans, estimateHeight) signalLater(line, "change", line, change) } function linesFor(start, end) { let result = [] for (let i = start; i < end; ++i) result.push(new Line(text[i], spansFor(i), estimateHeight)) return result } let from = change.from, to = change.to, text = change.text let firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line) let lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line // Adjust the line structure if (change.full) { doc.insert(0, linesFor(0, text.length)) doc.remove(text.length, doc.size - text.length) } else if (isWholeLineUpdate(doc, change)) { // This is a whole-line replace. Treated specially to make // sure line objects move the way they are supposed to. let added = linesFor(0, text.length - 1) update(lastLine, lastLine.text, lastSpans) if (nlines) doc.remove(from.line, nlines) if (added.length) doc.insert(from.line, added) } else if (firstLine == lastLine) { if (text.length == 1) { update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans) } else { let added = linesFor(1, text.length - 1) added.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight)) update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)) doc.insert(from.line + 1, added) } } else if (text.length == 1) { update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0)) doc.remove(from.line + 1, nlines) } else { update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)) update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans) let added = linesFor(1, text.length - 1) if (nlines > 1) doc.remove(from.line + 1, nlines - 1) doc.insert(from.line + 1, added) } signalLater(doc, "change", doc, change) } // Call f for all linked documents. export function linkedDocs(doc, f, sharedHistOnly) { function propagate(doc, skip, sharedHist) { if (doc.linked) for (let i = 0; i < doc.linked.length; ++i) { let rel = doc.linked[i] if (rel.doc == skip) continue let shared = sharedHist && rel.sharedHist if (sharedHistOnly && !shared) continue f(rel.doc, shared) propagate(rel.doc, doc, shared) } } propagate(doc, null, true) } // Attach a document to an editor. export function attachDoc(cm, doc) { if (doc.cm) throw new Error("This document is already in use.") cm.doc = doc doc.cm = cm estimateLineHeights(cm) loadMode(cm) setDirectionClass(cm) if (!cm.options.lineWrapping) findMaxLine(cm) cm.options.mode = doc.modeOption regChange(cm) } function setDirectionClass(cm) { ;(cm.doc.direction == "rtl" ? addClass : rmClass)(cm.display.lineDiv, "CodeMirror-rtl") } export function directionChanged(cm) { runInOp(cm, () => { setDirectionClass(cm) regChange(cm) }) } PK �S�Z|���/ �/ src/model/changes.jsnu �[��� import { retreatFrontier } from "../line/highlight.js" import { startWorker } from "../display/highlight_worker.js" import { operation } from "../display/operations.js" import { regChange, regLineChange } from "../display/view_tracking.js" import { clipLine, clipPos, cmp, Pos } from "../line/pos.js" import { sawReadOnlySpans } from "../line/saw_special_spans.js" import { lineLength, removeReadOnlyRanges, stretchSpansOverChange, visualLine } from "../line/spans.js" import { getBetween, getLine, lineNo } from "../line/utils_line.js" import { estimateHeight } from "../measurement/position_measurement.js" import { hasHandler, signal, signalCursorActivity } from "../util/event.js" import { indexOf, lst, map, sel_dontScroll } from "../util/misc.js" import { signalLater } from "../util/operation_group.js" import { changeEnd, computeSelAfterChange } from "./change_measurement.js" import { isWholeLineUpdate, linkedDocs, updateDoc } from "./document_data.js" import { addChangeToHistory, historyChangeFromChange, mergeOldSpans, pushSelectionToHistory } from "./history.js" import { Range, Selection } from "./selection.js" import { setSelection, setSelectionNoUndo, skipAtomic } from "./selection_updates.js" // UPDATING // Allow "beforeChange" event handlers to influence a change function filterChange(doc, change, update) { let obj = { canceled: false, from: change.from, to: change.to, text: change.text, origin: change.origin, cancel: () => obj.canceled = true } if (update) obj.update = (from, to, text, origin) => { if (from) obj.from = clipPos(doc, from) if (to) obj.to = clipPos(doc, to) if (text) obj.text = text if (origin !== undefined) obj.origin = origin } signal(doc, "beforeChange", doc, obj) if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj) if (obj.canceled) { if (doc.cm) doc.cm.curOp.updateInput = 2 return null } return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin} } // Apply a change to a document, and add it to the document's // history, and propagating it to all linked documents. export function makeChange(doc, change, ignoreReadOnly) { if (doc.cm) { if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) if (doc.cm.state.suppressEdits) return } if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) { change = filterChange(doc, change, true) if (!change) return } // Possibly split or suppress the update based on the presence // of read-only spans in its range. let split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to) if (split) { for (let i = split.length - 1; i >= 0; --i) makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text, origin: change.origin}) } else { makeChangeInner(doc, change) } } function makeChangeInner(doc, change) { if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) return let selAfter = computeSelAfterChange(doc, change) addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN) makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change)) let rebased = [] linkedDocs(doc, (doc, sharedHist) => { if (!sharedHist && indexOf(rebased, doc.history) == -1) { rebaseHist(doc.history, change) rebased.push(doc.history) } makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change)) }) } // Revert a change stored in a document's history. export function makeChangeFromHistory(doc, type, allowSelectionOnly) { let suppress = doc.cm && doc.cm.state.suppressEdits if (suppress && !allowSelectionOnly) return let hist = doc.history, event, selAfter = doc.sel let source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done // Verify that there is a useable event (so that ctrl-z won't // needlessly clear selection events) let i = 0 for (; i < source.length; i++) { event = source[i] if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges) break } if (i == source.length) return hist.lastOrigin = hist.lastSelOrigin = null for (;;) { event = source.pop() if (event.ranges) { pushSelectionToHistory(event, dest) if (allowSelectionOnly && !event.equals(doc.sel)) { setSelection(doc, event, {clearRedo: false}) return } selAfter = event } else if (suppress) { source.push(event) return } else break } // Build up a reverse change object to add to the opposite history // stack (redo when undoing, and vice versa). let antiChanges = [] pushSelectionToHistory(selAfter, dest) dest.push({changes: antiChanges, generation: hist.generation}) hist.generation = event.generation || ++hist.maxGeneration let filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange") for (let i = event.changes.length - 1; i >= 0; --i) { let change = event.changes[i] change.origin = type if (filter && !filterChange(doc, change, false)) { source.length = 0 return } antiChanges.push(historyChangeFromChange(doc, change)) let after = i ? computeSelAfterChange(doc, change) : lst(source) makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change)) if (!i && doc.cm) doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}) let rebased = [] // Propagate to the linked documents linkedDocs(doc, (doc, sharedHist) => { if (!sharedHist && indexOf(rebased, doc.history) == -1) { rebaseHist(doc.history, change) rebased.push(doc.history) } makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change)) }) } } // Sub-views need their line numbers shifted when text is added // above or below them in the parent document. function shiftDoc(doc, distance) { if (distance == 0) return doc.first += distance doc.sel = new Selection(map(doc.sel.ranges, range => new Range( Pos(range.anchor.line + distance, range.anchor.ch), Pos(range.head.line + distance, range.head.ch) )), doc.sel.primIndex) if (doc.cm) { regChange(doc.cm, doc.first, doc.first - distance, distance) for (let d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++) regLineChange(doc.cm, l, "gutter") } } // More lower-level change function, handling only a single document // (not linked ones). function makeChangeSingleDoc(doc, change, selAfter, spans) { if (doc.cm && !doc.cm.curOp) return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) if (change.to.line < doc.first) { shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line)) return } if (change.from.line > doc.lastLine()) return // Clip the change to the size of this doc if (change.from.line < doc.first) { let shift = change.text.length - 1 - (doc.first - change.from.line) shiftDoc(doc, shift) change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch), text: [lst(change.text)], origin: change.origin} } let last = doc.lastLine() if (change.to.line > last) { change = {from: change.from, to: Pos(last, getLine(doc, last).text.length), text: [change.text[0]], origin: change.origin} } change.removed = getBetween(doc, change.from, change.to) if (!selAfter) selAfter = computeSelAfterChange(doc, change) if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans) else updateDoc(doc, change, spans) setSelectionNoUndo(doc, selAfter, sel_dontScroll) if (doc.cantEdit && skipAtomic(doc, Pos(doc.firstLine(), 0))) doc.cantEdit = false } // Handle the interaction of a change to a document with the editor // that this document is part of. function makeChangeSingleDocInEditor(cm, change, spans) { let doc = cm.doc, display = cm.display, from = change.from, to = change.to let recomputeMaxLength = false, checkWidthStart = from.line if (!cm.options.lineWrapping) { checkWidthStart = lineNo(visualLine(getLine(doc, from.line))) doc.iter(checkWidthStart, to.line + 1, line => { if (line == display.maxLine) { recomputeMaxLength = true return true } }) } if (doc.sel.contains(change.from, change.to) > -1) signalCursorActivity(cm) updateDoc(doc, change, spans, estimateHeight(cm)) if (!cm.options.lineWrapping) { doc.iter(checkWidthStart, from.line + change.text.length, line => { let len = lineLength(line) if (len > display.maxLineLength) { display.maxLine = line display.maxLineLength = len display.maxLineChanged = true recomputeMaxLength = false } }) if (recomputeMaxLength) cm.curOp.updateMaxLine = true } retreatFrontier(doc, from.line) startWorker(cm, 400) let lendiff = change.text.length - (to.line - from.line) - 1 // Remember that these lines changed, for updating the display if (change.full) regChange(cm) else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change)) regLineChange(cm, from.line, "text") else regChange(cm, from.line, to.line + 1, lendiff) let changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change") if (changeHandler || changesHandler) { let obj = { from: from, to: to, text: change.text, removed: change.removed, origin: change.origin } if (changeHandler) signalLater(cm, "change", cm, obj) if (changesHandler) (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj) } cm.display.selForContextMenu = null } export function replaceRange(doc, code, from, to, origin) { if (!to) to = from if (cmp(to, from) < 0) [from, to] = [to, from] if (typeof code == "string") code = doc.splitLines(code) makeChange(doc, {from, to, text: code, origin}) } // Rebasing/resetting history to deal with externally-sourced changes function rebaseHistSelSingle(pos, from, to, diff) { if (to < pos.line) { pos.line += diff } else if (from < pos.line) { pos.line = from pos.ch = 0 } } // Tries to rebase an array of history events given a change in the // document. If the change touches the same lines as the event, the // event, and everything 'behind' it, is discarded. If the change is // before the event, the event's positions are updated. Uses a // copy-on-write scheme for the positions, to avoid having to // reallocate them all on every rebase, but also avoid problems with // shared position objects being unsafely updated. function rebaseHistArray(array, from, to, diff) { for (let i = 0; i < array.length; ++i) { let sub = array[i], ok = true if (sub.ranges) { if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true } for (let j = 0; j < sub.ranges.length; j++) { rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff) rebaseHistSelSingle(sub.ranges[j].head, from, to, diff) } continue } for (let j = 0; j < sub.changes.length; ++j) { let cur = sub.changes[j] if (to < cur.from.line) { cur.from = Pos(cur.from.line + diff, cur.from.ch) cur.to = Pos(cur.to.line + diff, cur.to.ch) } else if (from <= cur.to.line) { ok = false break } } if (!ok) { array.splice(0, i + 1) i = 0 } } } function rebaseHist(hist, change) { let from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1 rebaseHistArray(hist.done, from, to, diff) rebaseHistArray(hist.undone, from, to, diff) } // Utility for applying a change to a line by handle or number, // returning the number and optionally registering the line as // changed. export function changeLine(doc, handle, changeType, op) { let no = handle, line = handle if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle)) else no = lineNo(handle) if (no == null) return null if (op(line, no) && doc.cm) regLineChange(doc.cm, no, changeType) return line } PK �S�Z=�?e e src/model/history.jsnu �[��� import { cmp, copyPos } from "../line/pos.js" import { stretchSpansOverChange } from "../line/spans.js" import { getBetween } from "../line/utils_line.js" import { signal } from "../util/event.js" import { indexOf, lst } from "../util/misc.js" import { changeEnd } from "./change_measurement.js" import { linkedDocs } from "./document_data.js" import { Selection } from "./selection.js" export function History(startGen) { // Arrays of change events and selections. Doing something adds an // event to done and clears undo. Undoing moves events from done // to undone, redoing moves them in the other direction. this.done = []; this.undone = [] this.undoDepth = Infinity // Used to track when changes can be merged into a single undo // event this.lastModTime = this.lastSelTime = 0 this.lastOp = this.lastSelOp = null this.lastOrigin = this.lastSelOrigin = null // Used by the isClean() method this.generation = this.maxGeneration = startGen || 1 } // Create a history change event from an updateDoc-style change // object. export function historyChangeFromChange(doc, change) { let histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)} attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1) linkedDocs(doc, doc => attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1), true) return histChange } // Pop all selection events off the end of a history array. Stop at // a change event. function clearSelectionEvents(array) { while (array.length) { let last = lst(array) if (last.ranges) array.pop() else break } } // Find the top change event in the history. Pop off selection // events that are in the way. function lastChangeEvent(hist, force) { if (force) { clearSelectionEvents(hist.done) return lst(hist.done) } else if (hist.done.length && !lst(hist.done).ranges) { return lst(hist.done) } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) { hist.done.pop() return lst(hist.done) } } // Register a change in the history. Merges changes that are within // a single operation, or are close together with an origin that // allows merging (starting with "+") into a single event. export function addChangeToHistory(doc, change, selAfter, opId) { let hist = doc.history hist.undone.length = 0 let time = +new Date, cur let last if ((hist.lastOp == opId || hist.lastOrigin == change.origin && change.origin && ((change.origin.charAt(0) == "+" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500)) || change.origin.charAt(0) == "*")) && (cur = lastChangeEvent(hist, hist.lastOp == opId))) { // Merge this change into the last event last = lst(cur.changes) if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) { // Optimized case for simple insertion -- don't want to add // new changesets for every character typed last.to = changeEnd(change) } else { // Add new sub-event cur.changes.push(historyChangeFromChange(doc, change)) } } else { // Can not be merged, start a new event. let before = lst(hist.done) if (!before || !before.ranges) pushSelectionToHistory(doc.sel, hist.done) cur = {changes: [historyChangeFromChange(doc, change)], generation: hist.generation} hist.done.push(cur) while (hist.done.length > hist.undoDepth) { hist.done.shift() if (!hist.done[0].ranges) hist.done.shift() } } hist.done.push(selAfter) hist.generation = ++hist.maxGeneration hist.lastModTime = hist.lastSelTime = time hist.lastOp = hist.lastSelOp = opId hist.lastOrigin = hist.lastSelOrigin = change.origin if (!last) signal(doc, "historyAdded") } function selectionEventCanBeMerged(doc, origin, prev, sel) { let ch = origin.charAt(0) return ch == "*" || ch == "+" && prev.ranges.length == sel.ranges.length && prev.somethingSelected() == sel.somethingSelected() && new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500) } // Called whenever the selection changes, sets the new selection as // the pending selection in the history, and pushes the old pending // selection into the 'done' array when it was significantly // different (in number of selected ranges, emptiness, or time). export function addSelectionToHistory(doc, sel, opId, options) { let hist = doc.history, origin = options && options.origin // A new event is started when the previous origin does not match // the current, or the origins don't allow matching. Origins // starting with * are always merged, those starting with + are // merged when similar and close together in time. if (opId == hist.lastSelOp || (origin && hist.lastSelOrigin == origin && (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin || selectionEventCanBeMerged(doc, origin, lst(hist.done), sel)))) hist.done[hist.done.length - 1] = sel else pushSelectionToHistory(sel, hist.done) hist.lastSelTime = +new Date hist.lastSelOrigin = origin hist.lastSelOp = opId if (options && options.clearRedo !== false) clearSelectionEvents(hist.undone) } export function pushSelectionToHistory(sel, dest) { let top = lst(dest) if (!(top && top.ranges && top.equals(sel))) dest.push(sel) } // Used to store marked span information in the history. function attachLocalSpans(doc, change, from, to) { let existing = change["spans_" + doc.id], n = 0 doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), line => { if (line.markedSpans) (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans ++n }) } // When un/re-doing restores text containing marked spans, those // that have been explicitly cleared should not be restored. function removeClearedSpans(spans) { if (!spans) return null let out for (let i = 0; i < spans.length; ++i) { if (spans[i].marker.explicitlyCleared) { if (!out) out = spans.slice(0, i) } else if (out) out.push(spans[i]) } return !out ? spans : out.length ? out : null } // Retrieve and filter the old marked spans stored in a change event. function getOldSpans(doc, change) { let found = change["spans_" + doc.id] if (!found) return null let nw = [] for (let i = 0; i < change.text.length; ++i) nw.push(removeClearedSpans(found[i])) return nw } // Used for un/re-doing changes from the history. Combines the // result of computing the existing spans with the set of spans that // existed in the history (so that deleting around a span and then // undoing brings back the span). export function mergeOldSpans(doc, change) { let old = getOldSpans(doc, change) let stretched = stretchSpansOverChange(doc, change) if (!old) return stretched if (!stretched) return old for (let i = 0; i < old.length; ++i) { let oldCur = old[i], stretchCur = stretched[i] if (oldCur && stretchCur) { spans: for (let j = 0; j < stretchCur.length; ++j) { let span = stretchCur[j] for (let k = 0; k < oldCur.length; ++k) if (oldCur[k].marker == span.marker) continue spans oldCur.push(span) } } else if (stretchCur) { old[i] = stretchCur } } return old } // Used both to provide a JSON-safe object in .getHistory, and, when // detaching a document, to split the history in two export function copyHistoryArray(events, newGroup, instantiateSel) { let copy = [] for (let i = 0; i < events.length; ++i) { let event = events[i] if (event.ranges) { copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event) continue } let changes = event.changes, newChanges = [] copy.push({changes: newChanges}) for (let j = 0; j < changes.length; ++j) { let change = changes[j], m newChanges.push({from: change.from, to: change.to, text: change.text}) if (newGroup) for (var prop in change) if (m = prop.match(/^spans_(\d+)$/)) { if (indexOf(newGroup, Number(m[1])) > -1) { lst(newChanges)[prop] = change[prop] delete change[prop] } } } } return copy } PK �S�ZGV��[ [ src/model/selection_updates.jsnu �[��� import { signalLater } from "../util/operation_group.js" import { ensureCursorVisible } from "../display/scrolling.js" import { clipPos, cmp, Pos } from "../line/pos.js" import { getLine } from "../line/utils_line.js" import { hasHandler, signal, signalCursorActivity } from "../util/event.js" import { lst, sel_dontScroll } from "../util/misc.js" import { addSelectionToHistory } from "./history.js" import { normalizeSelection, Range, Selection, simpleSelection } from "./selection.js" // The 'scroll' parameter given to many of these indicated whether // the new cursor position should be scrolled into view after // modifying the selection. // If shift is held or the extend flag is set, extends a range to // include a given position (and optionally a second position). // Otherwise, simply returns the range between the given positions. // Used for cursor motion and such. export function extendRange(range, head, other, extend) { if (extend) { let anchor = range.anchor if (other) { let posBefore = cmp(head, anchor) < 0 if (posBefore != (cmp(other, anchor) < 0)) { anchor = head head = other } else if (posBefore != (cmp(head, other) < 0)) { head = other } } return new Range(anchor, head) } else { return new Range(other || head, head) } } // Extend the primary selection range, discard the rest. export function extendSelection(doc, head, other, options, extend) { if (extend == null) extend = doc.cm && (doc.cm.display.shift || doc.extend) setSelection(doc, new Selection([extendRange(doc.sel.primary(), head, other, extend)], 0), options) } // Extend all selections (pos is an array of selections with length // equal the number of selections) export function extendSelections(doc, heads, options) { let out = [] let extend = doc.cm && (doc.cm.display.shift || doc.extend) for (let i = 0; i < doc.sel.ranges.length; i++) out[i] = extendRange(doc.sel.ranges[i], heads[i], null, extend) let newSel = normalizeSelection(doc.cm, out, doc.sel.primIndex) setSelection(doc, newSel, options) } // Updates a single range in the selection. export function replaceOneSelection(doc, i, range, options) { let ranges = doc.sel.ranges.slice(0) ranges[i] = range setSelection(doc, normalizeSelection(doc.cm, ranges, doc.sel.primIndex), options) } // Reset the selection to a single range. export function setSimpleSelection(doc, anchor, head, options) { setSelection(doc, simpleSelection(anchor, head), options) } // Give beforeSelectionChange handlers a change to influence a // selection update. function filterSelectionChange(doc, sel, options) { let obj = { ranges: sel.ranges, update: function(ranges) { this.ranges = [] for (let i = 0; i < ranges.length; i++) this.ranges[i] = new Range(clipPos(doc, ranges[i].anchor), clipPos(doc, ranges[i].head)) }, origin: options && options.origin } signal(doc, "beforeSelectionChange", doc, obj) if (doc.cm) signal(doc.cm, "beforeSelectionChange", doc.cm, obj) if (obj.ranges != sel.ranges) return normalizeSelection(doc.cm, obj.ranges, obj.ranges.length - 1) else return sel } export function setSelectionReplaceHistory(doc, sel, options) { let done = doc.history.done, last = lst(done) if (last && last.ranges) { done[done.length - 1] = sel setSelectionNoUndo(doc, sel, options) } else { setSelection(doc, sel, options) } } // Set a new selection. export function setSelection(doc, sel, options) { setSelectionNoUndo(doc, sel, options) addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options) } export function setSelectionNoUndo(doc, sel, options) { if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange")) sel = filterSelectionChange(doc, sel, options) let bias = options && options.bias || (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1) setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true)) if (!(options && options.scroll === false) && doc.cm) ensureCursorVisible(doc.cm) } function setSelectionInner(doc, sel) { if (sel.equals(doc.sel)) return doc.sel = sel if (doc.cm) { doc.cm.curOp.updateInput = 1 doc.cm.curOp.selectionChanged = true signalCursorActivity(doc.cm) } signalLater(doc, "cursorActivity", doc) } // Verify that the selection does not partially select any atomic // marked ranges. export function reCheckSelection(doc) { setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false)) } // Return a selection that does not partially select any atomic // ranges. function skipAtomicInSelection(doc, sel, bias, mayClear) { let out for (let i = 0; i < sel.ranges.length; i++) { let range = sel.ranges[i] let old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i] let newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear) let newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear) if (out || newAnchor != range.anchor || newHead != range.head) { if (!out) out = sel.ranges.slice(0, i) out[i] = new Range(newAnchor, newHead) } } return out ? normalizeSelection(doc.cm, out, sel.primIndex) : sel } function skipAtomicInner(doc, pos, oldPos, dir, mayClear) { let line = getLine(doc, pos.line) if (line.markedSpans) for (let i = 0; i < line.markedSpans.length; ++i) { let sp = line.markedSpans[i], m = sp.marker // Determine if we should prevent the cursor being placed to the left/right of an atomic marker // Historically this was determined using the inclusiveLeft/Right option, but the new way to control it // is with selectLeft/Right let preventCursorLeft = ("selectLeft" in m) ? !m.selectLeft : m.inclusiveLeft let preventCursorRight = ("selectRight" in m) ? !m.selectRight : m.inclusiveRight if ((sp.from == null || (preventCursorLeft ? sp.from <= pos.ch : sp.from < pos.ch)) && (sp.to == null || (preventCursorRight ? sp.to >= pos.ch : sp.to > pos.ch))) { if (mayClear) { signal(m, "beforeCursorEnter") if (m.explicitlyCleared) { if (!line.markedSpans) break else {--i; continue} } } if (!m.atomic) continue if (oldPos) { let near = m.find(dir < 0 ? 1 : -1), diff if (dir < 0 ? preventCursorRight : preventCursorLeft) near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null) if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0)) return skipAtomicInner(doc, near, pos, dir, mayClear) } let far = m.find(dir < 0 ? -1 : 1) if (dir < 0 ? preventCursorLeft : preventCursorRight) far = movePos(doc, far, dir, far.line == pos.line ? line : null) return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null } } return pos } // Ensure a given position is not inside an atomic range. export function skipAtomic(doc, pos, oldPos, bias, mayClear) { let dir = bias || 1 let found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) || (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) || skipAtomicInner(doc, pos, oldPos, -dir, mayClear) || (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true)) if (!found) { doc.cantEdit = true return Pos(doc.first, 0) } return found } function movePos(doc, pos, dir, line) { if (dir < 0 && pos.ch == 0) { if (pos.line > doc.first) return clipPos(doc, Pos(pos.line - 1)) else return null } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) { if (pos.line < doc.first + doc.size - 1) return Pos(pos.line + 1, 0) else return null } else { return new Pos(pos.line, pos.ch + dir) } } export function selectAll(cm) { cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll) } PK �S�Z{�v�: : src/model/line_widget.jsnu �[��� import { runInOp } from "../display/operations.js" import { addToScrollTop } from "../display/scrolling.js" import { regLineChange } from "../display/view_tracking.js" import { heightAtLine, lineIsHidden } from "../line/spans.js" import { lineNo, updateLineHeight } from "../line/utils_line.js" import { widgetHeight } from "../measurement/widgets.js" import { changeLine } from "./changes.js" import { eventMixin } from "../util/event.js" import { signalLater } from "../util/operation_group.js" // Line widgets are block elements displayed above or below a line. export class LineWidget { constructor(doc, node, options) { if (options) for (let opt in options) if (options.hasOwnProperty(opt)) this[opt] = options[opt] this.doc = doc this.node = node } clear() { let cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line) if (no == null || !ws) return for (let i = 0; i < ws.length; ++i) if (ws[i] == this) ws.splice(i--, 1) if (!ws.length) line.widgets = null let height = widgetHeight(this) updateLineHeight(line, Math.max(0, line.height - height)) if (cm) { runInOp(cm, () => { adjustScrollWhenAboveVisible(cm, line, -height) regLineChange(cm, no, "widget") }) signalLater(cm, "lineWidgetCleared", cm, this, no) } } changed() { let oldH = this.height, cm = this.doc.cm, line = this.line this.height = null let diff = widgetHeight(this) - oldH if (!diff) return if (!lineIsHidden(this.doc, line)) updateLineHeight(line, line.height + diff) if (cm) { runInOp(cm, () => { cm.curOp.forceUpdate = true adjustScrollWhenAboveVisible(cm, line, diff) signalLater(cm, "lineWidgetChanged", cm, this, lineNo(line)) }) } } } eventMixin(LineWidget) function adjustScrollWhenAboveVisible(cm, line, diff) { if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop)) addToScrollTop(cm, diff) } export function addLineWidget(doc, handle, node, options) { let widget = new LineWidget(doc, node, options) let cm = doc.cm if (cm && widget.noHScroll) cm.display.alignWidgets = true changeLine(doc, handle, "widget", line => { let widgets = line.widgets || (line.widgets = []) if (widget.insertAt == null) widgets.push(widget) else widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget) widget.line = line if (cm && !lineIsHidden(doc, line)) { let aboveVisible = heightAtLine(line) < doc.scrollTop updateLineHeight(line, line.height + widgetHeight(widget)) if (aboveVisible) addToScrollTop(cm, widget.height) cm.curOp.forceUpdate = true } return true }) if (cm) signalLater(cm, "lineWidgetAdded", cm, widget, typeof handle == "number" ? handle : lineNo(handle)) return widget } PK �S�Z��g� � src/model/change_measurement.jsnu �[��� import { cmp, Pos } from "../line/pos.js" import { lst } from "../util/misc.js" import { normalizeSelection, Range, Selection } from "./selection.js" // Compute the position of the end of a change (its 'to' property // refers to the pre-change end). export function changeEnd(change) { if (!change.text) return change.to return Pos(change.from.line + change.text.length - 1, lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0)) } // Adjust a position to refer to the post-change position of the // same text, or the end of the change if the change covers it. function adjustForChange(pos, change) { if (cmp(pos, change.from) < 0) return pos if (cmp(pos, change.to) <= 0) return changeEnd(change) let line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch if (pos.line == change.to.line) ch += changeEnd(change).ch - change.to.ch return Pos(line, ch) } export function computeSelAfterChange(doc, change) { let out = [] for (let i = 0; i < doc.sel.ranges.length; i++) { let range = doc.sel.ranges[i] out.push(new Range(adjustForChange(range.anchor, change), adjustForChange(range.head, change))) } return normalizeSelection(doc.cm, out, doc.sel.primIndex) } function offsetPos(pos, old, nw) { if (pos.line == old.line) return Pos(nw.line, pos.ch - old.ch + nw.ch) else return Pos(nw.line + (pos.line - old.line), pos.ch) } // Used by replaceSelections to allow moving the selection to the // start or around the replaced test. Hint may be "start" or "around". export function computeReplacedSel(doc, changes, hint) { let out = [] let oldPrev = Pos(doc.first, 0), newPrev = oldPrev for (let i = 0; i < changes.length; i++) { let change = changes[i] let from = offsetPos(change.from, oldPrev, newPrev) let to = offsetPos(changeEnd(change), oldPrev, newPrev) oldPrev = change.to newPrev = to if (hint == "around") { let range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0 out[i] = new Range(inv ? to : from, inv ? from : to) } else { out[i] = new Range(from, from) } } return new Selection(out, doc.sel.primIndex) } PK �S�Zaʋ�V V src/model/selection.jsnu �[��� import { cmp, copyPos, equalCursorPos, maxPos, minPos } from "../line/pos.js" import { indexOf } from "../util/misc.js" // Selection objects are immutable. A new one is created every time // the selection changes. A selection is one or more non-overlapping // (and non-touching) ranges, sorted, and an integer that indicates // which one is the primary selection (the one that's scrolled into // view, that getCursor returns, etc). export class Selection { constructor(ranges, primIndex) { this.ranges = ranges this.primIndex = primIndex } primary() { return this.ranges[this.primIndex] } equals(other) { if (other == this) return true if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) return false for (let i = 0; i < this.ranges.length; i++) { let here = this.ranges[i], there = other.ranges[i] if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) return false } return true } deepCopy() { let out = [] for (let i = 0; i < this.ranges.length; i++) out[i] = new Range(copyPos(this.ranges[i].anchor), copyPos(this.ranges[i].head)) return new Selection(out, this.primIndex) } somethingSelected() { for (let i = 0; i < this.ranges.length; i++) if (!this.ranges[i].empty()) return true return false } contains(pos, end) { if (!end) end = pos for (let i = 0; i < this.ranges.length; i++) { let range = this.ranges[i] if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0) return i } return -1 } } export class Range { constructor(anchor, head) { this.anchor = anchor; this.head = head } from() { return minPos(this.anchor, this.head) } to() { return maxPos(this.anchor, this.head) } empty() { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch } } // Take an unsorted, potentially overlapping set of ranges, and // build a selection out of it. 'Consumes' ranges array (modifying // it). export function normalizeSelection(cm, ranges, primIndex) { let mayTouch = cm && cm.options.selectionsMayTouch let prim = ranges[primIndex] ranges.sort((a, b) => cmp(a.from(), b.from())) primIndex = indexOf(ranges, prim) for (let i = 1; i < ranges.length; i++) { let cur = ranges[i], prev = ranges[i - 1] let diff = cmp(prev.to(), cur.from()) if (mayTouch && !cur.empty() ? diff > 0 : diff >= 0) { let from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to()) let inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head if (i <= primIndex) --primIndex ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to)) } } return new Selection(ranges, primIndex) } export function simpleSelection(anchor, head) { return new Selection([new Range(anchor, head || anchor)], 0) } PK �S�Z�]�L� � src/model/chunk.jsnu �[��� import { cleanUpLine } from "../line/line_data.js" import { indexOf } from "../util/misc.js" import { signalLater } from "../util/operation_group.js" // The document is represented as a BTree consisting of leaves, with // chunk of lines in them, and branches, with up to ten leaves or // other branch nodes below them. The top node is always a branch // node, and is the document object itself (meaning it has // additional methods and properties). // // All nodes have parent links. The tree is used both to go from // line numbers to line objects, and to go from objects to numbers. // It also indexes by height, and is used to convert between height // and line object, and to find the total height of the document. // // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html export function LeafChunk(lines) { this.lines = lines this.parent = null let height = 0 for (let i = 0; i < lines.length; ++i) { lines[i].parent = this height += lines[i].height } this.height = height } LeafChunk.prototype = { chunkSize() { return this.lines.length }, // Remove the n lines at offset 'at'. removeInner(at, n) { for (let i = at, e = at + n; i < e; ++i) { let line = this.lines[i] this.height -= line.height cleanUpLine(line) signalLater(line, "delete") } this.lines.splice(at, n) }, // Helper used to collapse a small branch into a single leaf. collapse(lines) { lines.push.apply(lines, this.lines) }, // Insert the given array of lines at offset 'at', count them as // having the given height. insertInner(at, lines, height) { this.height += height this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at)) for (let i = 0; i < lines.length; ++i) lines[i].parent = this }, // Used to iterate over a part of the tree. iterN(at, n, op) { for (let e = at + n; at < e; ++at) if (op(this.lines[at])) return true } } export function BranchChunk(children) { this.children = children let size = 0, height = 0 for (let i = 0; i < children.length; ++i) { let ch = children[i] size += ch.chunkSize(); height += ch.height ch.parent = this } this.size = size this.height = height this.parent = null } BranchChunk.prototype = { chunkSize() { return this.size }, removeInner(at, n) { this.size -= n for (let i = 0; i < this.children.length; ++i) { let child = this.children[i], sz = child.chunkSize() if (at < sz) { let rm = Math.min(n, sz - at), oldHeight = child.height child.removeInner(at, rm) this.height -= oldHeight - child.height if (sz == rm) { this.children.splice(i--, 1); child.parent = null } if ((n -= rm) == 0) break at = 0 } else at -= sz } // If the result is smaller than 25 lines, ensure that it is a // single leaf node. if (this.size - n < 25 && (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) { let lines = [] this.collapse(lines) this.children = [new LeafChunk(lines)] this.children[0].parent = this } }, collapse(lines) { for (let i = 0; i < this.children.length; ++i) this.children[i].collapse(lines) }, insertInner(at, lines, height) { this.size += lines.length this.height += height for (let i = 0; i < this.children.length; ++i) { let child = this.children[i], sz = child.chunkSize() if (at <= sz) { child.insertInner(at, lines, height) if (child.lines && child.lines.length > 50) { // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced. // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest. let remaining = child.lines.length % 25 + 25 for (let pos = remaining; pos < child.lines.length;) { let leaf = new LeafChunk(child.lines.slice(pos, pos += 25)) child.height -= leaf.height this.children.splice(++i, 0, leaf) leaf.parent = this } child.lines = child.lines.slice(0, remaining) this.maybeSpill() } break } at -= sz } }, // When a node has grown, check whether it should be split. maybeSpill() { if (this.children.length <= 10) return let me = this do { let spilled = me.children.splice(me.children.length - 5, 5) let sibling = new BranchChunk(spilled) if (!me.parent) { // Become the parent node let copy = new BranchChunk(me.children) copy.parent = me me.children = [copy, sibling] me = copy } else { me.size -= sibling.size me.height -= sibling.height let myIndex = indexOf(me.parent.children, me) me.parent.children.splice(myIndex + 1, 0, sibling) } sibling.parent = me.parent } while (me.children.length > 10) me.parent.maybeSpill() }, iterN(at, n, op) { for (let i = 0; i < this.children.length; ++i) { let child = this.children[i], sz = child.chunkSize() if (at < sz) { let used = Math.min(n, sz - at) if (child.iterN(at, used, op)) return true if ((n -= used) == 0) break at = 0 } else at -= sz } } } PK �S�Z�h$�+ �+ src/model/mark_text.jsnu �[��� import { eltP } from "../util/dom.js" import { eventMixin, hasHandler, on } from "../util/event.js" import { endOperation, operation, runInOp, startOperation } from "../display/operations.js" import { clipPos, cmp, Pos } from "../line/pos.js" import { lineNo, updateLineHeight } from "../line/utils_line.js" import { clearLineMeasurementCacheFor, findViewForLine, textHeight } from "../measurement/position_measurement.js" import { seeReadOnlySpans, seeCollapsedSpans } from "../line/saw_special_spans.js" import { addMarkedSpan, conflictingCollapsedRange, getMarkedSpanFor, lineIsHidden, lineLength, MarkedSpan, removeMarkedSpan, visualLine } from "../line/spans.js" import { copyObj, indexOf, lst } from "../util/misc.js" import { signalLater } from "../util/operation_group.js" import { widgetHeight } from "../measurement/widgets.js" import { regChange, regLineChange } from "../display/view_tracking.js" import { linkedDocs } from "./document_data.js" import { addChangeToHistory } from "./history.js" import { reCheckSelection } from "./selection_updates.js" // TEXTMARKERS // Created with markText and setBookmark methods. A TextMarker is a // handle that can be used to clear or find a marked position in the // document. Line objects hold arrays (markedSpans) containing // {from, to, marker} object pointing to such marker objects, and // indicating that such a marker is present on that line. Multiple // lines may point to the same marker when it spans across lines. // The spans will have null for their from/to properties when the // marker continues beyond the start/end of the line. Markers have // links back to the lines they currently touch. // Collapsed markers have unique ids, in order to be able to order // them, which is needed for uniquely determining an outer marker // when they overlap (they may nest, but not partially overlap). let nextMarkerId = 0 export class TextMarker { constructor(doc, type) { this.lines = [] this.type = type this.doc = doc this.id = ++nextMarkerId } // Clear the marker. clear() { if (this.explicitlyCleared) return let cm = this.doc.cm, withOp = cm && !cm.curOp if (withOp) startOperation(cm) if (hasHandler(this, "clear")) { let found = this.find() if (found) signalLater(this, "clear", found.from, found.to) } let min = null, max = null for (let i = 0; i < this.lines.length; ++i) { let line = this.lines[i] let span = getMarkedSpanFor(line.markedSpans, this) if (cm && !this.collapsed) regLineChange(cm, lineNo(line), "text") else if (cm) { if (span.to != null) max = lineNo(line) if (span.from != null) min = lineNo(line) } line.markedSpans = removeMarkedSpan(line.markedSpans, span) if (span.from == null && this.collapsed && !lineIsHidden(this.doc, line) && cm) updateLineHeight(line, textHeight(cm.display)) } if (cm && this.collapsed && !cm.options.lineWrapping) for (let i = 0; i < this.lines.length; ++i) { let visual = visualLine(this.lines[i]), len = lineLength(visual) if (len > cm.display.maxLineLength) { cm.display.maxLine = visual cm.display.maxLineLength = len cm.display.maxLineChanged = true } } if (min != null && cm && this.collapsed) regChange(cm, min, max + 1) this.lines.length = 0 this.explicitlyCleared = true if (this.atomic && this.doc.cantEdit) { this.doc.cantEdit = false if (cm) reCheckSelection(cm.doc) } if (cm) signalLater(cm, "markerCleared", cm, this, min, max) if (withOp) endOperation(cm) if (this.parent) this.parent.clear() } // Find the position of the marker in the document. Returns a {from, // to} object by default. Side can be passed to get a specific side // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the // Pos objects returned contain a line object, rather than a line // number (used to prevent looking up the same line twice). find(side, lineObj) { if (side == null && this.type == "bookmark") side = 1 let from, to for (let i = 0; i < this.lines.length; ++i) { let line = this.lines[i] let span = getMarkedSpanFor(line.markedSpans, this) if (span.from != null) { from = Pos(lineObj ? line : lineNo(line), span.from) if (side == -1) return from } if (span.to != null) { to = Pos(lineObj ? line : lineNo(line), span.to) if (side == 1) return to } } return from && {from: from, to: to} } // Signals that the marker's widget changed, and surrounding layout // should be recomputed. changed() { let pos = this.find(-1, true), widget = this, cm = this.doc.cm if (!pos || !cm) return runInOp(cm, () => { let line = pos.line, lineN = lineNo(pos.line) let view = findViewForLine(cm, lineN) if (view) { clearLineMeasurementCacheFor(view) cm.curOp.selectionChanged = cm.curOp.forceUpdate = true } cm.curOp.updateMaxLine = true if (!lineIsHidden(widget.doc, line) && widget.height != null) { let oldHeight = widget.height widget.height = null let dHeight = widgetHeight(widget) - oldHeight if (dHeight) updateLineHeight(line, line.height + dHeight) } signalLater(cm, "markerChanged", cm, this) }) } attachLine(line) { if (!this.lines.length && this.doc.cm) { let op = this.doc.cm.curOp if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1) (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this) } this.lines.push(line) } detachLine(line) { this.lines.splice(indexOf(this.lines, line), 1) if (!this.lines.length && this.doc.cm) { let op = this.doc.cm.curOp ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this) } } } eventMixin(TextMarker) // Create a marker, wire it up to the right lines, and export function markText(doc, from, to, options, type) { // Shared markers (across linked documents) are handled separately // (markTextShared will call out to this again, once per // document). if (options && options.shared) return markTextShared(doc, from, to, options, type) // Ensure we are in an operation. if (doc.cm && !doc.cm.curOp) return operation(doc.cm, markText)(doc, from, to, options, type) let marker = new TextMarker(doc, type), diff = cmp(from, to) if (options) copyObj(options, marker, false) // Don't connect empty markers unless clearWhenEmpty is false if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false) return marker if (marker.replacedWith) { // Showing up as a widget implies collapsed (widget replaces text) marker.collapsed = true marker.widgetNode = eltP("span", [marker.replacedWith], "CodeMirror-widget") if (!options.handleMouseEvents) marker.widgetNode.setAttribute("cm-ignore-events", "true") if (options.insertLeft) marker.widgetNode.insertLeft = true } if (marker.collapsed) { if (conflictingCollapsedRange(doc, from.line, from, to, marker) || from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker)) throw new Error("Inserting collapsed marker partially overlapping an existing one") seeCollapsedSpans() } if (marker.addToHistory) addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN) let curLine = from.line, cm = doc.cm, updateMaxLine doc.iter(curLine, to.line + 1, line => { if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine) updateMaxLine = true if (marker.collapsed && curLine != from.line) updateLineHeight(line, 0) addMarkedSpan(line, new MarkedSpan(marker, curLine == from.line ? from.ch : null, curLine == to.line ? to.ch : null)) ++curLine }) // lineIsHidden depends on the presence of the spans, so needs a second pass if (marker.collapsed) doc.iter(from.line, to.line + 1, line => { if (lineIsHidden(doc, line)) updateLineHeight(line, 0) }) if (marker.clearOnEnter) on(marker, "beforeCursorEnter", () => marker.clear()) if (marker.readOnly) { seeReadOnlySpans() if (doc.history.done.length || doc.history.undone.length) doc.clearHistory() } if (marker.collapsed) { marker.id = ++nextMarkerId marker.atomic = true } if (cm) { // Sync editor state if (updateMaxLine) cm.curOp.updateMaxLine = true if (marker.collapsed) regChange(cm, from.line, to.line + 1) else if (marker.className || marker.startStyle || marker.endStyle || marker.css || marker.attributes || marker.title) for (let i = from.line; i <= to.line; i++) regLineChange(cm, i, "text") if (marker.atomic) reCheckSelection(cm.doc) signalLater(cm, "markerAdded", cm, marker) } return marker } // SHARED TEXTMARKERS // A shared marker spans multiple linked documents. It is // implemented as a meta-marker-object controlling multiple normal // markers. export class SharedTextMarker { constructor(markers, primary) { this.markers = markers this.primary = primary for (let i = 0; i < markers.length; ++i) markers[i].parent = this } clear() { if (this.explicitlyCleared) return this.explicitlyCleared = true for (let i = 0; i < this.markers.length; ++i) this.markers[i].clear() signalLater(this, "clear") } find(side, lineObj) { return this.primary.find(side, lineObj) } } eventMixin(SharedTextMarker) function markTextShared(doc, from, to, options, type) { options = copyObj(options) options.shared = false let markers = [markText(doc, from, to, options, type)], primary = markers[0] let widget = options.widgetNode linkedDocs(doc, doc => { if (widget) options.widgetNode = widget.cloneNode(true) markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type)) for (let i = 0; i < doc.linked.length; ++i) if (doc.linked[i].isParent) return primary = lst(markers) }) return new SharedTextMarker(markers, primary) } export function findSharedMarkers(doc) { return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), m => m.parent) } export function copySharedMarkers(doc, markers) { for (let i = 0; i < markers.length; i++) { let marker = markers[i], pos = marker.find() let mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to) if (cmp(mFrom, mTo)) { let subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type) marker.markers.push(subMark) subMark.parent = marker } } } export function detachSharedMarkers(markers) { for (let i = 0; i < markers.length; i++) { let marker = markers[i], linked = [marker.primary.doc] linkedDocs(marker.primary.doc, d => linked.push(d)) for (let j = 0; j < marker.markers.length; j++) { let subMarker = marker.markers[j] if (indexOf(linked, subMarker.doc) == -1) { subMarker.parent = null marker.markers.splice(j--, 1) } } } } PK �S�ZS�js�C �C src/model/Doc.jsnu �[��� import CodeMirror from "../edit/CodeMirror.js" import { docMethodOp } from "../display/operations.js" import { Line } from "../line/line_data.js" import { clipPos, clipPosArray, Pos } from "../line/pos.js" import { visualLine } from "../line/spans.js" import { getBetween, getLine, getLines, isLine, lineNo } from "../line/utils_line.js" import { classTest } from "../util/dom.js" import { splitLinesAuto } from "../util/feature_detection.js" import { createObj, map, isEmpty, sel_dontScroll } from "../util/misc.js" import { ensureCursorVisible, scrollToCoords } from "../display/scrolling.js" import { changeLine, makeChange, makeChangeFromHistory, replaceRange } from "./changes.js" import { computeReplacedSel } from "./change_measurement.js" import { BranchChunk, LeafChunk } from "./chunk.js" import { directionChanged, linkedDocs, updateDoc } from "./document_data.js" import { copyHistoryArray, History } from "./history.js" import { addLineWidget } from "./line_widget.js" import { copySharedMarkers, detachSharedMarkers, findSharedMarkers, markText } from "./mark_text.js" import { normalizeSelection, Range, simpleSelection } from "./selection.js" import { extendSelection, extendSelections, setSelection, setSelectionReplaceHistory, setSimpleSelection } from "./selection_updates.js" let nextDocId = 0 let Doc = function(text, mode, firstLine, lineSep, direction) { if (!(this instanceof Doc)) return new Doc(text, mode, firstLine, lineSep, direction) if (firstLine == null) firstLine = 0 BranchChunk.call(this, [new LeafChunk([new Line("", null)])]) this.first = firstLine this.scrollTop = this.scrollLeft = 0 this.cantEdit = false this.cleanGeneration = 1 this.modeFrontier = this.highlightFrontier = firstLine let start = Pos(firstLine, 0) this.sel = simpleSelection(start) this.history = new History(null) this.id = ++nextDocId this.modeOption = mode this.lineSep = lineSep this.direction = (direction == "rtl") ? "rtl" : "ltr" this.extend = false if (typeof text == "string") text = this.splitLines(text) updateDoc(this, {from: start, to: start, text: text}) setSelection(this, simpleSelection(start), sel_dontScroll) } Doc.prototype = createObj(BranchChunk.prototype, { constructor: Doc, // Iterate over the document. Supports two forms -- with only one // argument, it calls that for each line in the document. With // three, it iterates over the range given by the first two (with // the second being non-inclusive). iter: function(from, to, op) { if (op) this.iterN(from - this.first, to - from, op) else this.iterN(this.first, this.first + this.size, from) }, // Non-public interface for adding and removing lines. insert: function(at, lines) { let height = 0 for (let i = 0; i < lines.length; ++i) height += lines[i].height this.insertInner(at - this.first, lines, height) }, remove: function(at, n) { this.removeInner(at - this.first, n) }, // From here, the methods are part of the public interface. Most // are also available from CodeMirror (editor) instances. getValue: function(lineSep) { let lines = getLines(this, this.first, this.first + this.size) if (lineSep === false) return lines return lines.join(lineSep || this.lineSeparator()) }, setValue: docMethodOp(function(code) { let top = Pos(this.first, 0), last = this.first + this.size - 1 makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length), text: this.splitLines(code), origin: "setValue", full: true}, true) if (this.cm) scrollToCoords(this.cm, 0, 0) setSelection(this, simpleSelection(top), sel_dontScroll) }), replaceRange: function(code, from, to, origin) { from = clipPos(this, from) to = to ? clipPos(this, to) : from replaceRange(this, code, from, to, origin) }, getRange: function(from, to, lineSep) { let lines = getBetween(this, clipPos(this, from), clipPos(this, to)) if (lineSep === false) return lines return lines.join(lineSep || this.lineSeparator()) }, getLine: function(line) {let l = this.getLineHandle(line); return l && l.text}, getLineHandle: function(line) {if (isLine(this, line)) return getLine(this, line)}, getLineNumber: function(line) {return lineNo(line)}, getLineHandleVisualStart: function(line) { if (typeof line == "number") line = getLine(this, line) return visualLine(line) }, lineCount: function() {return this.size}, firstLine: function() {return this.first}, lastLine: function() {return this.first + this.size - 1}, clipPos: function(pos) {return clipPos(this, pos)}, getCursor: function(start) { let range = this.sel.primary(), pos if (start == null || start == "head") pos = range.head else if (start == "anchor") pos = range.anchor else if (start == "end" || start == "to" || start === false) pos = range.to() else pos = range.from() return pos }, listSelections: function() { return this.sel.ranges }, somethingSelected: function() {return this.sel.somethingSelected()}, setCursor: docMethodOp(function(line, ch, options) { setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options) }), setSelection: docMethodOp(function(anchor, head, options) { setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options) }), extendSelection: docMethodOp(function(head, other, options) { extendSelection(this, clipPos(this, head), other && clipPos(this, other), options) }), extendSelections: docMethodOp(function(heads, options) { extendSelections(this, clipPosArray(this, heads), options) }), extendSelectionsBy: docMethodOp(function(f, options) { let heads = map(this.sel.ranges, f) extendSelections(this, clipPosArray(this, heads), options) }), setSelections: docMethodOp(function(ranges, primary, options) { if (!ranges.length) return let out = [] for (let i = 0; i < ranges.length; i++) out[i] = new Range(clipPos(this, ranges[i].anchor), clipPos(this, ranges[i].head)) if (primary == null) primary = Math.min(ranges.length - 1, this.sel.primIndex) setSelection(this, normalizeSelection(this.cm, out, primary), options) }), addSelection: docMethodOp(function(anchor, head, options) { let ranges = this.sel.ranges.slice(0) ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor))) setSelection(this, normalizeSelection(this.cm, ranges, ranges.length - 1), options) }), getSelection: function(lineSep) { let ranges = this.sel.ranges, lines for (let i = 0; i < ranges.length; i++) { let sel = getBetween(this, ranges[i].from(), ranges[i].to()) lines = lines ? lines.concat(sel) : sel } if (lineSep === false) return lines else return lines.join(lineSep || this.lineSeparator()) }, getSelections: function(lineSep) { let parts = [], ranges = this.sel.ranges for (let i = 0; i < ranges.length; i++) { let sel = getBetween(this, ranges[i].from(), ranges[i].to()) if (lineSep !== false) sel = sel.join(lineSep || this.lineSeparator()) parts[i] = sel } return parts }, replaceSelection: function(code, collapse, origin) { let dup = [] for (let i = 0; i < this.sel.ranges.length; i++) dup[i] = code this.replaceSelections(dup, collapse, origin || "+input") }, replaceSelections: docMethodOp(function(code, collapse, origin) { let changes = [], sel = this.sel for (let i = 0; i < sel.ranges.length; i++) { let range = sel.ranges[i] changes[i] = {from: range.from(), to: range.to(), text: this.splitLines(code[i]), origin: origin} } let newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse) for (let i = changes.length - 1; i >= 0; i--) makeChange(this, changes[i]) if (newSel) setSelectionReplaceHistory(this, newSel) else if (this.cm) ensureCursorVisible(this.cm) }), undo: docMethodOp(function() {makeChangeFromHistory(this, "undo")}), redo: docMethodOp(function() {makeChangeFromHistory(this, "redo")}), undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true)}), redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true)}), setExtending: function(val) {this.extend = val}, getExtending: function() {return this.extend}, historySize: function() { let hist = this.history, done = 0, undone = 0 for (let i = 0; i < hist.done.length; i++) if (!hist.done[i].ranges) ++done for (let i = 0; i < hist.undone.length; i++) if (!hist.undone[i].ranges) ++undone return {undo: done, redo: undone} }, clearHistory: function() { this.history = new History(this.history.maxGeneration) linkedDocs(this, doc => doc.history = this.history, true) }, markClean: function() { this.cleanGeneration = this.changeGeneration(true) }, changeGeneration: function(forceSplit) { if (forceSplit) this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null return this.history.generation }, isClean: function (gen) { return this.history.generation == (gen || this.cleanGeneration) }, getHistory: function() { return {done: copyHistoryArray(this.history.done), undone: copyHistoryArray(this.history.undone)} }, setHistory: function(histData) { let hist = this.history = new History(this.history.maxGeneration) hist.done = copyHistoryArray(histData.done.slice(0), null, true) hist.undone = copyHistoryArray(histData.undone.slice(0), null, true) }, setGutterMarker: docMethodOp(function(line, gutterID, value) { return changeLine(this, line, "gutter", line => { let markers = line.gutterMarkers || (line.gutterMarkers = {}) markers[gutterID] = value if (!value && isEmpty(markers)) line.gutterMarkers = null return true }) }), clearGutter: docMethodOp(function(gutterID) { this.iter(line => { if (line.gutterMarkers && line.gutterMarkers[gutterID]) { changeLine(this, line, "gutter", () => { line.gutterMarkers[gutterID] = null if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null return true }) } }) }), lineInfo: function(line) { let n if (typeof line == "number") { if (!isLine(this, line)) return null n = line line = getLine(this, line) if (!line) return null } else { n = lineNo(line) if (n == null) return null } return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers, textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass, widgets: line.widgets} }, addLineClass: docMethodOp(function(handle, where, cls) { return changeLine(this, handle, where == "gutter" ? "gutter" : "class", line => { let prop = where == "text" ? "textClass" : where == "background" ? "bgClass" : where == "gutter" ? "gutterClass" : "wrapClass" if (!line[prop]) line[prop] = cls else if (classTest(cls).test(line[prop])) return false else line[prop] += " " + cls return true }) }), removeLineClass: docMethodOp(function(handle, where, cls) { return changeLine(this, handle, where == "gutter" ? "gutter" : "class", line => { let prop = where == "text" ? "textClass" : where == "background" ? "bgClass" : where == "gutter" ? "gutterClass" : "wrapClass" let cur = line[prop] if (!cur) return false else if (cls == null) line[prop] = null else { let found = cur.match(classTest(cls)) if (!found) return false let end = found.index + found[0].length line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null } return true }) }), addLineWidget: docMethodOp(function(handle, node, options) { return addLineWidget(this, handle, node, options) }), removeLineWidget: function(widget) { widget.clear() }, markText: function(from, to, options) { return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range") }, setBookmark: function(pos, options) { let realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options), insertLeft: options && options.insertLeft, clearWhenEmpty: false, shared: options && options.shared, handleMouseEvents: options && options.handleMouseEvents} pos = clipPos(this, pos) return markText(this, pos, pos, realOpts, "bookmark") }, findMarksAt: function(pos) { pos = clipPos(this, pos) let markers = [], spans = getLine(this, pos.line).markedSpans if (spans) for (let i = 0; i < spans.length; ++i) { let span = spans[i] if ((span.from == null || span.from <= pos.ch) && (span.to == null || span.to >= pos.ch)) markers.push(span.marker.parent || span.marker) } return markers }, findMarks: function(from, to, filter) { from = clipPos(this, from); to = clipPos(this, to) let found = [], lineNo = from.line this.iter(from.line, to.line + 1, line => { let spans = line.markedSpans if (spans) for (let i = 0; i < spans.length; i++) { let span = spans[i] if (!(span.to != null && lineNo == from.line && from.ch >= span.to || span.from == null && lineNo != from.line || span.from != null && lineNo == to.line && span.from >= to.ch) && (!filter || filter(span.marker))) found.push(span.marker.parent || span.marker) } ++lineNo }) return found }, getAllMarks: function() { let markers = [] this.iter(line => { let sps = line.markedSpans if (sps) for (let i = 0; i < sps.length; ++i) if (sps[i].from != null) markers.push(sps[i].marker) }) return markers }, posFromIndex: function(off) { let ch, lineNo = this.first, sepSize = this.lineSeparator().length this.iter(line => { let sz = line.text.length + sepSize if (sz > off) { ch = off; return true } off -= sz ++lineNo }) return clipPos(this, Pos(lineNo, ch)) }, indexFromPos: function (coords) { coords = clipPos(this, coords) let index = coords.ch if (coords.line < this.first || coords.ch < 0) return 0 let sepSize = this.lineSeparator().length this.iter(this.first, coords.line, line => { // iter aborts when callback returns a truthy value index += line.text.length + sepSize }) return index }, copy: function(copyHistory) { let doc = new Doc(getLines(this, this.first, this.first + this.size), this.modeOption, this.first, this.lineSep, this.direction) doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft doc.sel = this.sel doc.extend = false if (copyHistory) { doc.history.undoDepth = this.history.undoDepth doc.setHistory(this.getHistory()) } return doc }, linkedDoc: function(options) { if (!options) options = {} let from = this.first, to = this.first + this.size if (options.from != null && options.from > from) from = options.from if (options.to != null && options.to < to) to = options.to let copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction) if (options.sharedHist) copy.history = this.history ;(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist}) copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}] copySharedMarkers(copy, findSharedMarkers(this)) return copy }, unlinkDoc: function(other) { if (other instanceof CodeMirror) other = other.doc if (this.linked) for (let i = 0; i < this.linked.length; ++i) { let link = this.linked[i] if (link.doc != other) continue this.linked.splice(i, 1) other.unlinkDoc(this) detachSharedMarkers(findSharedMarkers(this)) break } // If the histories were shared, split them again if (other.history == this.history) { let splitIds = [other.id] linkedDocs(other, doc => splitIds.push(doc.id), true) other.history = new History(null) other.history.done = copyHistoryArray(this.history.done, splitIds) other.history.undone = copyHistoryArray(this.history.undone, splitIds) } }, iterLinkedDocs: function(f) {linkedDocs(this, f)}, getMode: function() {return this.mode}, getEditor: function() {return this.cm}, splitLines: function(str) { if (this.lineSep) return str.split(this.lineSep) return splitLinesAuto(str) }, lineSeparator: function() { return this.lineSep || "\n" }, setDirection: docMethodOp(function (dir) { if (dir != "rtl") dir = "ltr" if (dir == this.direction) return this.direction = dir this.iter(line => line.order = null) if (this.cm) directionChanged(this.cm) }) }) // Public alias. Doc.prototype.eachLine = Doc.prototype.iter export default Doc PK �S�Z�ƈ!� � src/modes.jsnu �[��� import { copyObj, createObj } from "./util/misc.js" // Known modes, by name and by MIME export let modes = {}, mimeModes = {} // Extra arguments are stored as the mode's dependencies, which is // used by (legacy) mechanisms like loadmode.js to automatically // load a mode. (Preferred mechanism is the require/define calls.) export function defineMode(name, mode) { if (arguments.length > 2) mode.dependencies = Array.prototype.slice.call(arguments, 2) modes[name] = mode } export function defineMIME(mime, spec) { mimeModes[mime] = spec } // Given a MIME type, a {name, ...options} config object, or a name // string, return a mode config object. export function resolveMode(spec) { if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) { spec = mimeModes[spec] } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) { let found = mimeModes[spec.name] if (typeof found == "string") found = {name: found} spec = createObj(found, spec) spec.name = found.name } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) { return resolveMode("application/xml") } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) { return resolveMode("application/json") } if (typeof spec == "string") return {name: spec} else return spec || {name: "null"} } // Given a mode spec (anything that resolveMode accepts), find and // initialize an actual mode object. export function getMode(options, spec) { spec = resolveMode(spec) let mfactory = modes[spec.name] if (!mfactory) return getMode(options, "text/plain") let modeObj = mfactory(options, spec) if (modeExtensions.hasOwnProperty(spec.name)) { let exts = modeExtensions[spec.name] for (let prop in exts) { if (!exts.hasOwnProperty(prop)) continue if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop] modeObj[prop] = exts[prop] } } modeObj.name = spec.name if (spec.helperType) modeObj.helperType = spec.helperType if (spec.modeProps) for (let prop in spec.modeProps) modeObj[prop] = spec.modeProps[prop] return modeObj } // This can be used to attach properties to mode objects from // outside the actual mode definition. export let modeExtensions = {} export function extendMode(mode, properties) { let exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {}) copyObj(properties, exts) } export function copyState(mode, state) { if (state === true) return state if (mode.copyState) return mode.copyState(state) let nstate = {} for (let n in state) { let val = state[n] if (val instanceof Array) val = val.concat([]) nstate[n] = val } return nstate } // Given a mode and a state (for that mode), find the inner mode and // state at the position that the state refers to. export function innerMode(mode, state) { let info while (mode.innerMode) { info = mode.innerMode(state) if (!info || info.mode == mode) break state = info.state mode = info.mode } return info || {mode: mode, state: state} } export function startState(mode, a1, a2) { return mode.startState ? mode.startState(a1, a2) : true } PK �S�Z�3^� � src/display/highlight_worker.jsnu �[��� import { getContextBefore, highlightLine, processLine } from "../line/highlight.js" import { copyState } from "../modes.js" import { bind } from "../util/misc.js" import { runInOp } from "./operations.js" import { regLineChange } from "./view_tracking.js" // HIGHLIGHT WORKER export function startWorker(cm, time) { if (cm.doc.highlightFrontier < cm.display.viewTo) cm.state.highlight.set(time, bind(highlightWorker, cm)) } function highlightWorker(cm) { let doc = cm.doc if (doc.highlightFrontier >= cm.display.viewTo) return let end = +new Date + cm.options.workTime let context = getContextBefore(cm, doc.highlightFrontier) let changedLines = [] doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), line => { if (context.line >= cm.display.viewFrom) { // Visible let oldStyles = line.styles let resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null let highlighted = highlightLine(cm, line, context, true) if (resetState) context.state = resetState line.styles = highlighted.styles let oldCls = line.styleClasses, newCls = highlighted.classes if (newCls) line.styleClasses = newCls else if (oldCls) line.styleClasses = null let ischange = !oldStyles || oldStyles.length != line.styles.length || oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass) for (let i = 0; !ischange && i < oldStyles.length; ++i) ischange = oldStyles[i] != line.styles[i] if (ischange) changedLines.push(context.line) line.stateAfter = context.save() context.nextLine() } else { if (line.text.length <= cm.options.maxHighlightLength) processLine(cm, line.text, context) line.stateAfter = context.line % 5 == 0 ? context.save() : null context.nextLine() } if (+new Date > end) { startWorker(cm, cm.options.workDelay) return true } }) doc.highlightFrontier = context.line doc.modeFrontier = Math.max(doc.modeFrontier, context.line) if (changedLines.length) runInOp(cm, () => { for (let i = 0; i < changedLines.length; i++) regLineChange(cm, changedLines[i], "text") }) } PK �S�Z)�!m m src/display/mode_state.jsnu �[��� import { getMode } from "../modes.js" import { startWorker } from "./highlight_worker.js" import { regChange } from "./view_tracking.js" // Used to get the editor into a consistent state again when options change. export function loadMode(cm) { cm.doc.mode = getMode(cm.options, cm.doc.modeOption) resetModeState(cm) } export function resetModeState(cm) { cm.doc.iter(line => { if (line.stateAfter) line.stateAfter = null if (line.styles) line.styles = null }) cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first startWorker(cm, 100) cm.state.modeGen++ if (cm.curOp) regChange(cm) } PK �S�Z,W W src/display/update_lines.jsnu �[��� import { heightAtLine } from "../line/spans.js" import { getLine, lineAtHeight, updateLineHeight } from "../line/utils_line.js" import { paddingTop, charWidth } from "../measurement/position_measurement.js" import { ie, ie_version } from "../util/browser.js" // Read the actual heights of the rendered lines, and update their // stored heights to match. export function updateHeightsInViewport(cm) { let display = cm.display let prevBottom = display.lineDiv.offsetTop for (let i = 0; i < display.view.length; i++) { let cur = display.view[i], wrapping = cm.options.lineWrapping let height, width = 0 if (cur.hidden) continue if (ie && ie_version < 8) { let bot = cur.node.offsetTop + cur.node.offsetHeight height = bot - prevBottom prevBottom = bot } else { let box = cur.node.getBoundingClientRect() height = box.bottom - box.top // Check that lines don't extend past the right of the current // editor width if (!wrapping && cur.text.firstChild) width = cur.text.firstChild.getBoundingClientRect().right - box.left - 1 } let diff = cur.line.height - height if (diff > .005 || diff < -.005) { updateLineHeight(cur.line, height) updateWidgetHeight(cur.line) if (cur.rest) for (let j = 0; j < cur.rest.length; j++) updateWidgetHeight(cur.rest[j]) } if (width > cm.display.sizerWidth) { let chWidth = Math.ceil(width / charWidth(cm.display)) if (chWidth > cm.display.maxLineLength) { cm.display.maxLineLength = chWidth cm.display.maxLine = cur.line cm.display.maxLineChanged = true } } } } // Read and store the height of line widgets associated with the // given line. function updateWidgetHeight(line) { if (line.widgets) for (let i = 0; i < line.widgets.length; ++i) { let w = line.widgets[i], parent = w.node.parentNode if (parent) w.height = parent.offsetHeight } } // Compute the lines that are visible in a given viewport (defaults // the the current scroll position). viewport may contain top, // height, and ensure (see op.scrollToPos) properties. export function visibleLines(display, doc, viewport) { let top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop top = Math.floor(top - paddingTop(display)) let bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight let from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom) // Ensure is a {from: {line, ch}, to: {line, ch}} object, and // forces those lines into the viewport (if possible). if (viewport && viewport.ensure) { let ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line if (ensureFrom < from) { from = ensureFrom to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight) } else if (Math.min(ensureTo, doc.lastLine()) >= to) { from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight) to = ensureTo } } return {from: from, to: Math.max(to, from + 1)} } PK �S�Z��OP src/display/gutters.jsnu �[��� import { elt, removeChildren } from "../util/dom.js" import { regChange } from "./view_tracking.js" import { alignHorizontally } from "./line_numbers.js" import { updateGutterSpace } from "./update_display.js" export function getGutters(gutters, lineNumbers) { let result = [], sawLineNumbers = false for (let i = 0; i < gutters.length; i++) { let name = gutters[i], style = null if (typeof name != "string") { style = name.style; name = name.className } if (name == "CodeMirror-linenumbers") { if (!lineNumbers) continue else sawLineNumbers = true } result.push({className: name, style}) } if (lineNumbers && !sawLineNumbers) result.push({className: "CodeMirror-linenumbers", style: null}) return result } // Rebuild the gutter elements, ensure the margin to the left of the // code matches their width. export function renderGutters(display) { let gutters = display.gutters, specs = display.gutterSpecs removeChildren(gutters) display.lineGutter = null for (let i = 0; i < specs.length; ++i) { let {className, style} = specs[i] let gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + className)) if (style) gElt.style.cssText = style if (className == "CodeMirror-linenumbers") { display.lineGutter = gElt gElt.style.width = (display.lineNumWidth || 1) + "px" } } gutters.style.display = specs.length ? "" : "none" updateGutterSpace(display) } export function updateGutters(cm) { renderGutters(cm.display) regChange(cm) alignHorizontally(cm) } PK �S�ZD>�mW( W( src/display/update_display.jsnu �[��� import { sawCollapsedSpans } from "../line/saw_special_spans.js" import { heightAtLine, visualLineEndNo, visualLineNo } from "../line/spans.js" import { getLine, lineNumberFor } from "../line/utils_line.js" import { displayHeight, displayWidth, getDimensions, paddingVert, scrollGap } from "../measurement/position_measurement.js" import { mac, webkit } from "../util/browser.js" import { activeElt, removeChildren, contains } from "../util/dom.js" import { hasHandler, signal } from "../util/event.js" import { indexOf } from "../util/misc.js" import { buildLineElement, updateLineForChanges } from "./update_line.js" import { startWorker } from "./highlight_worker.js" import { maybeUpdateLineNumberWidth } from "./line_numbers.js" import { measureForScrollbars, updateScrollbars } from "./scrollbars.js" import { updateSelection } from "./selection.js" import { updateHeightsInViewport, visibleLines } from "./update_lines.js" import { adjustView, countDirtyView, resetView } from "./view_tracking.js" // DISPLAY DRAWING export class DisplayUpdate { constructor(cm, viewport, force) { let display = cm.display this.viewport = viewport // Store some values that we'll need later (but don't want to force a relayout for) this.visible = visibleLines(display, cm.doc, viewport) this.editorIsHidden = !display.wrapper.offsetWidth this.wrapperHeight = display.wrapper.clientHeight this.wrapperWidth = display.wrapper.clientWidth this.oldDisplayWidth = displayWidth(cm) this.force = force this.dims = getDimensions(cm) this.events = [] } signal(emitter, type) { if (hasHandler(emitter, type)) this.events.push(arguments) } finish() { for (let i = 0; i < this.events.length; i++) signal.apply(null, this.events[i]) } } export function maybeClipScrollbars(cm) { let display = cm.display if (!display.scrollbarsClipped && display.scroller.offsetWidth) { display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth display.heightForcer.style.height = scrollGap(cm) + "px" display.sizer.style.marginBottom = -display.nativeBarWidth + "px" display.sizer.style.borderRightWidth = scrollGap(cm) + "px" display.scrollbarsClipped = true } } function selectionSnapshot(cm) { if (cm.hasFocus()) return null let active = activeElt() if (!active || !contains(cm.display.lineDiv, active)) return null let result = {activeElt: active} if (window.getSelection) { let sel = window.getSelection() if (sel.anchorNode && sel.extend && contains(cm.display.lineDiv, sel.anchorNode)) { result.anchorNode = sel.anchorNode result.anchorOffset = sel.anchorOffset result.focusNode = sel.focusNode result.focusOffset = sel.focusOffset } } return result } function restoreSelection(snapshot) { if (!snapshot || !snapshot.activeElt || snapshot.activeElt == activeElt()) return snapshot.activeElt.focus() if (!/^(INPUT|TEXTAREA)$/.test(snapshot.activeElt.nodeName) && snapshot.anchorNode && contains(document.body, snapshot.anchorNode) && contains(document.body, snapshot.focusNode)) { let sel = window.getSelection(), range = document.createRange() range.setEnd(snapshot.anchorNode, snapshot.anchorOffset) range.collapse(false) sel.removeAllRanges() sel.addRange(range) sel.extend(snapshot.focusNode, snapshot.focusOffset) } } // Does the actual updating of the line display. Bails out // (returning false) when there is nothing to be done and forced is // false. export function updateDisplayIfNeeded(cm, update) { let display = cm.display, doc = cm.doc if (update.editorIsHidden) { resetView(cm) return false } // Bail out if the visible area is already rendered and nothing changed. if (!update.force && update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo && (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) && display.renderedView == display.view && countDirtyView(cm) == 0) return false if (maybeUpdateLineNumberWidth(cm)) { resetView(cm) update.dims = getDimensions(cm) } // Compute a suitable new viewport (from & to) let end = doc.first + doc.size let from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first) let to = Math.min(end, update.visible.to + cm.options.viewportMargin) if (display.viewFrom < from && from - display.viewFrom < 20) from = Math.max(doc.first, display.viewFrom) if (display.viewTo > to && display.viewTo - to < 20) to = Math.min(end, display.viewTo) if (sawCollapsedSpans) { from = visualLineNo(cm.doc, from) to = visualLineEndNo(cm.doc, to) } let different = from != display.viewFrom || to != display.viewTo || display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth adjustView(cm, from, to) display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom)) // Position the mover div to align with the current scroll position cm.display.mover.style.top = display.viewOffset + "px" let toUpdate = countDirtyView(cm) if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view && (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo)) return false // For big changes, we hide the enclosing element during the // update, since that speeds up the operations on most browsers. let selSnapshot = selectionSnapshot(cm) if (toUpdate > 4) display.lineDiv.style.display = "none" patchDisplay(cm, display.updateLineNumbers, update.dims) if (toUpdate > 4) display.lineDiv.style.display = "" display.renderedView = display.view // There might have been a widget with a focused element that got // hidden or updated, if so re-focus it. restoreSelection(selSnapshot) // Prevent selection and cursors from interfering with the scroll // width and height. removeChildren(display.cursorDiv) removeChildren(display.selectionDiv) display.gutters.style.height = display.sizer.style.minHeight = 0 if (different) { display.lastWrapHeight = update.wrapperHeight display.lastWrapWidth = update.wrapperWidth startWorker(cm, 400) } display.updateLineNumbers = null return true } export function postUpdateDisplay(cm, update) { let viewport = update.viewport for (let first = true;; first = false) { if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) { // Clip forced viewport to actual scrollable area. if (viewport && viewport.top != null) viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)} // Updated line heights might result in the drawn area not // actually covering the viewport. Keep looping until it does. update.visible = visibleLines(cm.display, cm.doc, viewport) if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo) break } else if (first) { update.visible = visibleLines(cm.display, cm.doc, viewport) } if (!updateDisplayIfNeeded(cm, update)) break updateHeightsInViewport(cm) let barMeasure = measureForScrollbars(cm) updateSelection(cm) updateScrollbars(cm, barMeasure) setDocumentHeight(cm, barMeasure) update.force = false } update.signal(cm, "update", cm) if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) { update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo) cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo } } export function updateDisplaySimple(cm, viewport) { let update = new DisplayUpdate(cm, viewport) if (updateDisplayIfNeeded(cm, update)) { updateHeightsInViewport(cm) postUpdateDisplay(cm, update) let barMeasure = measureForScrollbars(cm) updateSelection(cm) updateScrollbars(cm, barMeasure) setDocumentHeight(cm, barMeasure) update.finish() } } // Sync the actual display DOM structure with display.view, removing // nodes for lines that are no longer in view, and creating the ones // that are not there yet, and updating the ones that are out of // date. function patchDisplay(cm, updateNumbersFrom, dims) { let display = cm.display, lineNumbers = cm.options.lineNumbers let container = display.lineDiv, cur = container.firstChild function rm(node) { let next = node.nextSibling // Works around a throw-scroll bug in OS X Webkit if (webkit && mac && cm.display.currentWheelTarget == node) node.style.display = "none" else node.parentNode.removeChild(node) return next } let view = display.view, lineN = display.viewFrom // Loop over the elements in the view, syncing cur (the DOM nodes // in display.lineDiv) with the view as we go. for (let i = 0; i < view.length; i++) { let lineView = view[i] if (lineView.hidden) { } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet let node = buildLineElement(cm, lineView, lineN, dims) container.insertBefore(node, cur) } else { // Already drawn while (cur != lineView.node) cur = rm(cur) let updateNumber = lineNumbers && updateNumbersFrom != null && updateNumbersFrom <= lineN && lineView.lineNumber if (lineView.changes) { if (indexOf(lineView.changes, "gutter") > -1) updateNumber = false updateLineForChanges(cm, lineView, lineN, dims) } if (updateNumber) { removeChildren(lineView.lineNumber) lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN))) } cur = lineView.node.nextSibling } lineN += lineView.size } while (cur) cur = rm(cur) } export function updateGutterSpace(display) { let width = display.gutters.offsetWidth display.sizer.style.marginLeft = width + "px" } export function setDocumentHeight(cm, measure) { cm.display.sizer.style.minHeight = measure.docHeight + "px" cm.display.heightForcer.style.top = measure.docHeight + "px" cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px" } PK �S�Z���+w w src/display/line_numbers.jsnu �[��� import { lineNumberFor } from "../line/utils_line.js" import { compensateForHScroll } from "../measurement/position_measurement.js" import { elt } from "../util/dom.js" import { updateGutterSpace } from "./update_display.js" // Re-align line numbers and gutter marks to compensate for // horizontal scrolling. export function alignHorizontally(cm) { let display = cm.display, view = display.view if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return let comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft let gutterW = display.gutters.offsetWidth, left = comp + "px" for (let i = 0; i < view.length; i++) if (!view[i].hidden) { if (cm.options.fixedGutter) { if (view[i].gutter) view[i].gutter.style.left = left if (view[i].gutterBackground) view[i].gutterBackground.style.left = left } let align = view[i].alignable if (align) for (let j = 0; j < align.length; j++) align[j].style.left = left } if (cm.options.fixedGutter) display.gutters.style.left = (comp + gutterW) + "px" } // Used to ensure that the line number gutter is still the right // size for the current document size. Returns true when an update // is needed. export function maybeUpdateLineNumberWidth(cm) { if (!cm.options.lineNumbers) return false let doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display if (last.length != display.lineNumChars) { let test = display.measure.appendChild(elt("div", [elt("div", last)], "CodeMirror-linenumber CodeMirror-gutter-elt")) let innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW display.lineGutter.style.width = "" display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1 display.lineNumWidth = display.lineNumInnerWidth + padding display.lineNumChars = display.lineNumInnerWidth ? last.length : -1 display.lineGutter.style.width = display.lineNumWidth + "px" updateGutterSpace(cm.display) return true } return false } PK �S�Z%�Cu� � src/display/focus.jsnu �[��� import { restartBlink } from "./selection.js" import { webkit } from "../util/browser.js" import { addClass, rmClass } from "../util/dom.js" import { signal } from "../util/event.js" export function ensureFocus(cm) { if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm) } } export function delayBlurEvent(cm) { cm.state.delayingBlurEvent = true setTimeout(() => { if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false onBlur(cm) } }, 100) } export function onFocus(cm, e) { if (cm.state.delayingBlurEvent) cm.state.delayingBlurEvent = false if (cm.options.readOnly == "nocursor") return if (!cm.state.focused) { signal(cm, "focus", cm, e) cm.state.focused = true addClass(cm.display.wrapper, "CodeMirror-focused") // This test prevents this from firing when a context // menu is closed (since the input reset would kill the // select-all detection hack) if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) { cm.display.input.reset() if (webkit) setTimeout(() => cm.display.input.reset(true), 20) // Issue #1730 } cm.display.input.receivedFocus() } restartBlink(cm) } export function onBlur(cm, e) { if (cm.state.delayingBlurEvent) return if (cm.state.focused) { signal(cm, "blur", cm, e) cm.state.focused = false rmClass(cm.display.wrapper, "CodeMirror-focused") } clearInterval(cm.display.blinker) setTimeout(() => { if (!cm.state.focused) cm.display.shift = false }, 150) } PK �S�Zn(L� src/display/view_tracking.jsnu �[��� import { buildViewArray } from "../line/line_data.js" import { sawCollapsedSpans } from "../line/saw_special_spans.js" import { visualLineEndNo, visualLineNo } from "../line/spans.js" import { findViewIndex } from "../measurement/position_measurement.js" import { indexOf } from "../util/misc.js" // Updates the display.view data structure for a given change to the // document. From and to are in pre-change coordinates. Lendiff is // the amount of lines added or subtracted by the change. This is // used for changes that span multiple lines, or change the way // lines are divided into visual lines. regLineChange (below) // registers single-line changes. export function regChange(cm, from, to, lendiff) { if (from == null) from = cm.doc.first if (to == null) to = cm.doc.first + cm.doc.size if (!lendiff) lendiff = 0 let display = cm.display if (lendiff && to < display.viewTo && (display.updateLineNumbers == null || display.updateLineNumbers > from)) display.updateLineNumbers = from cm.curOp.viewChanged = true if (from >= display.viewTo) { // Change after if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo) resetView(cm) } else if (to <= display.viewFrom) { // Change before if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) { resetView(cm) } else { display.viewFrom += lendiff display.viewTo += lendiff } } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap resetView(cm) } else if (from <= display.viewFrom) { // Top overlap let cut = viewCuttingPoint(cm, to, to + lendiff, 1) if (cut) { display.view = display.view.slice(cut.index) display.viewFrom = cut.lineN display.viewTo += lendiff } else { resetView(cm) } } else if (to >= display.viewTo) { // Bottom overlap let cut = viewCuttingPoint(cm, from, from, -1) if (cut) { display.view = display.view.slice(0, cut.index) display.viewTo = cut.lineN } else { resetView(cm) } } else { // Gap in the middle let cutTop = viewCuttingPoint(cm, from, from, -1) let cutBot = viewCuttingPoint(cm, to, to + lendiff, 1) if (cutTop && cutBot) { display.view = display.view.slice(0, cutTop.index) .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN)) .concat(display.view.slice(cutBot.index)) display.viewTo += lendiff } else { resetView(cm) } } let ext = display.externalMeasured if (ext) { if (to < ext.lineN) ext.lineN += lendiff else if (from < ext.lineN + ext.size) display.externalMeasured = null } } // Register a change to a single line. Type must be one of "text", // "gutter", "class", "widget" export function regLineChange(cm, line, type) { cm.curOp.viewChanged = true let display = cm.display, ext = cm.display.externalMeasured if (ext && line >= ext.lineN && line < ext.lineN + ext.size) display.externalMeasured = null if (line < display.viewFrom || line >= display.viewTo) return let lineView = display.view[findViewIndex(cm, line)] if (lineView.node == null) return let arr = lineView.changes || (lineView.changes = []) if (indexOf(arr, type) == -1) arr.push(type) } // Clear the view. export function resetView(cm) { cm.display.viewFrom = cm.display.viewTo = cm.doc.first cm.display.view = [] cm.display.viewOffset = 0 } function viewCuttingPoint(cm, oldN, newN, dir) { let index = findViewIndex(cm, oldN), diff, view = cm.display.view if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size) return {index: index, lineN: newN} let n = cm.display.viewFrom for (let i = 0; i < index; i++) n += view[i].size if (n != oldN) { if (dir > 0) { if (index == view.length - 1) return null diff = (n + view[index].size) - oldN index++ } else { diff = n - oldN } oldN += diff; newN += diff } while (visualLineNo(cm.doc, newN) != newN) { if (index == (dir < 0 ? 0 : view.length - 1)) return null newN += dir * view[index - (dir < 0 ? 1 : 0)].size index += dir } return {index: index, lineN: newN} } // Force the view to cover a given range, adding empty view element // or clipping off existing ones as needed. export function adjustView(cm, from, to) { let display = cm.display, view = display.view if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) { display.view = buildViewArray(cm, from, to) display.viewFrom = from } else { if (display.viewFrom > from) display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view) else if (display.viewFrom < from) display.view = display.view.slice(findViewIndex(cm, from)) display.viewFrom = from if (display.viewTo < to) display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)) else if (display.viewTo > to) display.view = display.view.slice(0, findViewIndex(cm, to)) } display.viewTo = to } // Count the number of lines in the view whose DOM representation is // out of date (or nonexistent). export function countDirtyView(cm) { let view = cm.display.view, dirty = 0 for (let i = 0; i < view.length; i++) { let lineView = view[i] if (!lineView.hidden && (!lineView.node || lineView.changes)) ++dirty } return dirty } PK �S�Z3��! ! src/display/scrollbars.jsnu �[��� import { addClass, elt, rmClass } from "../util/dom.js" import { on } from "../util/event.js" import { scrollGap, paddingVert } from "../measurement/position_measurement.js" import { ie, ie_version, mac, mac_geMountainLion } from "../util/browser.js" import { updateHeightsInViewport } from "./update_lines.js" import { Delayed } from "../util/misc.js" import { setScrollLeft, updateScrollTop } from "./scrolling.js" // SCROLLBARS // Prepare DOM reads needed to update the scrollbars. Done in one // shot to minimize update/measure roundtrips. export function measureForScrollbars(cm) { let d = cm.display, gutterW = d.gutters.offsetWidth let docH = Math.round(cm.doc.height + paddingVert(cm.display)) return { clientHeight: d.scroller.clientHeight, viewHeight: d.wrapper.clientHeight, scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth, viewWidth: d.wrapper.clientWidth, barLeft: cm.options.fixedGutter ? gutterW : 0, docHeight: docH, scrollHeight: docH + scrollGap(cm) + d.barHeight, nativeBarWidth: d.nativeBarWidth, gutterWidth: gutterW } } class NativeScrollbars { constructor(place, scroll, cm) { this.cm = cm let vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar") let horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar") vert.tabIndex = horiz.tabIndex = -1 place(vert); place(horiz) on(vert, "scroll", () => { if (vert.clientHeight) scroll(vert.scrollTop, "vertical") }) on(horiz, "scroll", () => { if (horiz.clientWidth) scroll(horiz.scrollLeft, "horizontal") }) this.checkedZeroWidth = false // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8). if (ie && ie_version < 8) this.horiz.style.minHeight = this.vert.style.minWidth = "18px" } update(measure) { let needsH = measure.scrollWidth > measure.clientWidth + 1 let needsV = measure.scrollHeight > measure.clientHeight + 1 let sWidth = measure.nativeBarWidth if (needsV) { this.vert.style.display = "block" this.vert.style.bottom = needsH ? sWidth + "px" : "0" let totalHeight = measure.viewHeight - (needsH ? sWidth : 0) // A bug in IE8 can cause this value to be negative, so guard it. this.vert.firstChild.style.height = Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px" } else { this.vert.style.display = "" this.vert.firstChild.style.height = "0" } if (needsH) { this.horiz.style.display = "block" this.horiz.style.right = needsV ? sWidth + "px" : "0" this.horiz.style.left = measure.barLeft + "px" let totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0) this.horiz.firstChild.style.width = Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + "px" } else { this.horiz.style.display = "" this.horiz.firstChild.style.width = "0" } if (!this.checkedZeroWidth && measure.clientHeight > 0) { if (sWidth == 0) this.zeroWidthHack() this.checkedZeroWidth = true } return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0} } setScrollLeft(pos) { if (this.horiz.scrollLeft != pos) this.horiz.scrollLeft = pos if (this.disableHoriz) this.enableZeroWidthBar(this.horiz, this.disableHoriz, "horiz") } setScrollTop(pos) { if (this.vert.scrollTop != pos) this.vert.scrollTop = pos if (this.disableVert) this.enableZeroWidthBar(this.vert, this.disableVert, "vert") } zeroWidthHack() { let w = mac && !mac_geMountainLion ? "12px" : "18px" this.horiz.style.height = this.vert.style.width = w this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none" this.disableHoriz = new Delayed this.disableVert = new Delayed } enableZeroWidthBar(bar, delay, type) { bar.style.pointerEvents = "auto" function maybeDisable() { // To find out whether the scrollbar is still visible, we // check whether the element under the pixel in the bottom // right corner of the scrollbar box is the scrollbar box // itself (when the bar is still visible) or its filler child // (when the bar is hidden). If it is still visible, we keep // it enabled, if it's hidden, we disable pointer events. let box = bar.getBoundingClientRect() let elt = type == "vert" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2) : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1) if (elt != bar) bar.style.pointerEvents = "none" else delay.set(1000, maybeDisable) } delay.set(1000, maybeDisable) } clear() { let parent = this.horiz.parentNode parent.removeChild(this.horiz) parent.removeChild(this.vert) } } class NullScrollbars { update() { return {bottom: 0, right: 0} } setScrollLeft() {} setScrollTop() {} clear() {} } export function updateScrollbars(cm, measure) { if (!measure) measure = measureForScrollbars(cm) let startWidth = cm.display.barWidth, startHeight = cm.display.barHeight updateScrollbarsInner(cm, measure) for (let i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) { if (startWidth != cm.display.barWidth && cm.options.lineWrapping) updateHeightsInViewport(cm) updateScrollbarsInner(cm, measureForScrollbars(cm)) startWidth = cm.display.barWidth; startHeight = cm.display.barHeight } } // Re-synchronize the fake scrollbars with the actual size of the // content. function updateScrollbarsInner(cm, measure) { let d = cm.display let sizes = d.scrollbars.update(measure) d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px" d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px" d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent" if (sizes.right && sizes.bottom) { d.scrollbarFiller.style.display = "block" d.scrollbarFiller.style.height = sizes.bottom + "px" d.scrollbarFiller.style.width = sizes.right + "px" } else d.scrollbarFiller.style.display = "" if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) { d.gutterFiller.style.display = "block" d.gutterFiller.style.height = sizes.bottom + "px" d.gutterFiller.style.width = measure.gutterWidth + "px" } else d.gutterFiller.style.display = "" } export let scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars} export function initScrollbars(cm) { if (cm.display.scrollbars) { cm.display.scrollbars.clear() if (cm.display.scrollbars.addClass) rmClass(cm.display.wrapper, cm.display.scrollbars.addClass) } cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](node => { cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller) // Prevent clicks in the scrollbars from killing focus on(node, "mousedown", () => { if (cm.state.focused) setTimeout(() => cm.display.input.focus(), 0) }) node.setAttribute("cm-not-content", "true") }, (pos, axis) => { if (axis == "horizontal") setScrollLeft(cm, pos) else updateScrollTop(cm, pos) }, cm) if (cm.display.scrollbars.addClass) addClass(cm.display.wrapper, cm.display.scrollbars.addClass) } PK �S�Z�\� � � src/display/scrolling.jsnu �[��� import { Pos } from "../line/pos.js" import { cursorCoords, displayHeight, displayWidth, estimateCoords, paddingTop, paddingVert, scrollGap, textHeight } from "../measurement/position_measurement.js" import { gecko, phantom } from "../util/browser.js" import { elt } from "../util/dom.js" import { signalDOMEvent } from "../util/event.js" import { startWorker } from "./highlight_worker.js" import { alignHorizontally } from "./line_numbers.js" import { updateDisplaySimple } from "./update_display.js" // SCROLLING THINGS INTO VIEW // If an editor sits on the top or bottom of the window, partially // scrolled out of view, this ensures that the cursor is visible. export function maybeScrollWindow(cm, rect) { if (signalDOMEvent(cm, "scrollCursorIntoView")) return let display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null if (rect.top + box.top < 0) doScroll = true else if (rect.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) doScroll = false if (doScroll != null && !phantom) { let scrollNode = elt("div", "\u200b", null, `position: absolute; top: ${rect.top - display.viewOffset - paddingTop(cm.display)}px; height: ${rect.bottom - rect.top + scrollGap(cm) + display.barHeight}px; left: ${rect.left}px; width: ${Math.max(2, rect.right - rect.left)}px;`) cm.display.lineSpace.appendChild(scrollNode) scrollNode.scrollIntoView(doScroll) cm.display.lineSpace.removeChild(scrollNode) } } // Scroll a given position into view (immediately), verifying that // it actually became visible (as line heights are accurately // measured, the position of something may 'drift' during drawing). export function scrollPosIntoView(cm, pos, end, margin) { if (margin == null) margin = 0 let rect if (!cm.options.lineWrapping && pos == end) { // Set pos and end to the cursor positions around the character pos sticks to // If pos.sticky == "before", that is around pos.ch - 1, otherwise around pos.ch // If pos == Pos(_, 0, "before"), pos and end are unchanged pos = pos.ch ? Pos(pos.line, pos.sticky == "before" ? pos.ch - 1 : pos.ch, "after") : pos end = pos.sticky == "before" ? Pos(pos.line, pos.ch + 1, "before") : pos } for (let limit = 0; limit < 5; limit++) { let changed = false let coords = cursorCoords(cm, pos) let endCoords = !end || end == pos ? coords : cursorCoords(cm, end) rect = {left: Math.min(coords.left, endCoords.left), top: Math.min(coords.top, endCoords.top) - margin, right: Math.max(coords.left, endCoords.left), bottom: Math.max(coords.bottom, endCoords.bottom) + margin} let scrollPos = calculateScrollPos(cm, rect) let startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft if (scrollPos.scrollTop != null) { updateScrollTop(cm, scrollPos.scrollTop) if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true } if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft) if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true } if (!changed) break } return rect } // Scroll a given set of coordinates into view (immediately). export function scrollIntoView(cm, rect) { let scrollPos = calculateScrollPos(cm, rect) if (scrollPos.scrollTop != null) updateScrollTop(cm, scrollPos.scrollTop) if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft) } // Calculate a new scroll position needed to scroll the given // rectangle into view. Returns an object with scrollTop and // scrollLeft properties. When these are undefined, the // vertical/horizontal position does not need to be adjusted. function calculateScrollPos(cm, rect) { let display = cm.display, snapMargin = textHeight(cm.display) if (rect.top < 0) rect.top = 0 let screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop let screen = displayHeight(cm), result = {} if (rect.bottom - rect.top > screen) rect.bottom = rect.top + screen let docBottom = cm.doc.height + paddingVert(display) let atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin if (rect.top < screentop) { result.scrollTop = atTop ? 0 : rect.top } else if (rect.bottom > screentop + screen) { let newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen) if (newTop != screentop) result.scrollTop = newTop } let gutterSpace = cm.options.fixedGutter ? 0 : display.gutters.offsetWidth let screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft - gutterSpace let screenw = displayWidth(cm) - display.gutters.offsetWidth let tooWide = rect.right - rect.left > screenw if (tooWide) rect.right = rect.left + screenw if (rect.left < 10) result.scrollLeft = 0 else if (rect.left < screenleft) result.scrollLeft = Math.max(0, rect.left + gutterSpace - (tooWide ? 0 : 10)) else if (rect.right > screenw + screenleft - 3) result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw return result } // Store a relative adjustment to the scroll position in the current // operation (to be applied when the operation finishes). export function addToScrollTop(cm, top) { if (top == null) return resolveScrollToPos(cm) cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top } // Make sure that at the end of the operation the current cursor is // shown. export function ensureCursorVisible(cm) { resolveScrollToPos(cm) let cur = cm.getCursor() cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin} } export function scrollToCoords(cm, x, y) { if (x != null || y != null) resolveScrollToPos(cm) if (x != null) cm.curOp.scrollLeft = x if (y != null) cm.curOp.scrollTop = y } export function scrollToRange(cm, range) { resolveScrollToPos(cm) cm.curOp.scrollToPos = range } // When an operation has its scrollToPos property set, and another // scroll action is applied before the end of the operation, this // 'simulates' scrolling that position into view in a cheap way, so // that the effect of intermediate scroll commands is not ignored. function resolveScrollToPos(cm) { let range = cm.curOp.scrollToPos if (range) { cm.curOp.scrollToPos = null let from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to) scrollToCoordsRange(cm, from, to, range.margin) } } export function scrollToCoordsRange(cm, from, to, margin) { let sPos = calculateScrollPos(cm, { left: Math.min(from.left, to.left), top: Math.min(from.top, to.top) - margin, right: Math.max(from.right, to.right), bottom: Math.max(from.bottom, to.bottom) + margin }) scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop) } // Sync the scrollable area and scrollbars, ensure the viewport // covers the visible area. export function updateScrollTop(cm, val) { if (Math.abs(cm.doc.scrollTop - val) < 2) return if (!gecko) updateDisplaySimple(cm, {top: val}) setScrollTop(cm, val, true) if (gecko) updateDisplaySimple(cm) startWorker(cm, 100) } export function setScrollTop(cm, val, forceScroll) { val = Math.max(0, Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val)) if (cm.display.scroller.scrollTop == val && !forceScroll) return cm.doc.scrollTop = val cm.display.scrollbars.setScrollTop(val) if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val } // Sync scroller and scrollbar, ensure the gutter elements are // aligned. export function setScrollLeft(cm, val, isScroller, forceScroll) { val = Math.max(0, Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth)) if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) return cm.doc.scrollLeft = val alignHorizontally(cm) if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val cm.display.scrollbars.setScrollLeft(val) } PK �S�Zc�mV V src/display/selection.jsnu �[��� import { Pos } from "../line/pos.js" import { visualLine } from "../line/spans.js" import { getLine } from "../line/utils_line.js" import { charCoords, cursorCoords, displayWidth, paddingH, wrappedLineExtentChar } from "../measurement/position_measurement.js" import { getOrder, iterateBidiSections } from "../util/bidi.js" import { elt } from "../util/dom.js" import { onBlur } from "./focus.js" export function updateSelection(cm) { cm.display.input.showSelection(cm.display.input.prepareSelection()) } export function prepareSelection(cm, primary = true) { let doc = cm.doc, result = {} let curFragment = result.cursors = document.createDocumentFragment() let selFragment = result.selection = document.createDocumentFragment() for (let i = 0; i < doc.sel.ranges.length; i++) { if (!primary && i == doc.sel.primIndex) continue let range = doc.sel.ranges[i] if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) continue let collapsed = range.empty() if (collapsed || cm.options.showCursorWhenSelecting) drawSelectionCursor(cm, range.head, curFragment) if (!collapsed) drawSelectionRange(cm, range, selFragment) } return result } // Draws a cursor for the given range export function drawSelectionCursor(cm, head, output) { let pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine) let cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor")) cursor.style.left = pos.left + "px" cursor.style.top = pos.top + "px" cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px" if (pos.other) { // Secondary cursor, shown when on a 'jump' in bi-directional text let otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor")) otherCursor.style.display = "" otherCursor.style.left = pos.other.left + "px" otherCursor.style.top = pos.other.top + "px" otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px" } } function cmpCoords(a, b) { return a.top - b.top || a.left - b.left } // Draws the given range as a highlighted selection function drawSelectionRange(cm, range, output) { let display = cm.display, doc = cm.doc let fragment = document.createDocumentFragment() let padding = paddingH(cm.display), leftSide = padding.left let rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right let docLTR = doc.direction == "ltr" function add(left, top, width, bottom) { if (top < 0) top = 0 top = Math.round(top) bottom = Math.round(bottom) fragment.appendChild(elt("div", null, "CodeMirror-selected", `position: absolute; left: ${left}px; top: ${top}px; width: ${width == null ? rightSide - left : width}px; height: ${bottom - top}px`)) } function drawForLine(line, fromArg, toArg) { let lineObj = getLine(doc, line) let lineLen = lineObj.text.length let start, end function coords(ch, bias) { return charCoords(cm, Pos(line, ch), "div", lineObj, bias) } function wrapX(pos, dir, side) { let extent = wrappedLineExtentChar(cm, lineObj, null, pos) let prop = (dir == "ltr") == (side == "after") ? "left" : "right" let ch = side == "after" ? extent.begin : extent.end - (/\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1) return coords(ch, prop)[prop] } let order = getOrder(lineObj, doc.direction) iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, (from, to, dir, i) => { let ltr = dir == "ltr" let fromPos = coords(from, ltr ? "left" : "right") let toPos = coords(to - 1, ltr ? "right" : "left") let openStart = fromArg == null && from == 0, openEnd = toArg == null && to == lineLen let first = i == 0, last = !order || i == order.length - 1 if (toPos.top - fromPos.top <= 3) { // Single line let openLeft = (docLTR ? openStart : openEnd) && first let openRight = (docLTR ? openEnd : openStart) && last let left = openLeft ? leftSide : (ltr ? fromPos : toPos).left let right = openRight ? rightSide : (ltr ? toPos : fromPos).right add(left, fromPos.top, right - left, fromPos.bottom) } else { // Multiple lines let topLeft, topRight, botLeft, botRight if (ltr) { topLeft = docLTR && openStart && first ? leftSide : fromPos.left topRight = docLTR ? rightSide : wrapX(from, dir, "before") botLeft = docLTR ? leftSide : wrapX(to, dir, "after") botRight = docLTR && openEnd && last ? rightSide : toPos.right } else { topLeft = !docLTR ? leftSide : wrapX(from, dir, "before") topRight = !docLTR && openStart && first ? rightSide : fromPos.right botLeft = !docLTR && openEnd && last ? leftSide : toPos.left botRight = !docLTR ? rightSide : wrapX(to, dir, "after") } add(topLeft, fromPos.top, topRight - topLeft, fromPos.bottom) if (fromPos.bottom < toPos.top) add(leftSide, fromPos.bottom, null, toPos.top) add(botLeft, toPos.top, botRight - botLeft, toPos.bottom) } if (!start || cmpCoords(fromPos, start) < 0) start = fromPos if (cmpCoords(toPos, start) < 0) start = toPos if (!end || cmpCoords(fromPos, end) < 0) end = fromPos if (cmpCoords(toPos, end) < 0) end = toPos }) return {start: start, end: end} } let sFrom = range.from(), sTo = range.to() if (sFrom.line == sTo.line) { drawForLine(sFrom.line, sFrom.ch, sTo.ch) } else { let fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line) let singleVLine = visualLine(fromLine) == visualLine(toLine) let leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end let rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start if (singleVLine) { if (leftEnd.top < rightStart.top - 2) { add(leftEnd.right, leftEnd.top, null, leftEnd.bottom) add(leftSide, rightStart.top, rightStart.left, rightStart.bottom) } else { add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom) } } if (leftEnd.bottom < rightStart.top) add(leftSide, leftEnd.bottom, null, rightStart.top) } output.appendChild(fragment) } // Cursor-blinking export function restartBlink(cm) { if (!cm.state.focused) return let display = cm.display clearInterval(display.blinker) let on = true display.cursorDiv.style.visibility = "" if (cm.options.cursorBlinkRate > 0) display.blinker = setInterval(() => { if (!cm.hasFocus()) onBlur(cm) display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden" }, cm.options.cursorBlinkRate) else if (cm.options.cursorBlinkRate < 0) display.cursorDiv.style.visibility = "hidden" } PK �S�Zݛ�h� � src/display/update_line.jsnu �[��� import { buildLineContent } from "../line/line_data.js" import { lineNumberFor } from "../line/utils_line.js" import { ie, ie_version } from "../util/browser.js" import { elt, classTest } from "../util/dom.js" import { signalLater } from "../util/operation_group.js" // When an aspect of a line changes, a string is added to // lineView.changes. This updates the relevant part of the line's // DOM structure. export function updateLineForChanges(cm, lineView, lineN, dims) { for (let j = 0; j < lineView.changes.length; j++) { let type = lineView.changes[j] if (type == "text") updateLineText(cm, lineView) else if (type == "gutter") updateLineGutter(cm, lineView, lineN, dims) else if (type == "class") updateLineClasses(cm, lineView) else if (type == "widget") updateLineWidgets(cm, lineView, dims) } lineView.changes = null } // Lines with gutter elements, widgets or a background class need to // be wrapped, and have the extra elements added to the wrapper div function ensureLineWrapped(lineView) { if (lineView.node == lineView.text) { lineView.node = elt("div", null, null, "position: relative") if (lineView.text.parentNode) lineView.text.parentNode.replaceChild(lineView.node, lineView.text) lineView.node.appendChild(lineView.text) if (ie && ie_version < 8) lineView.node.style.zIndex = 2 } return lineView.node } function updateLineBackground(cm, lineView) { let cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass if (cls) cls += " CodeMirror-linebackground" if (lineView.background) { if (cls) lineView.background.className = cls else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null } } else if (cls) { let wrap = ensureLineWrapped(lineView) lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild) cm.display.input.setUneditable(lineView.background) } } // Wrapper around buildLineContent which will reuse the structure // in display.externalMeasured when possible. function getLineContent(cm, lineView) { let ext = cm.display.externalMeasured if (ext && ext.line == lineView.line) { cm.display.externalMeasured = null lineView.measure = ext.measure return ext.built } return buildLineContent(cm, lineView) } // Redraw the line's text. Interacts with the background and text // classes because the mode may output tokens that influence these // classes. function updateLineText(cm, lineView) { let cls = lineView.text.className let built = getLineContent(cm, lineView) if (lineView.text == lineView.node) lineView.node = built.pre lineView.text.parentNode.replaceChild(built.pre, lineView.text) lineView.text = built.pre if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) { lineView.bgClass = built.bgClass lineView.textClass = built.textClass updateLineClasses(cm, lineView) } else if (cls) { lineView.text.className = cls } } function updateLineClasses(cm, lineView) { updateLineBackground(cm, lineView) if (lineView.line.wrapClass) ensureLineWrapped(lineView).className = lineView.line.wrapClass else if (lineView.node != lineView.text) lineView.node.className = "" let textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass lineView.text.className = textClass || "" } function updateLineGutter(cm, lineView, lineN, dims) { if (lineView.gutter) { lineView.node.removeChild(lineView.gutter) lineView.gutter = null } if (lineView.gutterBackground) { lineView.node.removeChild(lineView.gutterBackground) lineView.gutterBackground = null } if (lineView.line.gutterClass) { let wrap = ensureLineWrapped(lineView) lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass, `left: ${cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth}px; width: ${dims.gutterTotalWidth}px`) cm.display.input.setUneditable(lineView.gutterBackground) wrap.insertBefore(lineView.gutterBackground, lineView.text) } let markers = lineView.line.gutterMarkers if (cm.options.lineNumbers || markers) { let wrap = ensureLineWrapped(lineView) let gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", `left: ${cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth}px`) cm.display.input.setUneditable(gutterWrap) wrap.insertBefore(gutterWrap, lineView.text) if (lineView.line.gutterClass) gutterWrap.className += " " + lineView.line.gutterClass if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"])) lineView.lineNumber = gutterWrap.appendChild( elt("div", lineNumberFor(cm.options, lineN), "CodeMirror-linenumber CodeMirror-gutter-elt", `left: ${dims.gutterLeft["CodeMirror-linenumbers"]}px; width: ${cm.display.lineNumInnerWidth}px`)) if (markers) for (let k = 0; k < cm.display.gutterSpecs.length; ++k) { let id = cm.display.gutterSpecs[k].className, found = markers.hasOwnProperty(id) && markers[id] if (found) gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", `left: ${dims.gutterLeft[id]}px; width: ${dims.gutterWidth[id]}px`)) } } } function updateLineWidgets(cm, lineView, dims) { if (lineView.alignable) lineView.alignable = null let isWidget = classTest("CodeMirror-linewidget") for (let node = lineView.node.firstChild, next; node; node = next) { next = node.nextSibling if (isWidget.test(node.className)) lineView.node.removeChild(node) } insertLineWidgets(cm, lineView, dims) } // Build a line's DOM representation from scratch export function buildLineElement(cm, lineView, lineN, dims) { let built = getLineContent(cm, lineView) lineView.text = lineView.node = built.pre if (built.bgClass) lineView.bgClass = built.bgClass if (built.textClass) lineView.textClass = built.textClass updateLineClasses(cm, lineView) updateLineGutter(cm, lineView, lineN, dims) insertLineWidgets(cm, lineView, dims) return lineView.node } // A lineView may contain multiple logical lines (when merged by // collapsed spans). The widgets for all of them need to be drawn. function insertLineWidgets(cm, lineView, dims) { insertLineWidgetsFor(cm, lineView.line, lineView, dims, true) if (lineView.rest) for (let i = 0; i < lineView.rest.length; i++) insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false) } function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) { if (!line.widgets) return let wrap = ensureLineWrapped(lineView) for (let i = 0, ws = line.widgets; i < ws.length; ++i) { let widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget" + (widget.className ? " " + widget.className : "")) if (!widget.handleMouseEvents) node.setAttribute("cm-ignore-events", "true") positionLineWidget(widget, node, lineView, dims) cm.display.input.setUneditable(node) if (allowAbove && widget.above) wrap.insertBefore(node, lineView.gutter || lineView.text) else wrap.appendChild(node) signalLater(widget, "redraw") } } function positionLineWidget(widget, node, lineView, dims) { if (widget.noHScroll) { ;(lineView.alignable || (lineView.alignable = [])).push(node) let width = dims.wrapperWidth node.style.left = dims.fixedPos + "px" if (!widget.coverGutter) { width -= dims.gutterTotalWidth node.style.paddingLeft = dims.gutterTotalWidth + "px" } node.style.width = width + "px" } if (widget.coverGutter) { node.style.zIndex = 5 node.style.position = "relative" if (!widget.noHScroll) node.style.marginLeft = -dims.gutterTotalWidth + "px" } } PK �S�ZLw�� � src/display/scroll_events.jsnu �[��� import { chrome, gecko, ie, mac, presto, safari, webkit } from "../util/browser.js" import { e_preventDefault } from "../util/event.js" import { updateDisplaySimple } from "./update_display.js" import { setScrollLeft, updateScrollTop } from "./scrolling.js" // Since the delta values reported on mouse wheel events are // unstandardized between browsers and even browser versions, and // generally horribly unpredictable, this code starts by measuring // the scroll effect that the first few mouse wheel events have, // and, from that, detects the way it can convert deltas to pixel // offsets afterwards. // // The reason we want to know the amount a wheel event will scroll // is that it gives us a chance to update the display before the // actual scrolling happens, reducing flickering. let wheelSamples = 0, wheelPixelsPerUnit = null // Fill in a browser-detected starting value on browsers where we // know one. These don't have to be accurate -- the result of them // being wrong would just be a slight flicker on the first wheel // scroll (if it is large enough). if (ie) wheelPixelsPerUnit = -.53 else if (gecko) wheelPixelsPerUnit = 15 else if (chrome) wheelPixelsPerUnit = -.7 else if (safari) wheelPixelsPerUnit = -1/3 function wheelEventDelta(e) { let dx = e.wheelDeltaX, dy = e.wheelDeltaY if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail else if (dy == null) dy = e.wheelDelta return {x: dx, y: dy} } export function wheelEventPixels(e) { let delta = wheelEventDelta(e) delta.x *= wheelPixelsPerUnit delta.y *= wheelPixelsPerUnit return delta } export function onScrollWheel(cm, e) { let delta = wheelEventDelta(e), dx = delta.x, dy = delta.y let display = cm.display, scroll = display.scroller // Quit if there's nothing to scroll here let canScrollX = scroll.scrollWidth > scroll.clientWidth let canScrollY = scroll.scrollHeight > scroll.clientHeight if (!(dx && canScrollX || dy && canScrollY)) return // Webkit browsers on OS X abort momentum scrolls when the target // of the scroll event is removed from the scrollable element. // This hack (see related code in patchDisplay) makes sure the // element is kept around. if (dy && mac && webkit) { outer: for (let cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) { for (let i = 0; i < view.length; i++) { if (view[i].node == cur) { cm.display.currentWheelTarget = cur break outer } } } } // On some browsers, horizontal scrolling will cause redraws to // happen before the gutter has been realigned, causing it to // wriggle around in a most unseemly way. When we have an // estimated pixels/delta value, we just handle horizontal // scrolling entirely here. It'll be slightly off from native, but // better than glitching out. if (dx && !gecko && !presto && wheelPixelsPerUnit != null) { if (dy && canScrollY) updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * wheelPixelsPerUnit)) setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * wheelPixelsPerUnit)) // Only prevent default scrolling if vertical scrolling is // actually possible. Otherwise, it causes vertical scroll // jitter on OSX trackpads when deltaX is small and deltaY // is large (issue #3579) if (!dy || (dy && canScrollY)) e_preventDefault(e) display.wheelStartX = null // Abort measurement, if in progress return } // 'Project' the visible viewport to cover the area that is being // scrolled into view (if we know enough to estimate it). if (dy && wheelPixelsPerUnit != null) { let pixels = dy * wheelPixelsPerUnit let top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight if (pixels < 0) top = Math.max(0, top + pixels - 50) else bot = Math.min(cm.doc.height, bot + pixels + 50) updateDisplaySimple(cm, {top: top, bottom: bot}) } if (wheelSamples < 20) { if (display.wheelStartX == null) { display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop display.wheelDX = dx; display.wheelDY = dy setTimeout(() => { if (display.wheelStartX == null) return let movedX = scroll.scrollLeft - display.wheelStartX let movedY = scroll.scrollTop - display.wheelStartY let sample = (movedY && display.wheelDY && movedY / display.wheelDY) || (movedX && display.wheelDX && movedX / display.wheelDX) display.wheelStartX = display.wheelStartY = null if (!sample) return wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1) ++wheelSamples }, 200) } else { display.wheelDX += dx; display.wheelDY += dy } } } PK �S�Z����7 7 src/display/Display.jsnu �[��� import { gecko, ie, ie_version, mobile, webkit } from "../util/browser.js" import { elt, eltP } from "../util/dom.js" import { scrollerGap } from "../util/misc.js" import { getGutters, renderGutters } from "./gutters.js" // The display handles the DOM integration, both for input reading // and content drawing. It holds references to DOM nodes and // display-related state. export function Display(place, doc, input, options) { let d = this this.input = input // Covers bottom-right square when both scrollbars are present. d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler") d.scrollbarFiller.setAttribute("cm-not-content", "true") // Covers bottom of gutter when coverGutterNextToScrollbar is on // and h scrollbar is present. d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler") d.gutterFiller.setAttribute("cm-not-content", "true") // Will contain the actual code, positioned to cover the viewport. d.lineDiv = eltP("div", null, "CodeMirror-code") // Elements are added to these to represent selection and cursors. d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1") d.cursorDiv = elt("div", null, "CodeMirror-cursors") // A visibility: hidden element used to find the size of things. d.measure = elt("div", null, "CodeMirror-measure") // When lines outside of the viewport are measured, they are drawn in this. d.lineMeasure = elt("div", null, "CodeMirror-measure") // Wraps everything that needs to exist inside the vertically-padded coordinate system d.lineSpace = eltP("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv], null, "position: relative; outline: none") let lines = eltP("div", [d.lineSpace], "CodeMirror-lines") // Moved around its parent to cover visible view. d.mover = elt("div", [lines], null, "position: relative") // Set to the height of the document, allowing scrolling. d.sizer = elt("div", [d.mover], "CodeMirror-sizer") d.sizerWidth = null // Behavior of elts with overflow: auto and padding is // inconsistent across browsers. This is used to ensure the // scrollable area is big enough. d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;") // Will contain the gutters, if any. d.gutters = elt("div", null, "CodeMirror-gutters") d.lineGutter = null // Actual scrollable element. d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll") d.scroller.setAttribute("tabIndex", "-1") // The element in which the editor lives. d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror") // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported) if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0 } if (!webkit && !(gecko && mobile)) d.scroller.draggable = true if (place) { if (place.appendChild) place.appendChild(d.wrapper) else place(d.wrapper) } // Current rendered range (may be bigger than the view window). d.viewFrom = d.viewTo = doc.first d.reportedViewFrom = d.reportedViewTo = doc.first // Information about the rendered lines. d.view = [] d.renderedView = null // Holds info about a single rendered line when it was rendered // for measurement, while not in view. d.externalMeasured = null // Empty space (in pixels) above the view d.viewOffset = 0 d.lastWrapHeight = d.lastWrapWidth = 0 d.updateLineNumbers = null d.nativeBarWidth = d.barHeight = d.barWidth = 0 d.scrollbarsClipped = false // Used to only resize the line number gutter when necessary (when // the amount of lines crosses a boundary that makes its width change) d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null // Set to true when a non-horizontal-scrolling line widget is // added. As an optimization, line widget aligning is skipped when // this is false. d.alignWidgets = false d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null // Tracks the maximum line length so that the horizontal scrollbar // can be kept static when scrolling. d.maxLine = null d.maxLineLength = 0 d.maxLineChanged = false // Used for measuring wheel scrolling granularity d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null // True when shift is held down. d.shift = false // Used to track whether anything happened since the context menu // was opened. d.selForContextMenu = null d.activeTouch = null d.gutterSpecs = getGutters(options.gutters, options.lineNumbers) renderGutters(d) input.init(d) } PK �S�Z�0�^ ^ src/display/operations.jsnu �[��� import { clipPos } from "../line/pos.js" import { findMaxLine } from "../line/spans.js" import { displayWidth, measureChar, scrollGap } from "../measurement/position_measurement.js" import { signal } from "../util/event.js" import { activeElt } from "../util/dom.js" import { finishOperation, pushOperation } from "../util/operation_group.js" import { ensureFocus } from "./focus.js" import { measureForScrollbars, updateScrollbars } from "./scrollbars.js" import { restartBlink } from "./selection.js" import { maybeScrollWindow, scrollPosIntoView, setScrollLeft, setScrollTop } from "./scrolling.js" import { DisplayUpdate, maybeClipScrollbars, postUpdateDisplay, setDocumentHeight, updateDisplayIfNeeded } from "./update_display.js" import { updateHeightsInViewport } from "./update_lines.js" // Operations are used to wrap a series of changes to the editor // state in such a way that each change won't have to update the // cursor and display (which would be awkward, slow, and // error-prone). Instead, display updates are batched and then all // combined and executed at once. let nextOpId = 0 // Start a new operation. export function startOperation(cm) { cm.curOp = { cm: cm, viewChanged: false, // Flag that indicates that lines might need to be redrawn startHeight: cm.doc.height, // Used to detect need to update scrollbar forceUpdate: false, // Used to force a redraw updateInput: 0, // Whether to reset the input textarea typing: false, // Whether this reset should be careful to leave existing text (for compositing) changeObjs: null, // Accumulated changes, for firing change events cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already selectionChanged: false, // Whether the selection needs to be redrawn updateMaxLine: false, // Set when the widest line needs to be determined anew scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet scrollToPos: null, // Used to scroll to a specific position focus: false, id: ++nextOpId // Unique ID } pushOperation(cm.curOp) } // Finish an operation, updating the display and signalling delayed events export function endOperation(cm) { let op = cm.curOp if (op) finishOperation(op, group => { for (let i = 0; i < group.ops.length; i++) group.ops[i].cm.curOp = null endOperations(group) }) } // The DOM updates done when an operation finishes are batched so // that the minimum number of relayouts are required. function endOperations(group) { let ops = group.ops for (let i = 0; i < ops.length; i++) // Read DOM endOperation_R1(ops[i]) for (let i = 0; i < ops.length; i++) // Write DOM (maybe) endOperation_W1(ops[i]) for (let i = 0; i < ops.length; i++) // Read DOM endOperation_R2(ops[i]) for (let i = 0; i < ops.length; i++) // Write DOM (maybe) endOperation_W2(ops[i]) for (let i = 0; i < ops.length; i++) // Read DOM endOperation_finish(ops[i]) } function endOperation_R1(op) { let cm = op.cm, display = cm.display maybeClipScrollbars(cm) if (op.updateMaxLine) findMaxLine(cm) op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null || op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom || op.scrollToPos.to.line >= display.viewTo) || display.maxLineChanged && cm.options.lineWrapping op.update = op.mustUpdate && new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate) } function endOperation_W1(op) { op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update) } function endOperation_R2(op) { let cm = op.cm, display = cm.display if (op.updatedDisplay) updateHeightsInViewport(cm) op.barMeasure = measureForScrollbars(cm) // If the max line changed since it was last measured, measure it, // and ensure the document's width matches it. // updateDisplay_W2 will use these properties to do the actual resizing if (display.maxLineChanged && !cm.options.lineWrapping) { op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3 cm.display.sizerWidth = op.adjustWidthTo op.barMeasure.scrollWidth = Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth) op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm)) } if (op.updatedDisplay || op.selectionChanged) op.preparedSelection = display.input.prepareSelection() } function endOperation_W2(op) { let cm = op.cm if (op.adjustWidthTo != null) { cm.display.sizer.style.minWidth = op.adjustWidthTo + "px" if (op.maxScrollLeft < cm.doc.scrollLeft) setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true) cm.display.maxLineChanged = false } let takeFocus = op.focus && op.focus == activeElt() if (op.preparedSelection) cm.display.input.showSelection(op.preparedSelection, takeFocus) if (op.updatedDisplay || op.startHeight != cm.doc.height) updateScrollbars(cm, op.barMeasure) if (op.updatedDisplay) setDocumentHeight(cm, op.barMeasure) if (op.selectionChanged) restartBlink(cm) if (cm.state.focused && op.updateInput) cm.display.input.reset(op.typing) if (takeFocus) ensureFocus(op.cm) } function endOperation_finish(op) { let cm = op.cm, display = cm.display, doc = cm.doc if (op.updatedDisplay) postUpdateDisplay(cm, op.update) // Abort mouse wheel delta measurement, when scrolling explicitly if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos)) display.wheelStartX = display.wheelStartY = null // Propagate the scroll position to the actual DOM scroller if (op.scrollTop != null) setScrollTop(cm, op.scrollTop, op.forceScroll) if (op.scrollLeft != null) setScrollLeft(cm, op.scrollLeft, true, true) // If we need to scroll a specific position into view, do so. if (op.scrollToPos) { let rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from), clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin) maybeScrollWindow(cm, rect) } // Fire events for markers that are hidden/unidden by editing or // undoing let hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers if (hidden) for (let i = 0; i < hidden.length; ++i) if (!hidden[i].lines.length) signal(hidden[i], "hide") if (unhidden) for (let i = 0; i < unhidden.length; ++i) if (unhidden[i].lines.length) signal(unhidden[i], "unhide") if (display.wrapper.offsetHeight) doc.scrollTop = cm.display.scroller.scrollTop // Fire change events, and delayed event handlers if (op.changeObjs) signal(cm, "changes", cm, op.changeObjs) if (op.update) op.update.finish() } // Run the given function in an operation export function runInOp(cm, f) { if (cm.curOp) return f() startOperation(cm) try { return f() } finally { endOperation(cm) } } // Wraps a function in an operation. Returns the wrapped function. export function operation(cm, f) { return function() { if (cm.curOp) return f.apply(cm, arguments) startOperation(cm) try { return f.apply(cm, arguments) } finally { endOperation(cm) } } } // Used to add methods to editor and doc instances, wrapping them in // operations. export function methodOp(f) { return function() { if (this.curOp) return f.apply(this, arguments) startOperation(this) try { return f.apply(this, arguments) } finally { endOperation(this) } } } export function docMethodOp(f) { return function() { let cm = this.cm if (!cm || cm.curOp) return f.apply(this, arguments) startOperation(cm) try { return f.apply(this, arguments) } finally { endOperation(cm) } } } PK �S�ZTf�H H ! src/addon/runmode/runmode.node.jsnu �[��� import "./codemirror.node.js" import "../../../addon/runmode/runmode.js"PK �S�ZR�6�R R * src/addon/runmode/codemirror-standalone.jsnu �[��� import StringStream from "../../util/StringStream.js" import * as modeMethods from "../../modes.js" // declare global: globalThis, CodeMirror // Create a minimal CodeMirror needed to use runMode, and assign to root. var root = typeof globalThis !== 'undefined' ? globalThis : window root.CodeMirror = {} // Copy StringStream and mode methods into CodeMirror object. CodeMirror.StringStream = StringStream for (var exported in modeMethods) CodeMirror[exported] = modeMethods[exported] // Minimal default mode. CodeMirror.defineMode("null", () => ({token: stream => stream.skipToEnd()})) CodeMirror.defineMIME("text/plain", "null") CodeMirror.registerHelper = CodeMirror.registerGlobalHelper = Math.min CodeMirror.splitLines = function(string) { return string.split(/\r?\n|\r/) } CodeMirror.defaults = { indentUnit: 2 } export default CodeMirror PK �S�Z;W�+� � $ src/addon/runmode/codemirror.node.jsnu �[��� import StringStream from "../../util/StringStream.js" import * as modeMethods from "../../modes.js" import {countColumn} from "../../util/misc.js" // Copy StringStream and mode methods into exports (CodeMirror) object. exports.StringStream = StringStream exports.countColumn = countColumn for (var exported in modeMethods) exports[exported] = modeMethods[exported] // Shim library CodeMirror with the minimal CodeMirror defined above. require.cache[require.resolve("../../lib/codemirror")] = require.cache[require.resolve("./runmode.node")] require.cache[require.resolve("../../addon/runmode/runmode")] = require.cache[require.resolve("./runmode.node")] // Minimal default mode. exports.defineMode("null", () => ({token: stream => stream.skipToEnd()})) exports.defineMIME("text/plain", "null") exports.registerHelper = exports.registerGlobalHelper = Math.min exports.splitLines = function(string) { return string.split(/\r?\n|\r/) } exports.defaults = { indentUnit: 2 } PK �S�ZrB�N N '