tui_editor-rails 1.0.2.0

data/vendor/assets/components/codemirror/src/input/keymap.js

@@ -0,0 +1,148 @@
+import { flipCtrlCmd, mac, presto } from "../util/browser.js"
+import { map } from "../util/misc.js"
+
+import { keyNames } from "./keynames.js"
+
+export let keyMap = {}
+
+keyMap.basic = {
+  "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
+  "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
+  "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
+  "Tab": "defaultTab", "Shift-Tab": "indentAuto",
+  "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
+  "Esc": "singleSelection"
+}
+// Note that the save and find-related commands aren't defined by
+// default. User code or addons can define them. Unknown commands
+// are simply ignored.
+keyMap.pcDefault = {
+  "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
+  "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
+  "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
+  "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
+  "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
+  "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
+  "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
+  fallthrough: "basic"
+}
+// Very basic readline/emacs-style bindings, which are standard on Mac.
+keyMap.emacsy = {
+  "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
+  "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
+  "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
+  "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars",
+  "Ctrl-O": "openLine"
+}
+keyMap.macDefault = {
+  "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
+  "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
+  "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
+  "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
+  "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
+  "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
+  "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
+  fallthrough: ["basic", "emacsy"]
+}
+keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault
+
+// KEYMAP DISPATCH
+
+function normalizeKeyName(name) {
+  let parts = name.split(/-(?!$)/)
+  name = parts[parts.length - 1]
+  let alt, ctrl, shift, cmd
+  for (let i = 0; i < parts.length - 1; i++) {
+    let mod = parts[i]
+    if (/^(cmd|meta|m)$/i.test(mod)) cmd = true
+    else if (/^a(lt)?$/i.test(mod)) alt = true
+    else if (/^(c|ctrl|control)$/i.test(mod)) ctrl = true
+    else if (/^s(hift)?$/i.test(mod)) shift = true
+    else throw new Error("Unrecognized modifier name: " + mod)
+  }
+  if (alt) name = "Alt-" + name
+  if (ctrl) name = "Ctrl-" + name
+  if (cmd) name = "Cmd-" + name
+  if (shift) name = "Shift-" + name
+  return name
+}
+
+// This is a kludge to keep keymaps mostly working as raw objects
+// (backwards compatibility) while at the same time support features
+// like normalization and multi-stroke key bindings. It compiles a
+// new normalized keymap, and then updates the old object to reflect
+// this.
+export function normalizeKeyMap(keymap) {
+  let copy = {}
+  for (let keyname in keymap) if (keymap.hasOwnProperty(keyname)) {
+    let value = keymap[keyname]
+    if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) continue
+    if (value == "...") { delete keymap[keyname]; continue }
+
+    let keys = map(keyname.split(" "), normalizeKeyName)
+    for (let i = 0; i < keys.length; i++) {
+      let val, name
+      if (i == keys.length - 1) {
+        name = keys.join(" ")
+        val = value
+      } else {
+        name = keys.slice(0, i + 1).join(" ")
+        val = "..."
+      }
+      let prev = copy[name]
+      if (!prev) copy[name] = val
+      else if (prev != val) throw new Error("Inconsistent bindings for " + name)
+    }
+    delete keymap[keyname]
+  }
+  for (let prop in copy) keymap[prop] = copy[prop]
+  return keymap
+}
+
+export function lookupKey(key, map, handle, context) {
+  map = getKeyMap(map)
+  let found = map.call ? map.call(key, context) : map[key]
+  if (found === false) return "nothing"
+  if (found === "...") return "multi"
+  if (found != null && handle(found)) return "handled"
+
+  if (map.fallthrough) {
+    if (Object.prototype.toString.call(map.fallthrough) != "[object Array]")
+      return lookupKey(key, map.fallthrough, handle, context)
+    for (let i = 0; i < map.fallthrough.length; i++) {
+      let result = lookupKey(key, map.fallthrough[i], handle, context)
+      if (result) return result
+    }
+  }
+}
+
+// Modifier key presses don't count as 'real' key presses for the
+// purpose of keymap fallthrough.
+export function isModifierKey(value) {
+  let name = typeof value == "string" ? value : keyNames[value.keyCode]
+  return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod"
+}
+
+export function addModifierNames(name, event, noShift) {
+  let base = name
+  if (event.altKey && base != "Alt") name = "Alt-" + name
+  if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") name = "Ctrl-" + name
+  if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") name = "Cmd-" + name
+  if (!noShift && event.shiftKey && base != "Shift") name = "Shift-" + name
+  return name
+}
+
+// Look up the name of a key as indicated by an event object.
+export function keyName(event, noShift) {
+  if (presto && event.keyCode == 34 && event["char"]) return false
+  let name = keyNames[event.keyCode]
+  if (name == null || event.altGraphKey) return false
+  // Ctrl-ScrollLock has keyCode 3, same as Ctrl-Pause,
+  // so we'll use event.code when available (Chrome 48+, FF 38+, Safari 10.1+)
+  if (event.keyCode == 3 && event.code) name = event.code
+  return addModifierNames(name, event, noShift)
+}
+
+export function getKeyMap(val) {
+  return typeof val == "string" ? keyMap[val] : val
+}

