administrate-field-simple_mde_markdown 0.1.0

data/node_modules/codemirror/src/display/update_lines.js

@@ -0,0 +1,64 @@
+import { heightAtLine } from "../line/spans.js"
+import { getLine, lineAtHeight, updateLineHeight } from "../line/utils_line.js"
+import { paddingTop, textHeight } 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], height
+    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
+    }
+    let diff = cur.line.height - height
+    if (height < 2) height = textHeight(display)
+    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])
+    }
+  }
+}
+
+// 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)}
+}

data/node_modules/codemirror/src/display/view_tracking.js

@@ -0,0 +1,153 @@
+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
+}

data/node_modules/codemirror/src/edit/CodeMirror.js

@@ -0,0 +1,215 @@
+import { Display } from "../display/Display.js"
+import { onFocus, onBlur } from "../display/focus.js"
+import { setGuttersForLineNumbers, updateGutters } from "../display/gutters.js"
+import { maybeUpdateLineNumberWidth } from "../display/line_numbers.js"
+import { endOperation, operation, startOperation } from "../display/operations.js"
+import { initScrollbars } from "../display/scrollbars.js"
+import { onScrollWheel } from "../display/scroll_events.js"
+import { setScrollLeft, updateScrollTop } from "../display/scrolling.js"
+import { clipPos, Pos } from "../line/pos.js"
+import { posFromMouse } from "../measurement/position_measurement.js"
+import { eventInWidget } from "../measurement/widgets.js"
+import Doc from "../model/Doc.js"
+import { attachDoc } from "../model/document_data.js"
+import { Range } from "../model/selection.js"
+import { extendSelection } from "../model/selection_updates.js"
+import { ie, ie_version, mobile, webkit } from "../util/browser.js"
+import { e_preventDefault, e_stop, on, signal, signalDOMEvent } from "../util/event.js"
+import { bind, copyObj, Delayed } from "../util/misc.js"
+
+import { clearDragCursor, onDragOver, onDragStart, onDrop } from "./drop_events.js"
+import { ensureGlobalHandlers } from "./global_events.js"
+import { onKeyDown, onKeyPress, onKeyUp } from "./key_events.js"
+import { clickInGutter, onContextMenu, onMouseDown } from "./mouse_events.js"
+import { themeChanged } from "./utils.js"
+import { defaults, optionHandlers, Init } from "./options.js"
+
+// A CodeMirror instance represents an editor. This is the object
+// that user code is usually dealing with.
+
+export function CodeMirror(place, options) {
+  if (!(this instanceof CodeMirror)) return new CodeMirror(place, options)
+
+  this.options = options = options ? copyObj(options) : {}
+  // Determine effective options based on given values and defaults.
+  copyObj(defaults, options, false)
+  setGuttersForLineNumbers(options)
+
+  let doc = options.value
+  if (typeof doc == "string") doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction)
+  else if (options.mode) doc.modeOption = options.mode
+  this.doc = doc
+
+  let input = new CodeMirror.inputStyles[options.inputStyle](this)
+  let display = this.display = new Display(place, doc, input)
+  display.wrapper.CodeMirror = this
+  updateGutters(this)
+  themeChanged(this)
+  if (options.lineWrapping)
+    this.display.wrapper.className += " CodeMirror-wrap"
+  initScrollbars(this)
+
+  this.state = {
+    keyMaps: [],  // stores maps added by addKeyMap
+    overlays: [], // highlighting overlays, as added by addOverlay
+    modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
+    overwrite: false,
+    delayingBlurEvent: false,
+    focused: false,
+    suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
+    pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll
+    selectingText: false,
+    draggingText: false,
+    highlight: new Delayed(), // stores highlight worker timeout
+    keySeq: null,  // Unfinished key sequence
+    specialChars: null
+  }
+
+  if (options.autofocus && !mobile) display.input.focus()
+
+  // Override magic textarea content restore that IE sometimes does
+  // on our hidden textarea on reload
+  if (ie && ie_version < 11) setTimeout(() => this.display.input.reset(true), 20)
+
+  registerEventHandlers(this)
+  ensureGlobalHandlers()
+
+  startOperation(this)
+  this.curOp.forceUpdate = true
+  attachDoc(this, doc)
+
+  if ((options.autofocus && !mobile) || this.hasFocus())
+    setTimeout(bind(onFocus, this), 20)
+  else
+    onBlur(this)
+
+  for (let opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))
+    optionHandlers[opt](this, options[opt], Init)
+  maybeUpdateLineNumberWidth(this)
+  if (options.finishInit) options.finishInit(this)
+  for (let i = 0; i < initHooks.length; ++i) initHooks[i](this)
+  endOperation(this)
+  // Suppress optimizelegibility in Webkit, since it breaks text
+  // measuring on line wrapping boundaries.
+  if (webkit && options.lineWrapping &&
+      getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
+    display.lineDiv.style.textRendering = "auto"
+}
+
+// The default configuration options.
+CodeMirror.defaults = defaults
+// Functions to run when options are changed.
+CodeMirror.optionHandlers = optionHandlers
+
+export default CodeMirror
+
+// Attach the necessary event handlers when initializing the editor
+function registerEventHandlers(cm) {
+  let d = cm.display
+  on(d.scroller, "mousedown", operation(cm, onMouseDown))
+  // Older IE's will not fire a second mousedown for a double click
+  if (ie && ie_version < 11)
+    on(d.scroller, "dblclick", operation(cm, e => {
+      if (signalDOMEvent(cm, e)) return
+      let pos = posFromMouse(cm, e)
+      if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return
+      e_preventDefault(e)
+      let word = cm.findWordAt(pos)
+      extendSelection(cm.doc, word.anchor, word.head)
+    }))
+  else
+    on(d.scroller, "dblclick", e => signalDOMEvent(cm, e) || e_preventDefault(e))
+  // Some browsers fire contextmenu *after* opening the menu, at
+  // which point we can't mess with it anymore. Context menu is
+  // handled in onMouseDown for these browsers.
+  on(d.scroller, "contextmenu", e => onContextMenu(cm, e))
+
+  // Used to suppress mouse event handling when a touch happens
+  let touchFinished, prevTouch = {end: 0}
+  function finishTouch() {
+    if (d.activeTouch) {
+      touchFinished = setTimeout(() => d.activeTouch = null, 1000)
+      prevTouch = d.activeTouch
+      prevTouch.end = +new Date
+    }
+  }
+  function isMouseLikeTouchEvent(e) {
+    if (e.touches.length != 1) return false
+    let touch = e.touches[0]
+    return touch.radiusX <= 1 && touch.radiusY <= 1
+  }
+  function farAway(touch, other) {
+    if (other.left == null) return true
+    let dx = other.left - touch.left, dy = other.top - touch.top
+    return dx * dx + dy * dy > 20 * 20
+  }
+  on(d.scroller, "touchstart", e => {
+    if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) {
+      d.input.ensurePolled()
+      clearTimeout(touchFinished)
+      let now = +new Date
+      d.activeTouch = {start: now, moved: false,
+                       prev: now - prevTouch.end <= 300 ? prevTouch : null}
+      if (e.touches.length == 1) {
+        d.activeTouch.left = e.touches[0].pageX
+        d.activeTouch.top = e.touches[0].pageY
+      }
+    }
+  })
+  on(d.scroller, "touchmove", () => {
+    if (d.activeTouch) d.activeTouch.moved = true
+  })
+  on(d.scroller, "touchend", e => {
+    let touch = d.activeTouch
+    if (touch && !eventInWidget(d, e) && touch.left != null &&
+        !touch.moved && new Date - touch.start < 300) {
+      let pos = cm.coordsChar(d.activeTouch, "page"), range
+      if (!touch.prev || farAway(touch, touch.prev)) // Single tap
+        range = new Range(pos, pos)
+      else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
+        range = cm.findWordAt(pos)
+      else // Triple tap
+        range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)))
+      cm.setSelection(range.anchor, range.head)
+      cm.focus()
+      e_preventDefault(e)
+    }
+    finishTouch()
+  })
+  on(d.scroller, "touchcancel", finishTouch)
+
+  // Sync scrolling between fake scrollbars and real scrollable
+  // area, ensure viewport is updated when scrolling.
+  on(d.scroller, "scroll", () => {
+    if (d.scroller.clientHeight) {
+      updateScrollTop(cm, d.scroller.scrollTop)
+      setScrollLeft(cm, d.scroller.scrollLeft, true)
+      signal(cm, "scroll", cm)
+    }
+  })
+
+  // Listen to wheel events in order to try and update the viewport on time.
+  on(d.scroller, "mousewheel", e => onScrollWheel(cm, e))
+  on(d.scroller, "DOMMouseScroll", e => onScrollWheel(cm, e))
+
+  // Prevent wrapper from ever scrolling
+  on(d.wrapper, "scroll", () => d.wrapper.scrollTop = d.wrapper.scrollLeft = 0)
+
+  d.dragFunctions = {
+    enter: e => {if (!signalDOMEvent(cm, e)) e_stop(e)},
+    over: e => {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},
+    start: e => onDragStart(cm, e),
+    drop: operation(cm, onDrop),
+    leave: e => {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}
+  }
+
+  let inp = d.input.getField()
+  on(inp, "keyup", e => onKeyUp.call(cm, e))
+  on(inp, "keydown", operation(cm, onKeyDown))
+  on(inp, "keypress", operation(cm, onKeyPress))
+  on(inp, "focus", e => onFocus(cm, e))
+  on(inp, "blur", e => onBlur(cm, e))
+}
+
+let initHooks = []
+CodeMirror.defineInitHook = f => initHooks.push(f)

