Automatic rewrite of array to .mq-array

Remaining instances of array:
classes.txt:array
src/commands/math.js:    // .blocks array of child blocks.
src/commands/math/commands.js:    +     '<span class="array non-leaf">'
test/support/jquery-1.7.2.js:				// HANDLE: $(html) -> $(array)
test/support/jquery-1.7.2.js:	// Get the whole matched element set as a clean array
test/support/jquery-1.7.2.js:			// Return a 'clean' array
test/support/jquery-1.7.2.js:	// Take an array of elements and push it onto the stack
test/support/jquery-1.7.2.js:	// (You can seed the arguments with an array of args, but this is
test/support/jquery-1.7.2.js:	makeArray: function( array, results ) {
test/support/jquery-1.7.2.js:		if ( array != null ) {
test/support/jquery-1.7.2.js:			var type = jQuery.type( array );
test/support/jquery-1.7.2.js:			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
test/support/jquery-1.7.2.js:				push.call( ret, array );
test/support/jquery-1.7.2.js:				jQuery.merge( ret, array );
test/support/jquery-1.7.2.js:	inArray: function( elem, array, i ) {
test/support/jquery-1.7.2.js:		if ( array ) {
test/support/jquery-1.7.2.js:				return indexOf.call( array, elem, i );
test/support/jquery-1.7.2.js:			len = array.length;
test/support/jquery-1.7.2.js:				if ( i in array && array[ i ] === elem ) {
test/support/jquery-1.7.2.js:		// Go through the array, only saving the items
test/support/jquery-1.7.2.js:		// Go through the array, translating each of the items to their
test/support/jquery-1.7.2.js:				// Support array or space separated string names for data keys
test/support/jquery-1.7.2.js:						// We don't need an array for one selects
test/support/jquery-1.7.2.js:						// Multi-Selects return an array
test/support/jquery-1.7.2.js: * Utility function for retreiving the text value of an array of DOM nodes
test/support/jquery-1.7.2.js:		// If no nodeType, this is expected to be an array
test/support/jquery-1.7.2.js:		last: function( elem, i, match, array ) {
test/support/jquery-1.7.2.js:			return i === array.length - 1;
test/support/jquery-1.7.2.js:		PSEUDO: function( elem, match, i, array ) {
test/support/jquery-1.7.2.js:				return filter( elem, i, match, array );
test/support/jquery-1.7.2.js:		POS: function( elem, match, i, array ) {
test/support/jquery-1.7.2.js:				return filter( elem, i, match, array );
test/support/jquery-1.7.2.js:var makeArray = function( array, results ) {
test/support/jquery-1.7.2.js:	array = Array.prototype.slice.call( array, 0 );
test/support/jquery-1.7.2.js:		results.push.apply( results, array );
test/support/jquery-1.7.2.js:	return array;
test/support/jquery-1.7.2.js:// converting a NodeList to an array using builtin methods.
test/support/jquery-1.7.2.js:// Also verifies that the returned array holds DOM nodes
test/support/jquery-1.7.2.js:	makeArray = function( array, results ) {
test/support/jquery-1.7.2.js:		if ( toString.call(array) === "[object Array]" ) {
test/support/jquery-1.7.2.js:			Array.prototype.push.apply( ret, array );
test/support/jquery-1.7.2.js:			if ( typeof array.length === "number" ) {
test/support/jquery-1.7.2.js:				for ( var l = array.length; i < l; i++ ) {
test/support/jquery-1.7.2.js:					ret.push( array[i] );
test/support/jquery-1.7.2.js:				for ( ; array[i]; i++ ) {
test/support/jquery-1.7.2.js:					ret.push( array[i] );
test/support/jquery-1.7.2.js:	// Serialize an array of form elements or a set of
test/support/jquery-1.7.2.js:		// If an array was passed in, assume that it is an array of form elements.
test/support/jquery-1.7.2.js:		// Serialize array item.
test/support/jquery-1.7.2.js:				// Treat each array item as a scalar.
test/support/jquery-1.7.2.js:				// If array item is non-scalar (array or object), encode its
test/support/jquery-1.7.2.js:				// to force array serialization to be shallow.
Automatic rewrite of binary-operator to .mq-binary-operator

Remaining instances of binary-operator:
classes.txt:binary-operator
src/commands/math/symbols.js:      ctrlSeq, '<span class="binary-operator">'+html+'</span>', text
test/unit/publicapi.test.js:      assert.equal(mq.html(), '<var>x</var><span class="binary-operator">+</span><var>y</var>');
Automatic rewrite of blink to .mq-blink

Remaining instances of blink:
classes.txt:blink
src/css/editable.less:    &.blink { visibility: hidden; }
src/cursor.js:    this.intervalId = setInterval(this.blink, 500);
src/publicapi.js:      .replace(/<span class="?cursor( blink)?"?>.?<\/span>/i, '')
src/services/mouse.js:      var ctrlr = root.controller, cursor = ctrlr.cursor, blink = cursor.blink;
src/services/mouse.js:        cursor.blink = blink;
src/services/mouse.js:      cursor.blink = noop;
Automatic rewrite of blur to .mq-blur

Remaining instances of blur:
classes.txt:blur
src/commands/math.js:    // empty elements need the empty box provided by blur to
src/commands/math.js:  _.blur = function() {
src/commands/math/commands.js:    this.ends[L].blur = function() {
src/commands/text.js:  _.blur = function() {
src/commands/text.js:    MathBlock.prototype.blur.call(this);
src/cursor.js:    if (parent !== this.parent && this.parent.blur) this.parent.blur();
src/publicapi.js:      if (this.controller.blurred) this.controller.cursor.hide().parent.blur();
src/publicapi.js:  _.blur = function() { this.controller.textarea.blur(); return this; };
src/publicapi.js:    if (this.controller.blurred) this.controller.cursor.hide().parent.blur();
src/publicapi.js:    if (ctrlr.blurred) cursor.hide().parent.blur();
src/publicapi.js:      if (this.controller.blurred) this.controller.cursor.hide().parent.blur();
src/services/focusBlur.js:    }).blur(function() {
src/services/focusBlur.js:      blurTimeout = setTimeout(function() { // wait for blur on window; if
src/services/focusBlur.js:        root.postOrder('intentionalBlur'); // none, intentional blur: #264
src/services/focusBlur.js:        blur();
src/services/focusBlur.js:    function windowBlur() { // blur event also fired on window, just switching
src/services/focusBlur.js:      clearTimeout(blurTimeout); // tabs/windows, not intentional blur
src/services/focusBlur.js:      blur();
src/services/focusBlur.js:    function blur() { // not directly in the textarea blur handler so as to be
src/services/focusBlur.js:      cursor.hide().parent.blur(); // synchronous with/in the same frame as
src/services/focusBlur.js: * TODO: I wanted to move MathBlock::focus and blur here, it would clean
src/services/focusBlur.js: * and TextBlock::blur calls MathBlock::blur, when instead they could
src/services/focusBlur.js: * Problem is, there's lots of calls to .focus()/.blur() on nodes
src/services/focusBlur.js: * outside Controller::focusBlurEvents(), such as .postOrder('blur') on
src/services/focusBlur.js: * insertion, which if MathBlock::blur becomes Node::blur, would add the
src/services/focusBlur.js: * 'blur' CSS class to all Symbol's (because .isEmpty() is true for all
src/services/focusBlur.js: * .blur(), so this is TODO for now.
src/services/textarea.js:    .focus(function() { ctrlr.blurred = false; }).blur(function() {
src/services/textarea.js:      setTimeout(detach); //detaching during blur explodes in WebKit
test/support/jquery-1.7.2.js:		// focus/blur morphs to focusin/out; ensure we're not firing them right now
test/support/jquery-1.7.2.js:				// IE<9 dies on focus/blur to hidden element (#1486)
test/support/jquery-1.7.2.js:		blur: {
test/support/jquery-1.7.2.js:				// IE doesn't fire change on a check/radio until blur; trigger it on click
test/support/jquery-1.7.2.js:				// after a propertychange. Eat the blur-change in special.change.handle.
test/support/jquery-1.7.2.js:				// This still fires onchange a second time for check/radio after blur.
test/support/jquery-1.7.2.js:// Create "bubbling" focus and blur events
test/support/jquery-1.7.2.js:	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
test/support/jquery-1.7.2.js:jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
Automatic rewrite of cursor to .mq-cursor

Remaining instances of cursor:
Makefile:  $(SRC_DIR)/cursor.js \
README.md:* `.write(' - 1')` will write some LaTeX at the current cursor position
README.md:* `.cmd('\\sqrt')` will enter a LaTeX command at the current cursor position or
README.md:* `.moveTo{Left,Right,Dir}End()` move the cursor to the left/right end of the
README.md:  Space if `spaceBehavesLikeTab` is true) to move the cursor out of the exponent
README.md:  chars when there's nothing to the left of the cursor (Desmos, for example,
README.md:By default, the Left and Right keys move the cursor through all possible cursor
README.md:positions in a particular order: right into a fraction puts the cursor at the
README.md:left end of the numerator, right out of the numerator puts the cursor at the
README.md:left end of the denominator, right out of the denominator puts the cursor to the
README.md:right of the fraction; symmetrically, left into a fraction puts the cursor at
README.md:cursor to the right of the fraction, which unlike the default behavior is
README.md:Shift-Left/Shift-Right is pressed but the cursor is at the left/right/top/bottom
README.md:edge and so nothing happens within the math field. For example, when the cursor
README.md:the `border-color`, because the cursor, fraction bar, and square root
README.md:- tree- and cursor-manipulation methods, at the lowest level, to move the
README.md:  cursor or edit the tree or whatever.
README.md:    + `cursor.js` defines objects representing the cursor and a selection of
README.md:  moving the cursor around, LaTeX exporting, LaTeX parsing. Note that each of
README.md:  these varies by command (the cursor goes in a different place when moving into
README.md:  Left key is pressed, calls `.moveTowards` on the node just left of the cursor,
README.md:  `SquareRoot::moveTowards` can insert the cursor in different places).
classes.txt:cursor
src/commands/math.js:  _.finalizeInsert = function(cursor) {
src/commands/math.js:    self.postOrder('contactWeld', cursor);
src/commands/math.js:  // createLeftOf(cursor) and the methods it calls
src/commands/math.js:  _.createLeftOf = function(cursor) {
src/commands/math.js:    _super.createLeftOf.call(cmd, cursor);
src/commands/math.js:    cmd.placeCursor(cursor);
src/commands/math.js:  _.placeCursor = function(cursor) {
src/commands/math.js:    //insert the cursor at the right end of the first empty child, searching
src/commands/math.js:    cursor.insAtRightEnd(this.foldChildren(this.ends[L], function(leftward, child) {
src/commands/math.js:  // editability methods: called by the cursor for editing, cursor movements,
src/commands/math.js:  // the cursor
src/commands/math.js:  _.moveTowards = function(dir, cursor, updown) {
src/commands/math.js:    cursor.insAtDirEnd(-dir, updownInto || this.ends[-dir]);
src/commands/math.js:  _.deleteTowards = function(dir, cursor) {
src/commands/math.js:    cursor.startSelection();
src/commands/math.js:    this.selectTowards(dir, cursor);
src/commands/math.js:    cursor.select();
src/commands/math.js:  _.selectTowards = function(dir, cursor) {
src/commands/math.js:    cursor[-dir] = this;
src/commands/math.js:    cursor[dir] = this[dir];
src/commands/math.js:  _.unselectInto = function(dir, cursor) {
src/commands/math.js:    cursor.insAtDirEnd(-dir, cursor.anticursor.ancestors[this.id]);
src/commands/math.js:  _.seek = function(pageX, cursor) {
src/commands/math.js:    if (pageX < cmdBounds[L]) return cursor.insLeftOf(cmd);
src/commands/math.js:    if (pageX > cmdBounds[R]) return cursor.insRightOf(cmd);
src/commands/math.js:          if (block[L]) cursor.insAtRightEnd(block[L]);
src/commands/math.js:          else cursor.insLeftOf(cmd);
src/commands/math.js:        else cursor.insAtLeftEnd(block);
src/commands/math.js:            cursor.insRightOf(cmd);
src/commands/math.js:          else cursor.insAtRightEnd(block);
src/commands/math.js:        block.seek(pageX, cursor);
src/commands/math.js:  _.moveTowards = function(dir, cursor) {
src/commands/math.js:    cursor.jQ.insDirOf(dir, this.jQ);
src/commands/math.js:    cursor[-dir] = this;
src/commands/math.js:    cursor[dir] = this[dir];
src/commands/math.js:  _.deleteTowards = function(dir, cursor) {
src/commands/math.js:    cursor[dir] = this.remove()[dir];
src/commands/math.js:  _.seek = function(pageX, cursor) {
src/commands/math.js:      cursor.insLeftOf(this);
src/commands/math.js:      cursor.insRightOf(this);
src/commands/math.js:  // editability methods: called by the cursor for editing, cursor movements,
src/commands/math.js:  // the cursor
src/commands/math.js:  _.moveOutOf = function(dir, cursor, updown) {
src/commands/math.js:    if (!updownInto && this[dir]) cursor.insAtDirEnd(-dir, this[dir]);
src/commands/math.js:    else cursor.insDirOf(dir, this.parent);
src/commands/math.js:  _.selectOutOf = function(dir, cursor) {
src/commands/math.js:    cursor.insDirOf(dir, this.parent);
src/commands/math.js:  _.deleteOutOf = function(dir, cursor) {
src/commands/math.js:    cursor.unwrapGramp();
src/commands/math.js:  _.seek = function(pageX, cursor) {
src/commands/math.js:      return cursor.insAtRightEnd(this);
src/commands/math.js:    if (pageX < this.ends[L].jQ.offset().left) return cursor.insAtLeftEnd(this);
src/commands/math.js:    return node.seek(pageX, cursor);
src/commands/math.js:  _.write = function(cursor, ch, replacedFragment) {
src/commands/math.js:    cmd.createLeftOf(cursor);
src/commands/math/commands.js:  _.contactWeld = function(cursor) {
src/commands/math/commands.js:    // unless my block has none, in which case insert the cursor into
src/commands/math/commands.js:            return function(cursor) { cursor.insAtDirEnd(-dir, dest || src); };
src/commands/math/commands.js:        if (cursor && cursor[L] === this) {
src/commands/math/commands.js:            pt[L] ? cursor.insRightOf(pt[L]) : cursor.insAtLeftEnd(pt.parent);
src/commands/math/commands.js:          else cursor.insRightOf(this[dir]);
src/commands/math/commands.js:    this.ends[L].write = function(cursor, ch) {
src/commands/math/commands.js:        cursor.insRightOf(this.parent);
src/commands/math/commands.js:      cmd[supsub].deleteOutOf = function(dir, cursor) {
src/commands/math/commands.js:        cursor.insDirOf(dir, this.parent);
src/commands/math/commands.js:          cursor[-dir] = this.ends[dir];
src/commands/math/commands.js:            .withDirAdopt(dir, cursor.parent, cursor[dir], this.parent)
src/commands/math/commands.js:function insLeftOfMeUnlessAtEnd(cursor) {
src/commands/math/commands.js:  // cursor.insLeftOf(cmd), unless cursor at the end of block, and every
src/commands/math/commands.js:  var cmd = this.parent, ancestorCmd = cursor;
src/commands/math/commands.js:    if (ancestorCmd[R]) return cursor.insLeftOf(cmd);
src/commands/math/commands.js:  cursor.insRightOf(cmd);
src/commands/math/commands.js:  _.createLeftOf = function(cursor) {
src/commands/math/commands.js:      var leftward = cursor[L];
src/commands/math/commands.js:      if (leftward !== cursor[L]) {
src/commands/math/commands.js:        this.replaces(Fragment(leftward[R] || cursor.parent.ends[L], cursor[L]));
src/commands/math/commands.js:        cursor[L] = leftward;
src/commands/math/commands.js:    _super.createLeftOf.call(this, cursor);
src/commands/math/commands.js:  _.createLeftOf = function(cursor) {
src/commands/math/commands.js:      var brack = this.oppBrack(cursor[L], L) || this.oppBrack(cursor[R], R)
src/commands/math/commands.js:                  || this.oppBrack(cursor.parent.parent);
src/commands/math/commands.js:      if (brack === cursor.parent.parent && cursor[side]) { // move the stuff between
src/commands/math/commands.js:        Fragment(cursor[side], cursor.parent.ends[side], -side) // me and ghost outside
src/commands/math/commands.js:      else if (cursor[-side]) { // elsewise, auto-expand so ghost is at far end
src/commands/math/commands.js:        brack.replaces(Fragment(cursor[-side], cursor.parent.ends[-side], side));
src/commands/math/commands.js:        cursor[-side] = 0;
src/commands/math/commands.js:      _super.createLeftOf.call(brack, cursor);
src/commands/math/commands.js:    if (side === L) cursor.insAtLeftEnd(brack.ends[L]);
src/commands/math/commands.js:    else cursor.insRightOf(brack);
src/commands/math/commands.js:  _.deleteSide = function(side, outward, cursor) {
src/commands/math/commands.js:      sib ? cursor.insDirOf(-side, sib) : cursor.insAtDirEnd(side, parent);
src/commands/math/commands.js:      sib ? cursor.insDirOf(-side, sib) : cursor.insAtDirEnd(side, parent);
src/commands/math/commands.js:        cursor.insDirOf(-side, sib);
src/commands/math/commands.js:      } // didn't auto-expand, cursor goes just outside or just inside parens
src/commands/math/commands.js:      else (outward ? cursor.insDirOf(side, this)
src/commands/math/commands.js:                    : cursor.insAtDirEnd(side, this.ends[L]));
src/commands/math/commands.js:  _.deleteTowards = function(dir, cursor) {
src/commands/math/commands.js:    this.deleteSide(-dir, false, cursor);
src/commands/math/commands.js:    this.ends[L].deleteOutOf = function(dir, cursor) {
src/commands/math/commands.js:      this.parent.deleteSide(dir, true, cursor);
src/commands/math/commands.js:    this.ends[L].write = function(cursor, ch, replacedFragment) {
src/commands/math/commands.js:      if (ch.match(/[a-z]/i)) VanillaSymbol(ch).createLeftOf(cursor);
src/commands/math/commands.js:        this.parent.renderCommand(cursor);
src/commands/math/commands.js:        if (ch !== '\\' || !this.isEmpty()) this.parent.parent.write(cursor, ch);
src/commands/math/commands.js:        this.parent.renderCommand(ctrlr.cursor);
src/commands/math/commands.js:  _.createLeftOf = function(cursor) {
src/commands/math/commands.js:    _super.createLeftOf.call(this, cursor);
src/commands/math/commands.js:  _.renderCommand = function(cursor) {
src/commands/math/commands.js:      cursor.insLeftOf(this[R]);
src/commands/math/commands.js:      cursor.insAtRightEnd(this.parent);
src/commands/math/commands.js:    cursor.insertCmd(latex, this._replacedFragment);
src/commands/math/commands.js:    root.cursor = ctrlr.cursor.insAtRightEnd(root);
src/commands/math/symbols.js:  _.createLeftOf = function(cursor) {
src/commands/math/symbols.js:      var str = this.ctrlSeq, l = cursor[L], i = 1;
src/commands/math/symbols.js:          for (var i = 2, l = cursor[L]; i < str.length; i += 1, l = l[L]);
src/commands/math/symbols.js:          Fragment(l, cursor[L]).remove();
src/commands/math/symbols.js:          cursor[L] = l[L];
src/commands/math/symbols.js:          return LatexCmds[str](str).createLeftOf(cursor);
src/commands/math/symbols.js:  _.createLeftOf = function(cursor) {
src/commands/math/symbols.js:      Letter(fn.charAt(i)).createLeftOf(cursor);
src/commands/math/symbols.js:  _.createLeftOf = function(cursor) {
src/commands/math/symbols.js:    block.children().adopt(cursor.parent, cursor[L], cursor[R]);
src/commands/math/symbols.js:    cursor[L] = block.ends[R];
src/commands/math/symbols.js:    block.jQize().insertBefore(cursor.jQ);
src/commands/math/symbols.js:    block.finalizeInsert(cursor);
src/commands/math/symbols.js:    cursor.parent.bubble('edited');
src/commands/math/symbols.js:  _.deleteTowards = function(dir, cursor) {
src/commands/math/symbols.js:  _.createLeftOf = function(cursor) {
src/commands/math/symbols.js:    if (cursor[L] instanceof Inequality && cursor[L].strict) {
src/commands/math/symbols.js:      cursor[L].swap(false);
src/commands/text.js:  _.createLeftOf = function(cursor) {
src/commands/text.js:    _super.createLeftOf.call(this, cursor);
src/commands/text.js:    cursor.insAtRightEnd(textBlock);
src/commands/text.js:        textBlock.write(cursor, textBlock.replacedText.charAt(i));
src/commands/text.js:  // editability methods: called by the cursor for editing, cursor movements,
src/commands/text.js:  // the cursor
src/commands/text.js:  _.moveTowards = function(dir, cursor) { cursor.insAtDirEnd(-dir, this); };
src/commands/text.js:  _.moveOutOf = function(dir, cursor) { cursor.insDirOf(dir, this); };
src/commands/text.js:  _.selectOutOf = function(dir, cursor) {
src/commands/text.js:    cursor.insDirOf(dir, this);
src/commands/text.js:  _.deleteOutOf = function(dir, cursor) {
src/commands/text.js:    if (this.isEmpty()) cursor.insRightOf(this);
src/commands/text.js:  _.write = function(cursor, ch, replacedFragment) {
src/commands/text.js:      if (!cursor[L]) TextPiece(ch).createLeftOf(cursor);
src/commands/text.js:      else cursor[L].appendText(ch);
src/commands/text.js:      cursor.insRightOf(this);
src/commands/text.js:      VanillaSymbol('\\$','$').createLeftOf(cursor);
src/commands/text.js:    else if (!cursor[R]) cursor.insRightOf(this);
src/commands/text.js:    else if (!cursor[L]) cursor.insLeftOf(this);
src/commands/text.js:      cursor.insLeftOf(this);
src/commands/text.js:      _super.createLeftOf.call(leftBlock, cursor);
src/commands/text.js:  _.seek = function(pageX, cursor) {
src/commands/text.js:    cursor.hide();
src/commands/text.js:    // insert cursor at approx position in DOMTextNode
src/commands/text.js:    if (approxPosition <= 0) cursor.insAtLeftEnd(this);
src/commands/text.js:    else if (approxPosition >= textPc.text.length) cursor.insAtRightEnd(this);
src/commands/text.js:    else cursor.insLeftOf(textPc.splitRight(approxPosition));
src/commands/text.js:    var displ = pageX - cursor.show().offset().left; // displacement
src/commands/text.js:    while (cursor[dir] && displ * prevDispl > 0) {
src/commands/text.js:      cursor[dir].moveTowards(dir, cursor);
src/commands/text.js:      displ = pageX - cursor.offset().left;
src/commands/text.js:    if (dir*displ < -dir*prevDispl) cursor[-dir].moveTowards(-dir, cursor);
src/commands/text.js:    if (!cursor.anticursor) {
src/commands/text.js:      this.anticursorPosition = cursor[L] && cursor[L].text.length;
src/commands/text.js:      // ^ get it? 'cos if there's no cursor[L], it's 0... I'm a terrible person.
src/commands/text.js:    else if (cursor.anticursor.parent === this) {
src/commands/text.js:      var cursorPosition = cursor[L] && cursor[L].text.length;;
src/commands/text.js:        cursor.anticursor = Point.copy(cursor);
src/commands/text.js:          var newTextPc = cursor[L].splitRight(this.anticursorPosition);
src/commands/text.js:          cursor[L] = newTextPc;
src/commands/text.js:          var newTextPc = cursor[R].splitRight(this.anticursorPosition - cursorPosition);
src/commands/text.js:        cursor.anticursor = Point(this, newTextPc[L], newTextPc);
src/commands/text.js:  _.moveTowards = function(dir, cursor) {
src/commands/text.js:    else TextPiece(ch).createDir(-dir, cursor);
src/commands/text.js:    return this.deleteTowards(dir, cursor);
src/commands/text.js:  _.deleteTowards = function(dir, cursor) {
src/commands/text.js:      cursor[dir] = this[dir];
src/commands/text.js:  _.selectTowards = function(dir, cursor) {
src/commands/text.js:    var anticursor = cursor.anticursor;
src/commands/text.js:      var newPc = TextPiece(ch).createDir(dir, cursor);
src/commands/text.js:      cursor.insDirOf(dir, newPc);
src/commands/text.js:        var newPc = TextPiece(ch).createDir(-dir, cursor);
src/commands/text.js:        newPc.jQ.insDirOf(-dir, cursor.selection.jQ);
src/commands/text.js:    return this.deleteTowards(dir, cursor);
src/commands/text.js:  _.init = function(cursor) {
src/commands/text.js:    this.cursor = cursor;
src/commands/text.js:    this.ends[L].cursor = this.cursor;
src/commands/text.js:    this.ends[L].write = function(cursor, ch, replacedFragment) {
src/commands/text.js:        MathBlock.prototype.write.call(this, cursor, ch, replacedFragment);
src/commands/text.js:        cursor.insRightOf(this.parent);
src/commands/text.js:        this.parent.deleteTowards(dir, cursor);
src/commands/text.js:        VanillaSymbol('\\$','$').createLeftOf(cursor.show());
src/commands/text.js:      else if (!cursor[R])
src/commands/text.js:        cursor.insRightOf(this.parent);
src/commands/text.js:      else if (!cursor[L])
src/commands/text.js:        cursor.insLeftOf(this.parent);
src/commands/text.js:        MathBlock.prototype.write.call(this, cursor, ch, replacedFragment);
src/commands/text.js:  _.write = function(cursor, ch, replacedFragment) {
src/commands/text.js:      RootMathCommand(cursor).createLeftOf(cursor);
src/commands/text.js:      VanillaSymbol(ch, html).createLeftOf(cursor);
src/controller.js:    this.cursor = Cursor(root);
src/controller.js:      notifyees[i].apply(this.cursor, arguments);
src/css/editable.less:    // TODO: dasherize has-cursor
src/css/math.less:    cursor: text;
src/cursor.js://A fake cursor in the fake textbox that the math is rendered in.
src/cursor.js:    var jQ = this.jQ = this._jQ = $('<span class="cursor">&zwj;</span>');
src/cursor.js:   *   + if so put the cursor there,
src/cursor.js:   *     the cursor's current position
src/cursor.js:    //the cursor) at the end of their parent, so temporarily remove the
src/cursor.js:    var cursor = this;
src/cursor.js:    // Find the lowest common ancestor (`lca`), and the ancestor of the cursor
src/cursor.js:    pray('cursor and anticursor in the same tree', lca);
src/cursor.js:    // The cursor and the anticursor should be in the same tree, because the
src/cursor.js:    // within the tree of `this` cursor's root.
src/publicapi.js:    root.cursor = ctrlr.cursor; // TODO: stop depending on root.cursor, and rm it
src/publicapi.js:      if (this.controller.blurred) this.controller.cursor.hide().parent.blur();
src/publicapi.js:      .replace(/<span class="?cursor( blink)?"?>.?<\/span>/i, '')
src/publicapi.js:    if (this.controller.blurred) this.controller.cursor.hide().parent.blur();
src/publicapi.js:    var ctrlr = this.controller.notify(), cursor = ctrlr.cursor.show(),
src/publicapi.js:      seln = cursor.replaceSelection();
src/publicapi.js:    if (/^\\[a-z]+$/i.test(cmd)) cursor.insertCmd(cmd.slice(1), seln);
src/publicapi.js:    else cursor.parent.write(cursor, cmd, seln);
src/publicapi.js:    if (ctrlr.blurred) cursor.hide().parent.blur();
src/publicapi.js:    ctrlr.notify('move').cursor.insAtRightEnd(ctrlr.root);
src/publicapi.js:    while (ctrlr.cursor[L]) ctrlr.selectLeft();
src/publicapi.js:    this.controller.cursor.clearSelection();
src/publicapi.js:    this.controller.notify('move').cursor.insAtDirEnd(dir, this.controller.root);
src/publicapi.js:      if (this.controller.blurred) this.controller.cursor.hide().parent.blur();
src/services/focusBlur.js:    var ctrlr = this, root = ctrlr.root, cursor = ctrlr.cursor;
src/services/focusBlur.js:      if (!cursor.parent)
src/services/focusBlur.js:        cursor.insAtRightEnd(root);
src/services/focusBlur.js:      if (cursor.selection) {
src/services/focusBlur.js:        cursor.selection.jQ.removeClass('mq-blur');
src/services/focusBlur.js:        cursor.show();
src/services/focusBlur.js:        cursor.clearSelection();
src/services/focusBlur.js:      if (cursor.selection) cursor.selection.jQ.addClass('mq-blur');
src/services/focusBlur.js:      cursor.hide().parent.blur(); // synchronous with/in the same frame as
src/services/focusBlur.js:    cursor.hide();
src/services/keystroke.js:    this.cursor.parent.keystroke(key, evt, this);
src/services/keystroke.js:    var cursor = ctrlr.cursor;
src/services/keystroke.js:      while (cursor[L] || cursor.selection) {
src/services/keystroke.js:      ctrlr.notify('move').cursor.insAtRightEnd(cursor.parent);
src/services/keystroke.js:      ctrlr.notify('move').cursor.insAtRightEnd(ctrlr.root);
src/services/keystroke.js:      while (cursor[R]) {
src/services/keystroke.js:      while (cursor[R] || cursor.parent !== ctrlr.root) {
src/services/keystroke.js:      ctrlr.notify('move').cursor.insAtLeftEnd(cursor.parent);
src/services/keystroke.js:      ctrlr.notify('move').cursor.insAtLeftEnd(ctrlr.root);
src/services/keystroke.js:      while (cursor[L]) {
src/services/keystroke.js:      while (cursor[L] || cursor.parent !== ctrlr.root) {
src/services/keystroke.js:      if (cursor[L]) {
src/services/keystroke.js:        while (cursor[L]) ctrlr.selectLeft();
src/services/keystroke.js:      if (cursor[R]) {
src/services/keystroke.js:        while (cursor[R]) ctrlr.selectRight();
src/services/keystroke.js:      while (cursor[R] || cursor.selection) {
src/services/keystroke.js:      ctrlr.notify('move').cursor.insAtRightEnd(ctrlr.root);
src/services/keystroke.js:      while (cursor[L]) ctrlr.selectLeft();
src/services/keystroke.js:    var cursor = this.cursor;
src/services/keystroke.js:    if (cursor.parent !== this.root) e.preventDefault();
src/services/keystroke.js:    if (cursor.parent === this.root) return;
src/services/keystroke.js:    cursor.parent.moveOutOf(dir, cursor);
src/services/keystroke.js:    var cursor = this.cursor, updown = this.options.leftRightIntoCmdGoes;
src/services/keystroke.js:    if (cursor.selection) {
src/services/keystroke.js:      cursor.insDirOf(dir, cursor.selection.ends[dir]);
src/services/keystroke.js:    else if (cursor[dir]) cursor[dir].moveTowards(dir, cursor, updown);
src/services/keystroke.js:    else cursor.parent.moveOutOf(dir, cursor, updown);
src/services/keystroke.js:   *   + if it's a function, call it with the cursor as the sole argument and
src/services/keystroke.js:    var cursor = self.notify('upDown').cursor;
src/services/keystroke.js:    if (cursor[R][dirInto]) cursor.insAtLeftEnd(cursor[R][dirInto]);
src/services/keystroke.js:    else if (cursor[L][dirInto]) cursor.insAtRightEnd(cursor[L][dirInto]);
src/services/keystroke.js:      cursor.parent.bubble(function(ancestor) {
src/services/keystroke.js:          if (typeof prop === 'function') prop = ancestor[dirOutOf](cursor);
src/services/keystroke.js:          if (prop instanceof Node) cursor.jumpUpDown(ancestor, prop);
src/services/keystroke.js:    var cursor = this.cursor;
src/services/keystroke.js:    var hadSelection = cursor.selection;
src/services/keystroke.js:      if (cursor[dir]) cursor[dir].deleteTowards(dir, cursor);
src/services/keystroke.js:      else cursor.parent.deleteOutOf(dir, cursor);
src/services/keystroke.js:    if (cursor[L].siblingDeleted) cursor[L].siblingDeleted(R);
src/services/keystroke.js:    if (cursor[R].siblingDeleted) cursor[R].siblingDeleted(L);
src/services/keystroke.js:    cursor.parent.bubble('edited');
src/services/keystroke.js:    var cursor = this.notify('select').cursor, seln = cursor.selection;
src/services/keystroke.js:    if (!cursor.anticursor) cursor.startSelection();
src/services/keystroke.js:    var node = cursor[dir];
src/services/keystroke.js:      if (seln && seln.ends[dir] === node && cursor.anticursor[-dir] !== node) {
src/services/keystroke.js:        node.unselectInto(dir, cursor);
src/services/keystroke.js:      else node.selectTowards(dir, cursor);
src/services/keystroke.js:    else cursor.parent.selectOutOf(dir, cursor);
src/services/keystroke.js:    cursor.clearSelection();
src/services/keystroke.js:    cursor.select() || cursor.show();
src/services/latex.js:    var cursor = this.notify('edit').cursor;
src/services/latex.js:      block.children().adopt(cursor.parent, cursor[L], cursor[R]);
src/services/latex.js:      jQ.insertBefore(cursor.jQ);
src/services/latex.js:      cursor[L] = block.ends[R];
src/services/latex.js:      block.finalizeInsert(cursor);
src/services/latex.js:      cursor.parent.bubble('edited');
src/services/latex.js:    var root = this.root, cursor = this.cursor;
src/services/latex.js:    delete cursor.selection;
src/services/latex.js:    cursor.insAtRightEnd(root);
src/services/latex.js:    var root = this.root, cursor = this.cursor;
src/services/latex.js:    delete cursor.selection;
src/services/latex.js:    cursor.show().insAtRightEnd(root);
src/services/latex.js:        // HACK FIXME: this shouldn't have to have access to cursor
src/services/latex.js:        var rootMathCommand = RootMathCommand(cursor);
src/services/mouse.js:      var ctrlr = root.controller, cursor = ctrlr.cursor, blink = cursor.blink;
src/services/mouse.js:        if (!cursor.anticursor) cursor.startSelection();
src/services/mouse.js:        ctrlr.seek($(e.target), e.pageX, e.pageY).cursor.select();
src/services/mouse.js:        // it will try to move the cursor to document, which will not work.
src/services/mouse.js:        // cursor.seek needs to be refactored.
src/services/mouse.js:        cursor.blink = blink;
src/services/mouse.js:        if (!cursor.selection) {
src/services/mouse.js:            cursor.show();
src/services/mouse.js:      cursor.blink = noop;
src/services/mouse.js:      ctrlr.seek($(e.target), e.pageX, e.pageY).cursor.startSelection();
src/services/mouse.js:    var cursor = this.notify('select').cursor;
src/services/mouse.js:    cursor.clearSelection().show();
src/services/mouse.js:    node.seek(pageX, cursor);
src/services/scrollHoriz.js:    var cursor = this.cursor, seln = cursor.selection;
src/services/scrollHoriz.js:      var x = cursor.jQ[0].getBoundingClientRect().left;
src/services/scrollHoriz.js:      if (seln.ends[L] === cursor[R]) {
src/services/textarea.js:    ctrlr.cursor.selectionChanged = function() { ctrlr.selectionChanged(); };
src/services/textarea.js:    if (this.cursor.selection) {
src/services/textarea.js:      latex = this.cursor.selection.join('latex');
src/services/textarea.js:    var ctrlr = this, root = ctrlr.root, cursor = ctrlr.cursor,
src/services/textarea.js:      if (cursor.selection) cursor.selection.clear();
src/services/textarea.js:    var ctrlr = this, root = ctrlr.root, cursor = ctrlr.cursor,
src/services/textarea.js:      if (cursor.selection) {
src/services/textarea.js:          cursor.parent.bubble('edited');
src/services/textarea.js:    if (!this.cursor[L] && disabledChars.indexOf(ch) > -1) return;
src/services/textarea.js:    var cursor = this.notify().cursor;
src/services/textarea.js:    cursor.parent.write(cursor, ch, cursor.show().replaceSelection());
src/services/textarea.js:    this.writeLatex(text).cursor.show();
src/tree.js:  _.createDir = function(dir, cursor) {
src/tree.js:    node.jQ.insDirOf(dir, cursor.jQ);
src/tree.js:    cursor[dir] = node.adopt(cursor.parent, cursor[L], cursor[R]);
test/unit/SupSub.test.js:            prayWellFormedPoint(mq.controller.cursor);
test/unit/SupSub.test.js:          prayWellFormedPoint(mq.controller.cursor);
test/unit/publicapi.test.js:      assert.ok(!mq.controller.cursor.selection);
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor.selection.join('latex'), 'n+\\frac{n}{2}');
test/unit/publicapi.test.js:      assert.ok(!mq.controller.cursor.selection);
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor.selection.join('latex'), 'a');
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor[L].ctrlSeq, '0');
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor[R], 0);
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor[L], 0);
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor[R].ctrlSeq, 'a');
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor[L].ctrlSeq, '0');
test/unit/publicapi.test.js:      assert.equal(mq.controller.cursor[R], 0);
test/unit/publicapi.test.js:    var mq, rootBlock, cursor;
test/unit/publicapi.test.js:      cursor = mq.controller.cursor;
test/unit/publicapi.test.js:      assert.equal(cursor[L].ctrlSeq, '\\ ', 'left of the cursor is ' + cursor[L].ctrlSeq);
test/unit/publicapi.test.js:      assert.equal(cursor[R], 0, 'right of the cursor is ' + cursor[R]);
test/unit/publicapi.test.js:      assert.equal(cursor[L].ctrlSeq, '\\ ', 'left of the cursor is ' + cursor[L].ctrlSeq);
test/unit/publicapi.test.js:      assert.equal(cursor[R], 0, 'right of the cursor is ' + cursor[R]);
test/unit/publicapi.test.js:      cursor = mq.controller.cursor;
test/unit/publicapi.test.js:      assert.equal(cursor[L].parent, rootBlock, 'parent of the cursor is  ' + cursor[L].ctrlSeq);
test/unit/publicapi.test.js:      assert.equal(cursor[R], 0, 'right cursor is ' + cursor[R]);
test/unit/publicapi.test.js:      assert.equal(cursor[L], 0, 'left cursor is ' + cursor[L]);
test/unit/publicapi.test.js:      assert.equal(cursor[R], rootBlock.ends[L], 'parent of rootBlock is ' + cursor[R]);
test/unit/select.test.js:  var cursor = Cursor();
test/unit/select.test.js:  cursor.selectionChanged = noop;
test/unit/select.test.js:      Point.p.init.call(cursor, A.parent, A[L], A[R]);
test/unit/select.test.js:      cursor.startSelection();
test/unit/select.test.js:      Point.p.init.call(cursor, B.parent, B[L], B[R]);
test/unit/select.test.js:      assert.equal(cursor.select(), true);
test/unit/select.test.js:    Point.p.init.call(cursor, A.parent, A[L], A[R]);
test/unit/select.test.js:    cursor.startSelection();
test/unit/select.test.js:    assert.equal(cursor.select(), false);
test/unit/select.test.js:    Point.p.init.call(cursor, A.parent, A[L], A[R]);
test/unit/select.test.js:    cursor.startSelection();
test/unit/select.test.js:    Point.p.init.call(cursor, anotherTree, 0, 0);
test/unit/select.test.js:    assert.throws(function() { cursor.select(); });
test/unit/select.test.js:    Point.p.init.call(cursor, anotherTree, 0, 0);
test/unit/select.test.js:    cursor.startSelection();
test/unit/select.test.js:    Point.p.init.call(cursor, A.parent, A[L], A[R]);
test/unit/select.test.js:    assert.throws(function() { cursor.select(); });
test/unit/text.test.js:  test('changes the text nodes as the cursor moves around', function() {
test/unit/text.test.js:    var ctrlr = Controller(block), cursor = ctrlr.cursor.insAtRightEnd(block);
test/unit/text.test.js:    assertSplit(cursor.jQ, 'abc', null);
test/unit/text.test.js:    assertSplit(cursor.jQ, 'ab', 'c');
test/unit/text.test.js:    assertSplit(cursor.jQ, 'a', 'bc');
test/unit/text.test.js:    assertSplit(cursor.jQ, null, 'abc');
test/unit/text.test.js:    assertSplit(cursor.jQ, 'a', 'bc');
test/unit/text.test.js:    assertSplit(cursor.jQ, 'ab', 'c');
test/unit/text.test.js:    assertSplit(cursor.jQ, 'abc', null);
test/unit/typing.test.js:    prayWellFormedPoint(mq.controller.cursor);
test/unit/updown.test.js:  var mq, rootBlock, controller, cursor;
test/unit/updown.test.js:    cursor = controller.cursor;
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor is in root block');
test/unit/updown.test.js:    assert.equal(cursor[L], exp, 'cursor is at the end of root block');
test/unit/updown.test.js:    assert.equal(cursor.parent, expBlock, 'cursor up goes into exponent');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor down leaves exponent');
test/unit/updown.test.js:    assert.equal(cursor[L], exp, 'down when cursor at end of exponent puts cursor after exponent');
test/unit/updown.test.js:    assert.equal(cursor.parent, expBlock, 'cursor up left stays in exponent');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor is at the beginning of exponent');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor down leaves exponent');
test/unit/updown.test.js:    assert.equal(cursor[R], exp, 'cursor down in beginning of exponent puts cursor before exponent');
test/unit/updown.test.js:    assert.equal(cursor.parent, expBlock, 'cursor up left stays in exponent');
test/unit/updown.test.js:    assert.equal(cursor[L].latex(), 'n', 'cursor is in the middle of exponent');
test/unit/updown.test.js:    assert.equal(cursor[R].latex(), 'm', 'cursor is in the middle of exponent');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor down leaves exponent');
test/unit/updown.test.js:    assert.equal(cursor[R], exp, 'cursor down in middle of exponent puts cursor before exponent');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor is in root block');
test/unit/updown.test.js:    assert.equal(cursor[L], sub, 'cursor is at the end of root block');
test/unit/updown.test.js:    assert.equal(cursor.parent, subBlock, 'cursor down goes into subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor up leaves subscript');
test/unit/updown.test.js:    assert.equal(cursor[L], sub, 'up when cursor at end of subscript puts cursor after subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, subBlock, 'cursor down left stays in subscript');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor is at the beginning of subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor up leaves subscript');
test/unit/updown.test.js:    assert.equal(cursor[R], sub, 'cursor up in beginning of subscript puts cursor before subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, subBlock, 'cursor down left stays in subscript');
test/unit/updown.test.js:    assert.equal(cursor[L].latex(), '1', 'cursor is in the middle of subscript');
test/unit/updown.test.js:    assert.equal(cursor[R].latex(), '2', 'cursor is in the middle of subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor up leaves subscript');
test/unit/updown.test.js:    assert.equal(cursor[R], sub, 'cursor up in middle of subscript puts cursor before subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, numer, 'cursor up goes into numerator');
test/unit/updown.test.js:    assert.equal(cursor[R], 0, 'cursor up from right of fraction inserts at right end of numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, denom, 'cursor down goes into denominator');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor down from numerator inserts at left end of denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, numer, 'cursor up goes into numerator');
test/unit/updown.test.js:    assert.equal(cursor[R], 0, 'cursor up from denominator inserts at right end of numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor outside fraction');
test/unit/updown.test.js:    assert.equal(cursor[R], frac, 'cursor before fraction');
test/unit/updown.test.js:    assert.equal(cursor.parent, numer, 'cursor up goes into numerator');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor up from left of fraction inserts at left end of numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor outside fraction');
test/unit/updown.test.js:    assert.equal(cursor[R], frac, 'cursor before fraction');
test/unit/updown.test.js:    assert.equal(cursor.parent, denom, 'cursor down goes into denominator');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor down from left of fraction inserts at left end of denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, expBlock, 'cursor left goes into exponent');
test/unit/updown.test.js:    assert.equal(cursor.parent, halfDenom, 'cursor down goes into denominator of half');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'down again puts cursor back in root block');
test/unit/updown.test.js:    assert.equal(cursor[L], exp, 'down from end of half puts cursor after exponent');
test/unit/updown.test.js:    cursor.insAtLeftEnd(rootBlock);
test/unit/updown.test.js:    assert.equal(cursor.parent, subBlock, 'cursor in subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracNumer, 'cursor up from beginning of subscript goes into subscript fraction numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up from subscript fraction numerator goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[R], sub, 'cursor up from subscript fraction numerator goes before subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracDenom, 'cursor in subscript fraction denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up up from subscript fraction denominator that\s not at right end goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[R], sub, 'cursor up up from subscript fraction denominator that\s not at right end goes before subscript');
test/unit/updown.test.js:    cursor.insAtRightEnd(subBlock);
test/unit/updown.test.js:    assert.equal(cursor[L], subFrac, 'cursor after subscript fraction');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracDenom, 'cursor in subscript fraction denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up up from subscript fraction denominator that is at right end goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[L], sub, 'cursor up up from subscript fraction denominator that is at right end goes after subscript');
test/unit/updown.test.js:    assert.equal(inner.controller.cursor.parent, inner.controller.root);
test/unit/updown.test.js:    assert.equal(inner.controller.cursor.parent, inner.controller.root);
test/visual.html:.different-bgcolor.mathquill-editable .cursor {
Automatic rewrite of denominator to .mq-denominator

Remaining instances of denominator:
README.md:left end of the denominator, right out of the denominator puts the cursor to the
README.md:the right end of the denominator, etc. Note that right out of the numerator to
README.md:the left end of the denominator is actually leftwards (and downwards, it's
README.md:that left into a fraction goes up into the numerator, skipping the denominator;
README.md:symmetrically, right out of the numerator skips the denominator and puts the
README.md:actually rightwards (the drawback is the denominator is always skipped, you
classes.txt:denominator
src/commands/math/commands.js:    +   '<span class="denominator">&1</span>'
test/unit/publicapi.test.js:    mq.keystroke('Left'); // right edge of denominator
test/unit/updown.test.js:    assert.equal(denom.latex(), '34', 'denominator is right end child of fraction');
test/unit/updown.test.js:    assert.equal(cursor.parent, denom, 'cursor down goes into denominator');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor down from numerator inserts at left end of denominator');
test/unit/updown.test.js:    assert.equal(cursor[R], 0, 'cursor up from denominator inserts at right end of numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, denom, 'cursor down goes into denominator');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor down from left of fraction inserts at left end of denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, halfDenom, 'cursor down goes into denominator of half');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracDenom, 'cursor in subscript fraction denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up up from subscript fraction denominator that\s not at right end goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[R], sub, 'cursor up up from subscript fraction denominator that\s not at right end goes before subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracDenom, 'cursor in subscript fraction denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up up from subscript fraction denominator that is at right end goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[L], sub, 'cursor up up from subscript fraction denominator that is at right end goes after subscript');
Automatic rewrite of empty to .mq-empty

Remaining instances of empty:
README.md:  them to the (default empty) set of "auto-commands", commands automatically
classes.txt:empty
src/commands/math.js:    // empty elements need the empty box provided by blur to
src/commands/math.js:    //insert the cursor at the right end of the first empty child, searching
src/commands/math.js:    //left-to-right, or if none empty, the right end child
src/commands/math/symbols.js:LatexCmds.empty = LatexCmds.emptyset =
src/commands/math/symbols.js:  bind(BinaryOperator,'\\varnothing ','&empty;');
src/css/editable.less:// when empty by inserting invisible text.
src/publicapi.js:      el.empty().unbind('.mathquill')
src/services/latex.js:      jQ.empty();
src/tree.js:    // either it's empty and `rightward` is the left end child (possibly empty)
src/tree.js:    // either it's empty and `leftward` is the right end child (possibly empty)
src/tree.js:    pray('no half-empty fragments', !withDir === !oppDir);
src/tree.js:    // guard for empty and already-disowned fragments
test/support/jquery-1.7.2.js:	// Start with an empty selector
test/support/jquery-1.7.2.js:			empty: function() {
test/support/jquery-1.7.2.js:		// IE will insert them into empty tables
test/support/jquery-1.7.2.js:		// Check if empty table cells still have offsetWidth/Height
test/support/jquery-1.7.2.js:		// if the public data object is empty, the private is still empty
test/support/jquery-1.7.2.js:	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
test/support/jquery-1.7.2.js:	// Setting to empty string throws an error as an invalid value
test/support/jquery-1.7.2.js:			// Return undefined in the case of empty string
test/support/jquery-1.7.2.js:			// removeData also checks for emptiness and clears the expando if empty
test/support/jquery-1.7.2.js:				// Can use an empty set, since event contains the info
test/support/jquery-1.7.2.js:		empty: function( elem ) {
test/support/jquery-1.7.2.js:				this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
test/support/jquery-1.7.2.js:	empty: function() {
test/support/jquery-1.7.2.js:				this.empty().append( value );
test/support/jquery-1.7.2.js:		// checkbox/radio button to an empty string instead of "on"
test/support/jquery-1.7.2.js:		// Avoid setting ret to empty string here
test/support/jquery-1.7.2.js:										// We normalize with Webkit giving an empty statusText
test/unit/SupSub.test.js:    'typed, wrote, wrote empty'.split(', ').forEach(function(did, j) {
test/unit/latex.test.js:  test('empty LaTeX', function () {
test/unit/latex.test.js:      test('empty LaTeX', function () {
test/unit/latex.test.js:      test('empty LaTeX', function () {
test/unit/saneKeyboardEvents.test.js:        assert.equal(el.val(), '', 'the textarea remains empty');
test/unit/tree.test.js:    test('the empty case', function() {
test/unit/tree.test.js:    test('the empty case', function() {
test/unit/tree.test.js:    test('an empty fragment', function() {
test/unit/tree.test.js:      var empty = Fragment();
test/unit/tree.test.js:      empty.each(function() { count += 1 });
test/unit/tree.test.js:      assert.equal(count, 0, 'each is a noop on an empty fragment');
test/unit/tree.test.js:    test('half-empty fragments are disallowed', function() {
test/unit/tree.test.js:      }, 'half-empty on the right');
test/unit/tree.test.js:      }, 'half-empty on the left');
test/unit/typing.test.js:      test('empty parens', function() {
test/unit/typing.test.js:      test('empty mis-matched brackets', function() {
test/unit/typing.test.js:      test('empty pipes', function() {
test/unit/typing.test.js:      test('backspacing close-bracket then open-paren of 1+(]+4 (empty paren group)', function() {
test/unit/typing.test.js:      test('backspacing open-paren then close-bracket of 1+(]+4 (empty paren group)', function() {
test/unit/typing.test.js:      test('backspacing close-bracket then open-paren of 1+(] (empty paren group, nothing after)', function() {
test/unit/typing.test.js:      test('backspacing open-paren then close-bracket of 1+(] (empty paren group, nothing after)', function() {
test/unit/typing.test.js:      test('backspacing close-bracket then open-paren of (]+4 (empty paren group, nothing before)', function() {
test/unit/typing.test.js:      test('backspacing open-paren then close-bracket of (]+4 (empty paren group, nothing before)', function() {
test/unit/typing.test.js:        test('backspacing close-pipe then open-pipe of 1+||+4 (empty pipe pair)', function() {
test/unit/typing.test.js:        test('backspacing open-pipe then close-pipe of 1+||+4 (empty pipe pair)', function() {
test/unit/typing.test.js:        test('backspacing close-pipe then open-pipe of 1+|| (empty pipe pair, nothing after)', function() {
test/unit/typing.test.js:        test('backspacing open-pipe then close-pipe of 1+|| (empty pipe pair, nothing after)', function() {
test/unit/typing.test.js:        test('backspacing close-pipe then open-pipe of ||+4 (empty pipe pair, nothing before)', function() {
test/unit/typing.test.js:        test('backspacing open-pipe then close-pipe of ||+4 (empty pipe pair, nothing before)', function() {
Automatic rewrite of florin to .mq-florin

Remaining instances of florin:
classes.txt:florin
src/commands/math.js:    if (ch.match(/^[a-eg-zA-Z]$/)) //exclude f because want florin
src/commands/math/symbols.js:LatexCmds.f = bind(Symbol, 'f', '<var class="florin">&fnof;</var><span style="display:inline-block;width:0">&nbsp;</span>');
Automatic rewrite of focused to .mq-focused

Remaining instances of focused:
classes.txt:focused
src/services/saneKeyboardEvents.util.js:      // when the textarea is not necessarily focused.  We focus it
Automatic rewrite of font to .mq-font

Remaining instances of font:
.gitattributes:src/font/* text=binary
Makefile:FONT_SOURCE = $(SRC_DIR)/font
Makefile:FONT_TARGET = $(BUILD_DIR)/font
Makefile:.PHONY: all cat uglify css font dist clean
Makefile:all: font css uglify
Makefile:dev: font css js
Makefile:font: $(FONT_TARGET)
README.md:`font/` directory relative to `mathquill.css` (or change your copy of
README.md:font isn't settled, and fractions are somewhat arcane, see the Wiki pages
classes.txt:font
src/commands/math/commands.js:LatexCmds.mathrm = bind(Style, '\\mathrm', 'span', 'class="roman font"');
src/commands/math/commands.js:LatexCmds.mathit = bind(Style, '\\mathit', 'i', 'class="font"');
src/commands/math/commands.js:LatexCmds.mathbf = bind(Style, '\\mathbf', 'b', 'class="font"');
src/commands/math/commands.js:LatexCmds.mathsf = bind(Style, '\\mathsf', 'span', 'class="sans-serif font"');
src/commands/math/commands.js:LatexCmds.mathtt = bind(Style, '\\mathtt', 'span', 'class="monospace font"');
src/commands/math/symbols.js:// does not use Symbola font
src/commands/math/symbols.js:  bind(Symbol,'\\Upsilon ','<var style="font-family: serif">&upsih;</var>'); //Symbola's 'upsilon with a hook' is a capital Y without hooks :(
src/commands/text.js: * Represents flat strings of typically serif-font Roman characters, as
src/commands/text.js:  makeTextBlock('\\textsc', 'span', 'style="font-variant:small-caps" class="text"');
src/css/editable.less:    font-family: @mono;
src/css/font.less:@font-face {
src/css/font.less:  font-family: Symbola;
src/css/font.less:  src: url(font/Symbola.eot);
src/css/font.less:    url(font/Symbola.ttf) format("truetype"),
src/css/font.less:    url(font/Symbola.otf) format("opentype"),
src/css/font.less:    url(font/Symbola.svg#Symbola) format("svg")
src/css/main.less:@import "font.less";
src/css/math.less:  font-variant: normal;
src/css/math.less:  font-weight: normal;
src/css/math.less:  font-style: normal;
src/css/math.less:  font-size: 115%;
src/css/math.less:    font-family: @times;
src/css/math.less:    font-size: inherit;
src/css/math.less:    font-size: 87%;
src/css/math.less:    font: 1em @times;
src/css/math.less:      font-family: inherit;
src/css/math.less:      font-style: inherit;
src/css/math.less:  // TODO [Han]: Why do we have to special-case .font?
src/css/math.less:    font-weight: bolder;
src/css/math.less:    font-style: italic;
src/css/math.less:    font-size: 125%;
src/css/math.less:    font-style: normal;
src/css/math.less:    font-family: sans-serif, Symbola, serif;
src/css/math.less:    font-family: monospace, Symbola, serif;
src/css/math.less:    font-size: 90%;
src/css/math.less:      font-size: 80%;
src/css/math.less:      font-size: 70%;
src/css/math.less:    font-size: 80%;
src/css/math.less:    font-family: Symbola, "Times New Roman", serif;
src/css/math.less:    font-style: normal;
src/css/math.less:    font-size: 90%;
src/css/math.less:    font-size: 0.75em;
src/css/math.less:      font-size: 80%;
src/css/math.less:    font-family: @symbola;
src/font/Symbola.svg:<font id="Symbola" horiz-adv-x="2048" >
src/font/Symbola.svg:<font-face units-per-em="2048" ascent="1606" descent="-442" />
src/font/Symbola.svg:</font>
src/font/stixgeneral-bundle/STIXFontLicense2010.txt:of collaborative font projects, to support the font creation efforts of academic
src/font/stixgeneral-bundle/STIXFontLicense2010.txt:restriction only applies to the primary font name as presented to the users.
src/font/stixgeneral-bundle/stixgeneral-webfont.svg:<font id="webfontZXtFAA5Q" horiz-adv-x="685" >
src/font/stixgeneral-bundle/stixgeneral-webfont.svg:<font-face units-per-em="1000" ascent="750" descent="-250" />
src/font/stixgeneral-bundle/stixgeneral-webfont.svg:</font>
src/font/stixgeneral-bundle/stixgeneralbol-webfont.svg:<font id="webfontwFpnxWyx" horiz-adv-x="750" >
src/font/stixgeneral-bundle/stixgeneralbol-webfont.svg:<font-face units-per-em="1000" ascent="750" descent="-250" />
src/font/stixgeneral-bundle/stixgeneralbol-webfont.svg:</font>
src/font/stixgeneral-bundle/stixgeneralbolita-webfont.svg:<font id="webfontSsfHxKRo" horiz-adv-x="500" >
src/font/stixgeneral-bundle/stixgeneralbolita-webfont.svg:<font-face units-per-em="1000" ascent="750" descent="-250" />
src/font/stixgeneral-bundle/stixgeneralbolita-webfont.svg:</font>
src/font/stixgeneral-bundle/stixgeneralitalic-webfont.svg:<font id="webfont2oJeLJIt" horiz-adv-x="500" >
src/font/stixgeneral-bundle/stixgeneralitalic-webfont.svg:<font-face units-per-em="1000" ascent="750" descent="-250" />
src/font/stixgeneral-bundle/stixgeneralitalic-webfont.svg:</font>
test/demo.html:  font: 90% Verdana, sans-serif;
test/demo.html:  font-size: 90%;
test/support/home.css:  font-family: Georgia, serif;
test/support/home.css:  font-size: 2em;
test/support/home.css:  font-size: 60%;
test/support/home.css:  font: 90% monospace;
test/visual.html:  font-size: .8em;
test/visual.html:  font-size: 2.5em;
test/visual.html:<tr><td><span class="mathquill-embedded-latex" style="font-size:1.4375em">\left| a + \left| b \right| \right|</span><td><span>\left| a + \left| b \right| \right|</span>
test/visual.html:<tr><td><span class="mathquill-embedded-latex" style="font-size:1.4375em">\left(\left(\left(\left(\left(\left(\left( \right)\right)\right)\right)\right)\right)\right)</span><td><span>\left(\left(\left(\left(\left(\left(\left( \right)\right)\right)\right)\right)\right)\right)</span>
test/visual.html:<tr><td><span class="mathquill-embedded-latex" style="font-size:1.4375em">\sqrt{x}+\sqrt{\frac{x}{\frac{ }{\frac{ }{ }}}}+\sqrt{\frac{x}{\frac{ }{\frac{ }{\frac{ }{\frac{ }{ }}}}}}</span><td><span>\sqrt{x}+\sqrt{\frac{x}{\frac{ }{\frac{ }{ }}}}+\sqrt{\frac{x}{\frac{ }{\frac{ }{\frac{ }{\frac{ }{ }}}}}}</span>
test/visual.html:  .testclass { background-color: #5A8; border-radius: 5px; padding: 4px; font-weight:bold;color:gold;}
Automatic rewrite of fraction to .mq-fraction

Remaining instances of fraction:
README.md:positions in a particular order: right into a fraction puts the cursor at the
README.md:right of the fraction; symmetrically, left into a fraction puts the cursor at
README.md:that left into a fraction goes up into the numerator, skipping the denominator;
README.md:cursor to the right of the fraction, which unlike the default behavior is
README.md:the `border-color`, because the cursor, fraction bar, and square root
README.md:- A **command** is a thing you can type and edit like a fraction, square root,
README.md:  a fraction vs into a square root, they export different LaTeX, etc), cue
classes.txt:fraction
src/commands/math/commands.js:LatexCmds.fraction = P(MathCommand, function(_, _super) {
src/commands/math/commands.js:      '<span class="fraction non-leaf">'
src/css/math.less:  //   See also .fraction
src/services/mouse.js:    // seek from root, which is less accurate (e.g. fraction)
test/unit/updown.test.js:  test('up/down into and within fraction', function() {
test/unit/updown.test.js:    assert.equal(frac.latex(), '\\frac{12}{34}', 'fraction is in root block');
test/unit/updown.test.js:    assert.equal(frac, rootBlock.ends[R], 'fraction is sole child of root block');
test/unit/updown.test.js:    assert.equal(numer.latex(), '12', 'numerator is left end child of fraction');
test/unit/updown.test.js:    assert.equal(denom.latex(), '34', 'denominator is right end child of fraction');
test/unit/updown.test.js:    assert.equal(cursor[R], 0, 'cursor up from right of fraction inserts at right end of numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor outside fraction');
test/unit/updown.test.js:    assert.equal(cursor[R], frac, 'cursor before fraction');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor up from left of fraction inserts at left end of numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, rootBlock, 'cursor outside fraction');
test/unit/updown.test.js:    assert.equal(cursor[R], frac, 'cursor before fraction');
test/unit/updown.test.js:    assert.equal(cursor[L], 0, 'cursor down from left of fraction inserts at left end of denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracNumer, 'cursor up from beginning of subscript goes into subscript fraction numerator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up from subscript fraction numerator goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[R], sub, 'cursor up from subscript fraction numerator goes before subscript');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracDenom, 'cursor in subscript fraction denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up up from subscript fraction denominator that\s not at right end goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[R], sub, 'cursor up up from subscript fraction denominator that\s not at right end goes before subscript');
test/unit/updown.test.js:    assert.equal(subFrac[R], 0, 'subscript fraction is at right end');
test/unit/updown.test.js:    assert.equal(cursor[L], subFrac, 'cursor after subscript fraction');
test/unit/updown.test.js:    assert.equal(cursor.parent, subFracDenom, 'cursor in subscript fraction denominator');
test/unit/updown.test.js:    assert.equal(cursor.parent, dxBlock, 'cursor up up from subscript fraction denominator that is at right end goes out of subscript');
test/unit/updown.test.js:    assert.equal(cursor[L], sub, 'cursor up up from subscript fraction denominator that is at right end goes after subscript');
test/unit/updown.test.js:  test('\\MathQuillMathField{} in a fraction', function() {
Automatic rewrite of ghost to .mq-ghost

Remaining instances of ghost:
classes.txt:ghost
src/commands/math/commands.js://   first typed as one-sided bracket with matching "ghost" bracket at
src/commands/math/commands.js:      +   '<span class="scaled paren'+(this.side === R ? ' ghost' : '')+'">'
src/commands/math/commands.js:      +   '<span class="scaled paren'+(this.side === L ? ' ghost' : '')+'">'
src/commands/math/commands.js:        Fragment(cursor[side], cursor.parent.ends[side], -side) // me and ghost outside
src/commands/math/commands.js:      else if (cursor[-side]) { // elsewise, auto-expand so ghost is at far end
src/commands/math/commands.js:    if (side === this.side) { // deleting non-ghost of one-sided bracket, unwrap
src/commands/math/commands.js:    if (this.oppBrack(this.ends[L].ends[this.side], side)) { // paren is ghost,
src/commands/math/commands.js:        this.parent.parent.closeOpposing(this); // ghost, if so become [1+2+3)
src/commands/math/commands.js:      if (sib) { // auto-expand so ghost is at far end
src/commands/math/commands.js:  _.siblingCreated = function(dir) { // if something typed between ghost and far
src/css/math.less:    &.ghost { color: silver; }
test/unit/typing.test.js:        // now check that the inner open-paren isn't still a ghost
test/unit/typing.test.js:    suite('typing outside ghost paren', function() {
test/unit/typing.test.js:      test('typing outside ghost paren solidifies ghost', function() {
test/unit/typing.test.js:      test('close paren group by typing close-bracket outside ghost paren', function() {
test/visual.html:<p>In all editable fields, the selection should clear and ghost parens should solidify if you click outside, but not if you switch tabs/windows and switch back to this page.
Automatic rewrite of hasCursor to .mq-hasCursor

Remaining instances of hasCursor:
classes.txt:hasCursor
src/publicapi.js:      .replace(/ hasCursor|hasCursor ?/, '')
Automatic rewrite of large-operator to .mq-large-operator

Remaining instances of large-operator:
classes.txt:large-operator
src/commands/math/commands.js:      '<span class="large-operator non-leaf">'
Automatic rewrite of latex-command-input to .mq-latex-command-input

Remaining instances of latex-command-input:
classes.txt:latex-command-input
src/commands/math/commands.js:  _.htmlTemplate = '<span class="latex-command-input non-leaf">\\<span>&0</span></span>';
Automatic rewrite of limit to .mq-limit

Remaining instances of limit:
classes.txt:limit
Automatic rewrite of matrixed to .mq-matrixed

Remaining instances of matrixed:
README.md:editable itself, set it on elements with class `matrixed`, and then set
README.md:a Chroma filter on elements with class `matrixed-container`.
README.md:    #my-math-input .matrixed {
README.md:    #my-math-input .matrixed-container {
classes.txt:matrixed
classes.txt:matrixed-container
src/commands/math/commands.js:    if (!jQ.hasClass('matrixed-container')) {
src/commands/math/commands.js:      jQ.addClass('matrixed-container')
src/commands/math/commands.js:      .wrapInner('<span class="matrixed"></span>');
src/css/main.less:@import "matrixed.less";
src/css/matrixed.less:  .matrixed-container {
src/css/selections.less:// have rules setting the background color of .matrixed and
src/css/selections.less:// .matrixed-container, and we need to guarantee that our rules
src/css/selections.less:// setting the background color of matrixed/containers inside
src/css/selections.less:    .matrixed-container {
src/css/selections.less:      .matrixed-container {
test/visual.html:.different-bgcolor.mathquill-editable .matrixed {
Automatic rewrite of matrixed-container to .mq-matrixed-container

Remaining instances of matrixed-container:
README.md:a Chroma filter on elements with class `matrixed-container`.
README.md:    #my-math-input .matrixed-container {
classes.txt:matrixed-container
src/css/selections.less:// .matrixed-container, and we need to guarantee that our rules
Automatic rewrite of monospace to .mq-monospace

Remaining instances of monospace:
classes.txt:monospace
src/commands/math/commands.js:LatexCmds.mathtt = bind(Style, '\\mathtt', 'span', 'class="monospace font"');
src/commands/text.js:  makeTextBlock('\\texttt', 'span', 'class="monospace text"');
src/css/math.less:    font-family: monospace, Symbola, serif;
src/css/mixins/fonts.less:@mono: "Courier New", monospace;
test/support/home.css:  font: 90% monospace;
Automatic rewrite of non-leaf to .mq-non-leaf

Remaining instances of non-leaf:
classes.txt:non-leaf
src/commands/math/commands.js:LatexCmds.underline = bind(Style, '\\underline', 'span', 'class="non-leaf underline"');
src/commands/math/commands.js:LatexCmds.overline = LatexCmds.bar = bind(Style, '\\overline', 'span', 'class="non-leaf overline"');
src/commands/math/commands.js:      '<span class="large-operator non-leaf">'
src/commands/math/commands.js:      '<span class="supsub non-leaf">'
src/commands/math/commands.js:      '<span class="supsub non-leaf sup-only">'
src/commands/math/commands.js:      '<span class="fraction non-leaf">'
src/commands/math/commands.js:      '<span class="non-leaf">'
src/commands/math/commands.js:    +   '<span class="non-leaf sqrt-stem">&0</span>'
src/commands/math/commands.js:      '<span class="non-leaf">'
src/commands/math/commands.js:      '<sup class="nthroot non-leaf">&0</sup>'
src/commands/math/commands.js:    +   '<span class="sqrt-stem non-leaf">&1</span>'
src/commands/math/commands.js:        '<span class="non-leaf">'
src/commands/math/commands.js:      +   '<span class="non-leaf">&0</span>'
src/commands/math/commands.js:  _.htmlTemplate = '<span class="latex-command-input non-leaf">\\<span>&0</span></span>';
src/commands/math/commands.js:      '<span class="non-leaf">'
src/commands/math/commands.js:    +   '<span class="non-leaf">'
src/commands/math/commands.js:    +     '<span class="array non-leaf">'