data/vendor/assets/components/codemirror/src/input/keynames.js

@@ -0,0 +1,17 @@
+export let keyNames = {
+  3: "Pause", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
+  19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
+  36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
+  46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod",
+  106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete", 145: "ScrollLock",
+  173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
+  221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
+  63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"
+}
+
+// Number keys
+for (let i = 0; i < 10; i++) keyNames[i + 48] = keyNames[i + 96] = String(i)
+// Alphabetic keys
+for (let i = 65; i <= 90; i++) keyNames[i] = String.fromCharCode(i)
+// Function keys
+for (let i = 1; i <= 12; i++) keyNames[i + 111] = keyNames[i + 63235] = "F" + i

data/vendor/assets/components/codemirror/src/input/movement.js

@@ -0,0 +1,110 @@
+import { Pos } from "../line/pos.js"
+import { prepareMeasureForLine, measureCharPrepared, wrappedLineExtentChar } from "../measurement/position_measurement.js"
+import { getBidiPartAt, getOrder } from "../util/bidi.js"
+import { findFirst, lst, skipExtendingChars } from "../util/misc.js"
+
+function moveCharLogically(line, ch, dir) {
+  let target = skipExtendingChars(line.text, ch + dir, dir)
+  return target < 0 || target > line.text.length ? null : target
+}
+
+export function moveLogically(line, start, dir) {
+  let ch = moveCharLogically(line, start.ch, dir)
+  return ch == null ? null : new Pos(start.line, ch, dir < 0 ? "after" : "before")
+}
+
+export function endOfLine(visually, cm, lineObj, lineNo, dir) {
+  if (visually) {
+    let order = getOrder(lineObj, cm.doc.direction)
+    if (order) {
+      let part = dir < 0 ? lst(order) : order[0]
+      let moveInStorageOrder = (dir < 0) == (part.level == 1)
+      let sticky = moveInStorageOrder ? "after" : "before"
+      let ch
+      // With a wrapped rtl chunk (possibly spanning multiple bidi parts),
+      // it could be that the last bidi part is not on the last visual line,
+      // since visual lines contain content order-consecutive chunks.
+      // Thus, in rtl, we are looking for the first (content-order) character
+      // in the rtl chunk that is on the last line (that is, the same line
+      // as the last (content-order) character).
+      if (part.level > 0 || cm.doc.direction == "rtl") {
+        let prep = prepareMeasureForLine(cm, lineObj)
+        ch = dir < 0 ? lineObj.text.length - 1 : 0
+        let targetTop = measureCharPrepared(cm, prep, ch).top
+        ch = findFirst(ch => measureCharPrepared(cm, prep, ch).top == targetTop, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch)
+        if (sticky == "before") ch = moveCharLogically(lineObj, ch, 1)
+      } else ch = dir < 0 ? part.to : part.from
+      return new Pos(lineNo, ch, sticky)
+    }
+  }
+  return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? "before" : "after")
+}
+
+export function moveVisually(cm, line, start, dir) {
+  let bidi = getOrder(line, cm.doc.direction)
+  if (!bidi) return moveLogically(line, start, dir)
+  if (start.ch >= line.text.length) {
+    start.ch = line.text.length
+    start.sticky = "before"
+  } else if (start.ch <= 0) {
+    start.ch = 0
+    start.sticky = "after"
+  }
+  let partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos]
+  if (cm.doc.direction == "ltr" && part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) {
+    // Case 1: We move within an ltr part in an ltr editor. Even with wrapped lines,
+    // nothing interesting happens.
+    return moveLogically(line, start, dir)
+  }
+
+  let mv = (pos, dir) => moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir)
+  let prep
+  let getWrappedLineExtent = ch => {
+    if (!cm.options.lineWrapping) return {begin: 0, end: line.text.length}
+    prep = prep || prepareMeasureForLine(cm, line)
+    return wrappedLineExtentChar(cm, line, prep, ch)
+  }
+  let wrappedLineExtent = getWrappedLineExtent(start.sticky == "before" ? mv(start, -1) : start.ch)
+
+  if (cm.doc.direction == "rtl" || part.level == 1) {
+    let moveInStorageOrder = (part.level == 1) == (dir < 0)
+    let ch = mv(start, moveInStorageOrder ? 1 : -1)
+    if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {
+      // Case 2: We move within an rtl part or in an rtl editor on the same visual line
+      let sticky = moveInStorageOrder ? "before" : "after"
+      return new Pos(start.line, ch, sticky)
+    }
+  }
+
+  // Case 3: Could not move within this bidi part in this visual line, so leave
+  // the current bidi part
+
+  let searchInVisualLine = (partPos, dir, wrappedLineExtent) => {
+    let getRes = (ch, moveInStorageOrder) => moveInStorageOrder
+      ? new Pos(start.line, mv(ch, 1), "before")
+      : new Pos(start.line, ch, "after")
+
+    for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {
+      let part = bidi[partPos]
+      let moveInStorageOrder = (dir > 0) == (part.level != 1)
+      let ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1)
+      if (part.from <= ch && ch < part.to) return getRes(ch, moveInStorageOrder)
+      ch = moveInStorageOrder ? part.from : mv(part.to, -1)
+      if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) return getRes(ch, moveInStorageOrder)
+    }
+  }
+
+  // Case 3a: Look for other bidi parts on the same visual line
+  let res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent)
+  if (res) return res
+
+  // Case 3b: Look for other bidi parts on the next visual line
+  let nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1)
+  if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {
+    res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh))
+    if (res) return res
+  }
+
+  // Case 4: Nowhere to move
+  return null
+}

