@muze-nl/simplystore 0.3.6 → 0.4.1

package/www/codemirror/src/model/selection_updates.js

@@ -1,216 +0,0 @@
-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 && doc.cm.getOption("readOnly") != "nocursor")
-    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 = range.head == range.anchor ? newAnchor : 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)
-}

package/www/codemirror/src/modes.js

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

package/www/codemirror/src/util/StringStream.js

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

package/www/codemirror/src/util/bidi.js

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

package/www/codemirror/src/util/browser.js

@@ -1,34 +0,0 @@
-// 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\/(\d+)/.exec(userAgent)
-export let chrome_version = chrome && +chrome[1]
-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 = safari && (/Mobile\/\w+/.test(userAgent) || navigator.maxTouchPoints > 2)
-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)