data/node_modules/codemirror/src/edit/commands.js

@@ -0,0 +1,178 @@
+import { deleteNearSelection } from "./deleteNearSelection.js"
+import { runInOp } from "../display/operations.js"
+import { ensureCursorVisible } from "../display/scrolling.js"
+import { endOfLine } from "../input/movement.js"
+import { clipPos, Pos } from "../line/pos.js"
+import { visualLine, visualLineEnd } from "../line/spans.js"
+import { getLine, lineNo } from "../line/utils_line.js"
+import { Range } from "../model/selection.js"
+import { selectAll } from "../model/selection_updates.js"
+import { countColumn, sel_dontScroll, sel_move, spaceStr } from "../util/misc.js"
+import { getOrder } from "../util/bidi.js"
+
+// Commands are parameter-less actions that can be performed on an
+// editor, mostly used for keybindings.
+export let commands = {
+  selectAll: selectAll,
+  singleSelection: cm => cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll),
+  killLine: cm => deleteNearSelection(cm, range => {
+    if (range.empty()) {
+      let len = getLine(cm.doc, range.head.line).text.length
+      if (range.head.ch == len && range.head.line < cm.lastLine())
+        return {from: range.head, to: Pos(range.head.line + 1, 0)}
+      else
+        return {from: range.head, to: Pos(range.head.line, len)}
+    } else {
+      return {from: range.from(), to: range.to()}
+    }
+  }),
+  deleteLine: cm => deleteNearSelection(cm, range => ({
+    from: Pos(range.from().line, 0),
+    to: clipPos(cm.doc, Pos(range.to().line + 1, 0))
+  })),
+  delLineLeft: cm => deleteNearSelection(cm, range => ({
+    from: Pos(range.from().line, 0), to: range.from()
+  })),
+  delWrappedLineLeft: cm => deleteNearSelection(cm, range => {
+    let top = cm.charCoords(range.head, "div").top + 5
+    let leftPos = cm.coordsChar({left: 0, top: top}, "div")
+    return {from: leftPos, to: range.from()}
+  }),
+  delWrappedLineRight: cm => deleteNearSelection(cm, range => {
+    let top = cm.charCoords(range.head, "div").top + 5
+    let rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
+    return {from: range.from(), to: rightPos }
+  }),
+  undo: cm => cm.undo(),
+  redo: cm => cm.redo(),
+  undoSelection: cm => cm.undoSelection(),
+  redoSelection: cm => cm.redoSelection(),
+  goDocStart: cm => cm.extendSelection(Pos(cm.firstLine(), 0)),
+  goDocEnd: cm => cm.extendSelection(Pos(cm.lastLine())),
+  goLineStart: cm => cm.extendSelectionsBy(range => lineStart(cm, range.head.line),
+    {origin: "+move", bias: 1}
+  ),
+  goLineStartSmart: cm => cm.extendSelectionsBy(range => lineStartSmart(cm, range.head),
+    {origin: "+move", bias: 1}
+  ),
+  goLineEnd: cm => cm.extendSelectionsBy(range => lineEnd(cm, range.head.line),
+    {origin: "+move", bias: -1}
+  ),
+  goLineRight: cm => cm.extendSelectionsBy(range => {
+    let top = cm.cursorCoords(range.head, "div").top + 5
+    return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
+  }, sel_move),
+  goLineLeft: cm => cm.extendSelectionsBy(range => {
+    let top = cm.cursorCoords(range.head, "div").top + 5
+    return cm.coordsChar({left: 0, top: top}, "div")
+  }, sel_move),
+  goLineLeftSmart: cm => cm.extendSelectionsBy(range => {
+    let top = cm.cursorCoords(range.head, "div").top + 5
+    let pos = cm.coordsChar({left: 0, top: top}, "div")
+    if (pos.ch < cm.getLine(pos.line).search(/\S/)) return lineStartSmart(cm, range.head)
+    return pos
+  }, sel_move),
+  goLineUp: cm => cm.moveV(-1, "line"),
+  goLineDown: cm => cm.moveV(1, "line"),
+  goPageUp: cm => cm.moveV(-1, "page"),
+  goPageDown: cm => cm.moveV(1, "page"),
+  goCharLeft: cm => cm.moveH(-1, "char"),
+  goCharRight: cm => cm.moveH(1, "char"),
+  goColumnLeft: cm => cm.moveH(-1, "column"),
+  goColumnRight: cm => cm.moveH(1, "column"),
+  goWordLeft: cm => cm.moveH(-1, "word"),
+  goGroupRight: cm => cm.moveH(1, "group"),
+  goGroupLeft: cm => cm.moveH(-1, "group"),
+  goWordRight: cm => cm.moveH(1, "word"),
+  delCharBefore: cm => cm.deleteH(-1, "char"),
+  delCharAfter: cm => cm.deleteH(1, "char"),
+  delWordBefore: cm => cm.deleteH(-1, "word"),
+  delWordAfter: cm => cm.deleteH(1, "word"),
+  delGroupBefore: cm => cm.deleteH(-1, "group"),
+  delGroupAfter: cm => cm.deleteH(1, "group"),
+  indentAuto: cm => cm.indentSelection("smart"),
+  indentMore: cm => cm.indentSelection("add"),
+  indentLess: cm => cm.indentSelection("subtract"),
+  insertTab: cm => cm.replaceSelection("\t"),
+  insertSoftTab: cm => {
+    let spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize
+    for (let i = 0; i < ranges.length; i++) {
+      let pos = ranges[i].from()
+      let col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)
+      spaces.push(spaceStr(tabSize - col % tabSize))
+    }
+    cm.replaceSelections(spaces)
+  },
+  defaultTab: cm => {
+    if (cm.somethingSelected()) cm.indentSelection("add")
+    else cm.execCommand("insertTab")
+  },
+  // Swap the two chars left and right of each selection's head.
+  // Move cursor behind the two swapped characters afterwards.
+  //
+  // Doesn't consider line feeds a character.
+  // Doesn't scan more than one line above to find a character.
+  // Doesn't do anything on an empty line.
+  // Doesn't do anything with non-empty selections.
+  transposeChars: cm => runInOp(cm, () => {
+    let ranges = cm.listSelections(), newSel = []
+    for (let i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) continue
+      let cur = ranges[i].head, line = getLine(cm.doc, cur.line).text
+      if (line) {
+        if (cur.ch == line.length) cur = new Pos(cur.line, cur.ch - 1)
+        if (cur.ch > 0) {
+          cur = new Pos(cur.line, cur.ch + 1)
+          cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
+                          Pos(cur.line, cur.ch - 2), cur, "+transpose")
+        } else if (cur.line > cm.doc.first) {
+          let prev = getLine(cm.doc, cur.line - 1).text
+          if (prev) {
+            cur = new Pos(cur.line, 1)
+            cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
+                            prev.charAt(prev.length - 1),
+                            Pos(cur.line - 1, prev.length - 1), cur, "+transpose")
+          }
+        }
+      }
+      newSel.push(new Range(cur, cur))
+    }
+    cm.setSelections(newSel)
+  }),
+  newlineAndIndent: cm => runInOp(cm, () => {
+    let sels = cm.listSelections()
+    for (let i = sels.length - 1; i >= 0; i--)
+      cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input")
+    sels = cm.listSelections()
+    for (let i = 0; i < sels.length; i++)
+      cm.indentLine(sels[i].from().line, null, true)
+    ensureCursorVisible(cm)
+  }),
+  openLine: cm => cm.replaceSelection("\n", "start"),
+  toggleOverwrite: cm => cm.toggleOverwrite()
+}
+
+
+function lineStart(cm, lineN) {
+  let line = getLine(cm.doc, lineN)
+  let visual = visualLine(line)
+  if (visual != line) lineN = lineNo(visual)
+  return endOfLine(true, cm, visual, lineN, 1)
+}
+function lineEnd(cm, lineN) {
+  let line = getLine(cm.doc, lineN)
+  let visual = visualLineEnd(line)
+  if (visual != line) lineN = lineNo(visual)
+  return endOfLine(true, cm, line, lineN, -1)
+}
+function lineStartSmart(cm, pos) {
+  let start = lineStart(cm, pos.line)
+  let line = getLine(cm.doc, start.line)
+  let order = getOrder(line, cm.doc.direction)
+  if (!order || order[0].level == 0) {
+    let firstNonWS = Math.max(0, line.text.search(/\S/))
+    let inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch
+    return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky)
+  }
+  return start
+}