data/vendor/assets/components/codemirror/src/line/highlight.js

@@ -0,0 +1,284 @@
+import { countColumn } from "../util/misc.js"
+import { copyState, innerMode, startState } from "../modes.js"
+import StringStream from "../util/StringStream.js"
+
+import { getLine, lineNo } from "./utils_line.js"
+import { clipPos } from "./pos.js"
+
+class SavedContext {
+  constructor(state, lookAhead) {
+    this.state = state
+    this.lookAhead = lookAhead
+  }
+}
+
+class Context {
+  constructor(doc, state, line, lookAhead) {
+    this.state = state
+    this.doc = doc
+    this.line = line
+    this.maxLookAhead = lookAhead || 0
+    this.baseTokens = null
+    this.baseTokenPos = 1
+  }
+
+  lookAhead(n) {
+    let line = this.doc.getLine(this.line + n)
+    if (line != null && n > this.maxLookAhead) this.maxLookAhead = n
+    return line
+  }
+
+  baseToken(n) {
+    if (!this.baseTokens) return null
+    while (this.baseTokens[this.baseTokenPos] <= n)
+      this.baseTokenPos += 2
+    let type = this.baseTokens[this.baseTokenPos + 1]
+    return {type: type && type.replace(/( |^)overlay .*/, ""),
+            size: this.baseTokens[this.baseTokenPos] - n}
+  }
+
+  nextLine() {
+    this.line++
+    if (this.maxLookAhead > 0) this.maxLookAhead--
+  }
+
+  static fromSaved(doc, saved, line) {
+    if (saved instanceof SavedContext)
+      return new Context(doc, copyState(doc.mode, saved.state), line, saved.lookAhead)
+    else
+      return new Context(doc, copyState(doc.mode, saved), line)
+  }
+
+  save(copy) {
+    let state = copy !== false ? copyState(this.doc.mode, this.state) : this.state
+    return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state
+  }
+}
+
+
+// Compute a style array (an array starting with a mode generation
+// -- for invalidation -- followed by pairs of end positions and
+// style strings), which is used to highlight the tokens on the
+// line.
+export function highlightLine(cm, line, context, forceToEnd) {
+  // A styles array always starts with a number identifying the
+  // mode/overlays that it is based on (for easy invalidation).
+  let st = [cm.state.modeGen], lineClasses = {}
+  // Compute the base array of styles
+  runMode(cm, line.text, cm.doc.mode, context, (end, style) => st.push(end, style),
+          lineClasses, forceToEnd)
+  let state = context.state
+
+  // Run overlays, adjust style array.
+  for (let o = 0; o < cm.state.overlays.length; ++o) {
+    context.baseTokens = st
+    let overlay = cm.state.overlays[o], i = 1, at = 0
+    context.state = true
+    runMode(cm, line.text, overlay.mode, context, (end, style) => {
+      let start = i
+      // Ensure there's a token end at the current position, and that i points at it
+      while (at < end) {
+        let i_end = st[i]
+        if (i_end > end)
+          st.splice(i, 1, end, st[i+1], i_end)
+        i += 2
+        at = Math.min(end, i_end)
+      }
+      if (!style) return
+      if (overlay.opaque) {
+        st.splice(start, i - start, end, "overlay " + style)
+        i = start + 2
+      } else {
+        for (; start < i; start += 2) {
+          let cur = st[start+1]
+          st[start+1] = (cur ? cur + " " : "") + "overlay " + style
+        }
+      }
+    }, lineClasses)
+    context.state = state
+    context.baseTokens = null
+    context.baseTokenPos = 1
+  }
+
+  return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}
+}
+
+export function getLineStyles(cm, line, updateFrontier) {
+  if (!line.styles || line.styles[0] != cm.state.modeGen) {
+    let context = getContextBefore(cm, lineNo(line))
+    let resetState = line.text.length > cm.options.maxHighlightLength && copyState(cm.doc.mode, context.state)
+    let result = highlightLine(cm, line, context)
+    if (resetState) context.state = resetState
+    line.stateAfter = context.save(!resetState)
+    line.styles = result.styles
+    if (result.classes) line.styleClasses = result.classes
+    else if (line.styleClasses) line.styleClasses = null
+    if (updateFrontier === cm.doc.highlightFrontier)
+      cm.doc.modeFrontier = Math.max(cm.doc.modeFrontier, ++cm.doc.highlightFrontier)
+  }
+  return line.styles
+}
+
+export function getContextBefore(cm, n, precise) {
+  let doc = cm.doc, display = cm.display
+  if (!doc.mode.startState) return new Context(doc, true, n)
+  let start = findStartLine(cm, n, precise)
+  let saved = start > doc.first && getLine(doc, start - 1).stateAfter
+  let context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start)
+
+  doc.iter(start, n, line => {
+    processLine(cm, line.text, context)
+    let pos = context.line
+    line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null
+    context.nextLine()
+  })
+  if (precise) doc.modeFrontier = context.line
+  return context
+}
+
+// Lightweight form of highlight -- proceed over this line and
+// update state, but don't save a style array. Used for lines that
+// aren't currently visible.
+export function processLine(cm, text, context, startAt) {
+  let mode = cm.doc.mode
+  let stream = new StringStream(text, cm.options.tabSize, context)
+  stream.start = stream.pos = startAt || 0
+  if (text == "") callBlankLine(mode, context.state)
+  while (!stream.eol()) {
+    readToken(mode, stream, context.state)
+    stream.start = stream.pos
+  }
+}
+
+function callBlankLine(mode, state) {
+  if (mode.blankLine) return mode.blankLine(state)
+  if (!mode.innerMode) return
+  let inner = innerMode(mode, state)
+  if (inner.mode.blankLine) return inner.mode.blankLine(inner.state)
+}
+
+export function readToken(mode, stream, state, inner) {
+  for (let i = 0; i < 10; i++) {
+    if (inner) inner[0] = innerMode(mode, state).mode
+    let style = mode.token(stream, state)
+    if (stream.pos > stream.start) return style
+  }
+  throw new Error("Mode " + mode.name + " failed to advance stream.")
+}
+
+class Token {
+  constructor(stream, type, state) {
+    this.start = stream.start; this.end = stream.pos
+    this.string = stream.current()
+    this.type = type || null
+    this.state = state
+  }
+}
+
+// Utility for getTokenAt and getLineTokens
+export function takeToken(cm, pos, precise, asArray) {
+  let doc = cm.doc, mode = doc.mode, style
+  pos = clipPos(doc, pos)
+  let line = getLine(doc, pos.line), context = getContextBefore(cm, pos.line, precise)
+  let stream = new StringStream(line.text, cm.options.tabSize, context), tokens
+  if (asArray) tokens = []
+  while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
+    stream.start = stream.pos
+    style = readToken(mode, stream, context.state)
+    if (asArray) tokens.push(new Token(stream, style, copyState(doc.mode, context.state)))
+  }
+  return asArray ? tokens : new Token(stream, style, context.state)
+}
+
+function extractLineClasses(type, output) {
+  if (type) for (;;) {
+    let lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/)
+    if (!lineClass) break
+    type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length)
+    let prop = lineClass[1] ? "bgClass" : "textClass"
+    if (output[prop] == null)
+      output[prop] = lineClass[2]
+    else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
+      output[prop] += " " + lineClass[2]
+  }
+  return type
+}
+
+// Run the given mode's parser over a line, calling f for each token.
+function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) {
+  let flattenSpans = mode.flattenSpans
+  if (flattenSpans == null) flattenSpans = cm.options.flattenSpans
+  let curStart = 0, curStyle = null
+  let stream = new StringStream(text, cm.options.tabSize, context), style
+  let inner = cm.options.addModeClass && [null]
+  if (text == "") extractLineClasses(callBlankLine(mode, context.state), lineClasses)
+  while (!stream.eol()) {
+    if (stream.pos > cm.options.maxHighlightLength) {
+      flattenSpans = false
+      if (forceToEnd) processLine(cm, text, context, stream.pos)
+      stream.pos = text.length
+      style = null
+    } else {
+      style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses)
+    }
+    if (inner) {
+      let mName = inner[0].name
+      if (mName) style = "m-" + (style ? mName + " " + style : mName)
+    }
+    if (!flattenSpans || curStyle != style) {
+      while (curStart < stream.start) {
+        curStart = Math.min(stream.start, curStart + 5000)
+        f(curStart, curStyle)
+      }
+      curStyle = style
+    }
+    stream.start = stream.pos
+  }
+  while (curStart < stream.pos) {
+    // Webkit seems to refuse to render text nodes longer than 57444
+    // characters, and returns inaccurate measurements in nodes
+    // starting around 5000 chars.
+    let pos = Math.min(stream.pos, curStart + 5000)
+    f(pos, curStyle)
+    curStart = pos
+  }
+}
+
+// Finds the line to start with when starting a parse. Tries to
+// find a line with a stateAfter, so that it can start with a
+// valid state. If that fails, it returns the line with the
+// smallest indentation, which tends to need the least context to
+// parse correctly.
+function findStartLine(cm, n, precise) {
+  let minindent, minline, doc = cm.doc
+  let lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100)
+  for (let search = n; search > lim; --search) {
+    if (search <= doc.first) return doc.first
+    let line = getLine(doc, search - 1), after = line.stateAfter
+    if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier))
+      return search
+    let indented = countColumn(line.text, null, cm.options.tabSize)
+    if (minline == null || minindent > indented) {
+      minline = search - 1
+      minindent = indented
+    }
+  }
+  return minline
+}
+
+export function retreatFrontier(doc, n) {
+  doc.modeFrontier = Math.min(doc.modeFrontier, n)
+  if (doc.highlightFrontier < n - 10) return
+  let start = doc.first
+  for (let line = n - 1; line > start; line--) {
+    let saved = getLine(doc, line).stateAfter
+    // change is on 3
+    // state on line 1 looked ahead 2 -- so saw 3
+    // test 1 + 2 < 3 should cover this
+    if (saved && (!(saved instanceof SavedContext) || line + saved.lookAhead < n)) {
+      start = line + 1
+      break
+    }
+  }
+  doc.highlightFrontier = Math.min(doc.highlightFrontier, start)
+}