kitodo / kitodo-publication

  if (typeof exports == "object" && typeof module == "object") // CommonJS

    return define([], mod);

  else // Plain browser env

})(function() {

  "use strict";

  // BROWSER SNIFFING

  // Kludges for bugs and behavior differences that can't be feature

  // detected are enabled based on userAgent etc sniffing.

  var ie_upto10 = /MSIE \d/.test(navigator.userAgent);

  var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);

  var ie = ie_upto10 || ie_11up;

  var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1]);

  var webkit = /WebKit\//.test(navigator.userAgent);

  var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(navigator.userAgent);

  var chrome = /Chrome\//.test(navigator.userAgent);

  var presto = /Opera\//.test(navigator.userAgent);

  var safari = /Apple Computer/.test(navigator.vendor);

  var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(navigator.userAgent);

  var phantom = /PhantomJS/.test(navigator.userAgent);

  var ios = /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent);

  // This is woefully incomplete. Suggestions for alternative methods welcome.

  var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(navigator.userAgent);

  var mac = ios || /Mac/.test(navigator.platform);

  var windows = /win/i.test(navigator.platform);

  var presto_version = presto && navigator.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

  var captureRightClick = gecko || (ie && ie_version >= 9);

  // Optimize some code when these features are not used.

  var sawReadOnlySpans = false, sawCollapsedSpans = false;

  // EDITOR CONSTRUCTOR

  // A CodeMirror instance represents an editor. This is the object

  // that user code is usually dealing with.

  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);

    var doc = options.value;

    if (typeof doc == "string") doc = new Doc(doc, options.mode);

    this.doc = doc;

    var input = new CodeMirror.inputStyles[options.inputStyle](this);

    var 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";

    if (options.autofocus && !mobile) display.input.focus();

    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, 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

      draggingText: false,

      highlight: new Delayed(), // stores highlight worker timeout

      keySeq: null  // Unfinished key sequence

    };

    var cm = this;

    // Override magic textarea content restore that IE sometimes does

    // on our hidden textarea on reload

    if (ie && ie_version < 11) setTimeout(function() { cm.display.input.reset(true); }, 20);

    registerEventHandlers(this);

    ensureGlobalHandlers();

    startOperation(this);

    this.curOp.forceUpdate = true;

    attachDoc(this, doc);

    if ((options.autofocus && !mobile) || cm.hasFocus())

      setTimeout(bind(onFocus, this), 20);

    else

      onBlur(this);

    for (var opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))

      optionHandlers[opt](this, options[opt], Init);

    maybeUpdateLineNumberWidth(this);

    if (options.finishInit) options.finishInit(this);

    for (var i = 0; i < initHooks.length; ++i) initHooks[i](this);

    endOperation(this);

    // Suppress optimizelegibility in Webkit, since it breaks text

    // measuring on line wrapping boundaries.

        getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")

  }

  // DISPLAY CONSTRUCTOR

  // The display handles the DOM integration, both for input reading

  // and content drawing. It holds references to DOM nodes and

  // display-related state.

  function Display(place, doc, input) {

    var 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 = elt("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 = elt("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],

                      null, "position: relative; outline: none");

    // Moved around its parent to cover visible view.

    d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-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;

    input.init(d);

  }

  // STATE UPDATES

  // Used to get the editor into a consistent state again when options change.

  function loadMode(cm) {

    cm.doc.mode = CodeMirror.getMode(cm.options, cm.doc.modeOption);

    resetModeState(cm);

  }

  function resetModeState(cm) {

    cm.doc.iter(function(line) {

      if (line.stateAfter) line.stateAfter = null;

      if (line.styles) line.styles = null;

    });

    cm.doc.frontier = cm.doc.first;

    startWorker(cm, 100);

    cm.state.modeGen++;

    if (cm.curOp) regChange(cm);

  }

  function wrappingChanged(cm) {

    if (cm.options.lineWrapping) {

      addClass(cm.display.wrapper, "CodeMirror-wrap");

      cm.display.sizer.style.minWidth = "";

      cm.display.sizerWidth = null;

    } else {

      rmClass(cm.display.wrapper, "CodeMirror-wrap");

      findMaxLine(cm);

    }

    estimateLineHeights(cm);

    regChange(cm);

    clearCaches(cm);

    setTimeout(function(){updateScrollbars(cm);}, 100);

  }

  // Returns a function that estimates the height of a line, to use as

  // first approximation until the line becomes visible (and is thus

  // properly measurable).

  function estimateHeight(cm) {

    var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;

    var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);

    return function(line) {

      if (lineIsHidden(cm.doc, line)) return 0;

      var widgetsHeight = 0;

      if (line.widgets) for (var i = 0; i < line.widgets.length; i++) {

        if (line.widgets[i].height) widgetsHeight += line.widgets[i].height;

      }

      if (wrapping)

        return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th;

      else

    };

  }

  function estimateLineHeights(cm) {

    var doc = cm.doc, est = estimateHeight(cm);

    doc.iter(function(line) {

      var estHeight = est(line);

      if (estHeight != line.height) updateLineHeight(line, estHeight);

    });

  }

  function themeChanged(cm) {

    cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +

      cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");

    clearCaches(cm);

  }

  function guttersChanged(cm) {

    updateGutters(cm);

    regChange(cm);

    setTimeout(function(){alignHorizontally(cm);}, 20);

  }

  // Rebuild the gutter elements, ensure the margin to the left of the

  // code matches their width.

  function updateGutters(cm) {

    var gutters = cm.display.gutters, specs = cm.options.gutters;

    removeChildren(gutters);

    for (var i = 0; i < specs.length; ++i) {

      var gutterClass = specs[i];

      var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass));

      if (gutterClass == "CodeMirror-linenumbers") {

        cm.display.lineGutter = gElt;

        gElt.style.width = (cm.display.lineNumWidth || 1) + "px";

      }

    }

    gutters.style.display = i ? "" : "none";

    updateGutterSpace(cm);

  }

  function updateGutterSpace(cm) {

    var width = cm.display.gutters.offsetWidth;

    cm.display.sizer.style.marginLeft = width + "px";

  }

  // Compute the character length of a line, taking into account

  // collapsed ranges (see markText) that might hide parts, and join

  // other lines onto it.

  function lineLength(line) {

    var len = line.text.length, merged, cur = line;

    while (merged = collapsedSpanAtStart(cur)) {

      var found = merged.find(0, true);

      cur = found.from.line;

      len += found.from.ch - found.to.ch;

    }

    cur = line;

    while (merged = collapsedSpanAtEnd(cur)) {

      len -= cur.text.length - found.from.ch;

      cur = found.to.line;

      len += cur.text.length - found.to.ch;

    }

    return len;

  }

  // Find the longest line in the document.

  function findMaxLine(cm) {

    var d = cm.display, doc = cm.doc;

    d.maxLine = getLine(doc, doc.first);

    d.maxLineLength = lineLength(d.maxLine);

    d.maxLineChanged = true;

    doc.iter(function(line) {

      var len = lineLength(line);

      if (len > d.maxLineLength) {

        d.maxLineLength = len;

        d.maxLine = line;

      }

    });

  }

  // Make sure the gutters options contains the element

  // "CodeMirror-linenumbers" when the lineNumbers option is true.

  function setGuttersForLineNumbers(options) {

    var found = indexOf(options.gutters, "CodeMirror-linenumbers");

    if (found == -1 && options.lineNumbers) {

      options.gutters = options.gutters.concat(["CodeMirror-linenumbers"]);

    } else if (found > -1 && !options.lineNumbers) {

      options.gutters = options.gutters.slice(0);

      options.gutters.splice(found, 1);

    }

  }

  // SCROLLBARS

  // Prepare DOM reads needed to update the scrollbars. Done in one

  // shot to minimize update/measure roundtrips.

  function measureForScrollbars(cm) {

    var d = cm.display, gutterW = d.gutters.offsetWidth;

    var 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

    };

  }

  function NativeScrollbars(place, scroll, cm) {

    this.cm = cm;

    var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar");

    var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar");

    place(vert); place(horiz);

    on(vert, "scroll", function() {

      if (vert.clientHeight) scroll(vert.scrollTop, "vertical");

    });

    on(horiz, "scroll", function() {

      if (horiz.clientWidth) scroll(horiz.scrollLeft, "horizontal");

    });

    this.checkedOverlay = 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";

  }

  NativeScrollbars.prototype = copyObj({

    update: function(measure) {

      var needsH = measure.scrollWidth > measure.clientWidth + 1;

      var needsV = measure.scrollHeight > measure.clientHeight + 1;

      var sWidth = measure.nativeBarWidth;

      if (needsV) {

        this.vert.style.display = "block";

        this.vert.style.bottom = needsH ? sWidth + "px" : "0";

        var 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";

        var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);

        this.horiz.firstChild.style.width =

          (measure.scrollWidth - measure.clientWidth + totalWidth) + "px";

      } else {

        this.horiz.style.display = "";

        this.horiz.firstChild.style.width = "0";

      }

      if (!this.checkedOverlay && measure.clientHeight > 0) {

        this.checkedOverlay = true;

      }

      return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0};

    },

    setScrollLeft: function(pos) {

      if (this.horiz.scrollLeft != pos) this.horiz.scrollLeft = pos;

    },

    setScrollTop: function(pos) {

      if (this.vert.scrollTop != pos) this.vert.scrollTop = pos;

    },

    overlayHack: function() {

      var w = mac && !mac_geMountainLion ? "12px" : "18px";

      this.horiz.style.minHeight = this.vert.style.minWidth = w;

      var self = this;

      var barMouseDown = function(e) {

        if (e_target(e) != self.vert && e_target(e) != self.horiz)

          operation(self.cm, onMouseDown)(e);

      };

      on(this.vert, "mousedown", barMouseDown);

      on(this.horiz, "mousedown", barMouseDown);

    },

    clear: function() {

      var parent = this.horiz.parentNode;

      parent.removeChild(this.horiz);

      parent.removeChild(this.vert);

    }

  }, NativeScrollbars.prototype);

  function NullScrollbars() {}

  NullScrollbars.prototype = copyObj({

    update: function() { return {bottom: 0, right: 0}; },

    setScrollLeft: function() {},

    setScrollTop: function() {},

    clear: function() {}

  }, NullScrollbars.prototype);

  CodeMirror.scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars};

  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 CodeMirror.scrollbarModel[cm.options.scrollbarStyle](function(node) {

      cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller);

      // Prevent clicks in the scrollbars from killing focus

      on(node, "mousedown", function() {

        if (cm.state.focused) setTimeout(function() { cm.display.input.focus(); }, 0);

      });

      node.setAttribute("cm-not-content", "true");

    }, function(pos, axis) {

      if (axis == "horizontal") setScrollLeft(cm, pos);

      else setScrollTop(cm, pos);

    }, cm);

    if (cm.display.scrollbars.addClass)

      addClass(cm.display.wrapper, cm.display.scrollbars.addClass);

  }

  function updateScrollbars(cm, measure) {

    if (!measure) measure = measureForScrollbars(cm);

    var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight;

    updateScrollbarsInner(cm, measure);

    for (var 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) {

    var d = cm.display;

    var sizes = d.scrollbars.update(measure);

    d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px";

    d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px";

    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 = "";

  }

  // 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.

  function visibleLines(display, doc, viewport) {

    top = Math.floor(top - paddingTop(display));

    var 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) {

      var 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)};

  }

  // LINE NUMBERS

  // Re-align line numbers and gutter marks to compensate for

  // horizontal scrolling.

  function alignHorizontally(cm) {

    var display = cm.display, view = display.view;

    if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return;

    var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;

    var gutterW = display.gutters.offsetWidth, left = comp + "px";

    for (var i = 0; i < view.length; i++) if (!view[i].hidden) {

      if (cm.options.fixedGutter && view[i].gutter)

        view[i].gutter.style.left = left;

      var align = view[i].alignable;

      if (align) for (var 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.

  function maybeUpdateLineNumberWidth(cm) {

    if (!cm.options.lineNumbers) return false;

    var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display;

    if (last.length != display.lineNumChars) {

      var test = display.measure.appendChild(elt("div", [elt("div", last)],

                                                 "CodeMirror-linenumber CodeMirror-gutter-elt"));

      var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;

      display.lineGutter.style.width = "";

      display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding);

      display.lineNumWidth = display.lineNumInnerWidth + padding;

      display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;

      display.lineGutter.style.width = display.lineNumWidth + "px";

      updateGutterSpace(cm);

      return true;

    }

    return false;

  }

  function lineNumberFor(options, i) {

    return String(options.lineNumberFormatter(i + options.firstLineNumber));

  }

  // Computes display.scroller.scrollLeft + display.gutters.offsetWidth,

  // but using getBoundingClientRect to get a sub-pixel-accurate

  // result.

  function compensateForHScroll(display) {

    return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left;

  }

  // DISPLAY DRAWING