The Tor Browser / file revision

 "use strict";

 var htmlNamespace = "http://www.w3.org/1999/xhtml";

 var cssStylingFlag = false;

 var defaultSingleLineContainerName = "p";

 // This is bad :(

 var globalRange = null;

 // Commands are stored in a dictionary where we call their actions and such

 var commands = {};

 ///////////////////////////////////////////////////////////////////////////////

 ////////////////////////////// Utility functions //////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////

 //@{

 function nextNode(node) {

 	if (node.hasChildNodes()) {

 		return node.firstChild;

 	}

 	return nextNodeDescendants(node);

 }

 function previousNode(node) {

 	if (node.previousSibling) {

 		node = node.previousSibling;

 		while (node.hasChildNodes()) {

 			node = node.lastChild;

 		}

 		return node;

 	}

 	if (node.parentNode

 	&& node.parentNode.nodeType == Node.ELEMENT_NODE) {

 		return node.parentNode;

 	}

 	return null;

 }

 function nextNodeDescendants(node) {

 	while (node && !node.nextSibling) {

 		node = node.parentNode;

 	}

 	if (!node) {

 		return null;

 	}

 	return node.nextSibling;

 }

 /**

  * Returns true if ancestor is an ancestor of descendant, false otherwise.

  */

 function isAncestor(ancestor, descendant) {

 	return ancestor

 		&& descendant

 		&& Boolean(ancestor.compareDocumentPosition(descendant) & Node.DOCUMENT_POSITION_CONTAINED_BY);

 }

 /**

  * Returns true if ancestor is an ancestor of or equal to descendant, false

  * otherwise.

  */

 function isAncestorContainer(ancestor, descendant) {

 	return (ancestor || descendant)

 		&& (ancestor == descendant || isAncestor(ancestor, descendant));

 }

 /**

  * Returns true if descendant is a descendant of ancestor, false otherwise.

  */

 function isDescendant(descendant, ancestor) {

 	return ancestor

 		&& descendant

 		&& Boolean(ancestor.compareDocumentPosition(descendant) & Node.DOCUMENT_POSITION_CONTAINED_BY);

 }

 /**

  * Returns true if node1 is before node2 in tree order, false otherwise.

  */

 function isBefore(node1, node2) {

 	return Boolean(node1.compareDocumentPosition(node2) & Node.DOCUMENT_POSITION_FOLLOWING);

 }

 /**

  * Returns true if node1 is after node2 in tree order, false otherwise.

  */

 function isAfter(node1, node2) {

 	return Boolean(node1.compareDocumentPosition(node2) & Node.DOCUMENT_POSITION_PRECEDING);

 }

 function getAncestors(node) {

 	var ancestors = [];

 	while (node.parentNode) {

 		ancestors.unshift(node.parentNode);

 		node = node.parentNode;

 	}

 	return ancestors;

 }

 function getInclusiveAncestors(node) {

 	return getAncestors(node).concat(node);

 }

 function getDescendants(node) {

 	var descendants = [];

 	var stop = nextNodeDescendants(node);

 	while ((node = nextNode(node))

 	&& node != stop) {

 		descendants.push(node);

 	}

 	return descendants;

 }

 function getInclusiveDescendants(node) {

 	return [node].concat(getDescendants(node));

 }

 function convertProperty(property) {

 	// Special-case for now

 	var map = {

 		"fontFamily": "font-family",

 		"fontSize": "font-size",

 		"fontStyle": "font-style",

 		"fontWeight": "font-weight",

 		"textDecoration": "text-decoration",

 	};

 	if (typeof map[property] != "undefined") {

 		return map[property];

 	}

 	return property;

 }

 // Return the <font size=X> value for the given CSS size, or undefined if there

 // is none.

 function cssSizeToLegacy(cssVal) {

 	return {

 		"x-small": 1,

 		"small": 2,

 		"medium": 3,

 		"large": 4,

 		"x-large": 5,

 		"xx-large": 6,

 		"xxx-large": 7

 	}[cssVal];

 }

 // Return the CSS size given a legacy size.

 function legacySizeToCss(legacyVal) {

 	return {

 		1: "x-small",

 		2: "small",

 		3: "medium",

 		4: "large",

 		5: "x-large",

 		6: "xx-large",

 		7: "xxx-large",

 	}[legacyVal];

 }

 // Opera 11 puts HTML elements in the null namespace, it seems.

 function isHtmlNamespace(ns) {

 	return ns === null

 		|| ns === htmlNamespace;

 }

 // "the directionality" from HTML.  I don't bother caring about non-HTML

 // elements.

 //

 // "The directionality of an element is either 'ltr' or 'rtl', and is

 // determined as per the first appropriate set of steps from the following

 // list:"

 function getDirectionality(element) {

 	// "If the element's dir attribute is in the ltr state

 	//     The directionality of the element is 'ltr'."

 	if (element.dir == "ltr") {

 		return "ltr";

 	}

 	// "If the element's dir attribute is in the rtl state

 	//     The directionality of the element is 'rtl'."

 	if (element.dir == "rtl") {

 		return "rtl";

 	}

 	// "If the element's dir attribute is in the auto state

 	// "If the element is a bdi element and the dir attribute is not in a

 	// defined state (i.e. it is not present or has an invalid value)

 	//     [lots of complicated stuff]

 	//

 	// Skip this, since no browser implements it anyway.

 	// "If the element is a root element and the dir attribute is not in a

 	// defined state (i.e. it is not present or has an invalid value)

 	//     The directionality of the element is 'ltr'."

 	if (!isHtmlElement(element.parentNode)) {

 		return "ltr";

 	}

 	// "If the element has a parent element and the dir attribute is not in a

 	// defined state (i.e. it is not present or has an invalid value)

 	//     The directionality of the element is the same as the element's

 	//     parent element's directionality."

 	return getDirectionality(element.parentNode);

 }

 //@}

 ///////////////////////////////////////////////////////////////////////////////

 ///////////////////////////// DOM Range functions /////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////

 //@{

 function getNodeIndex(node) {

 	var ret = 0;

 	while (node.previousSibling) {

 		ret++;

 		node = node.previousSibling;

 	}

 	return ret;

 }

 // "The length of a Node node is the following, depending on node:

 //

 // ProcessingInstruction

 // DocumentType

 //   Always 0.

 // Text

 // Comment

 //   node's length.

 // Any other node

 //   node's childNodes's length."

 function getNodeLength(node) {

 	switch (node.nodeType) {

 		case Node.PROCESSING_INSTRUCTION_NODE:

 		case Node.DOCUMENT_TYPE_NODE:

 			return 0;

 		case Node.TEXT_NODE:

 		case Node.COMMENT_NODE:

 			return node.length;

 		default:

 			return node.childNodes.length;

 	}

 }

 /**

  * The position of two boundary points relative to one another, as defined by

  * DOM Range.

  */

 function getPosition(nodeA, offsetA, nodeB, offsetB) {

 	// "If node A is the same as node B, return equal if offset A equals offset

 	// B, before if offset A is less than offset B, and after if offset A is

 	// greater than offset B."

 	if (nodeA == nodeB) {

 		if (offsetA == offsetB) {

 			return "equal";

 		}

 		if (offsetA < offsetB) {

 			return "before";

 		}

 		if (offsetA > offsetB) {

 			return "after";

 		}

 	}

 	// "If node A is after node B in tree order, compute the position of (node

 	// B, offset B) relative to (node A, offset A). If it is before, return

 	// after. If it is after, return before."

 	if (nodeB.compareDocumentPosition(nodeA) & Node.DOCUMENT_POSITION_FOLLOWING) {

 		var pos = getPosition(nodeB, offsetB, nodeA, offsetA);

 		if (pos == "before") {

 			return "after";

 		}

 		if (pos == "after") {

 			return "before";

 		}

 	}

 	// "If node A is an ancestor of node B:"

 	if (nodeB.compareDocumentPosition(nodeA) & Node.DOCUMENT_POSITION_CONTAINS) {

 		// "Let child equal node B."

 		var child = nodeB;

 		// "While child is not a child of node A, set child to its parent."

 		while (child.parentNode != nodeA) {

 			child = child.parentNode;

 		}

 		// "If the index of child is less than offset A, return after."

 		if (getNodeIndex(child) < offsetA) {

 			return "after";

 		}

 	}

 	// "Return before."

 	return "before";

 }

 /**

  * Returns the furthest ancestor of a Node as defined by DOM Range.

  */

 function getFurthestAncestor(node) {

 	var root = node;

 	while (root.parentNode != null) {

 		root = root.parentNode;

 	}

 	return root;

 }

 /**

  * "contained" as defined by DOM Range: "A Node node is contained in a range

  * range if node's furthest ancestor is the same as range's root, and (node, 0)

  * is after range's start, and (node, length of node) is before range's end."

  */

 function isContained(node, range) {

 	var pos1 = getPosition(node, 0, range.startContainer, range.startOffset);

 	var pos2 = getPosition(node, getNodeLength(node), range.endContainer, range.endOffset);

 	return getFurthestAncestor(node) == getFurthestAncestor(range.startContainer)

 		&& pos1 == "after"

 		&& pos2 == "before";

 }

 /**

  * Return all nodes contained in range that the provided function returns true

  * for, omitting any with an ancestor already being returned.

  */

 function getContainedNodes(range, condition) {

 	if (typeof condition == "undefined") {

 		condition = function() { return true };

 	}

 	var node = range.startContainer;

 	if (node.hasChildNodes()

 	&& range.startOffset < node.childNodes.length) {

 		// A child is contained

 		node = node.childNodes[range.startOffset];

 	} else if (range.startOffset == getNodeLength(node)) {

 		// No descendant can be contained

 		node = nextNodeDescendants(node);

 	} else {

 		// No children; this node at least can't be contained

 		node = nextNode(node);

 	}

 	var stop = range.endContainer;

 	if (stop.hasChildNodes()

 	&& range.endOffset < stop.childNodes.length) {

 		// The node after the last contained node is a child

 		stop = stop.childNodes[range.endOffset];

 	} else {

 		// This node and/or some of its children might be contained

 		stop = nextNodeDescendants(stop);

 	}

 	var nodeList = [];

 	while (isBefore(node, stop)) {

 		if (isContained(node, range)

 		&& condition(node)) {

 			nodeList.push(node);

 			node = nextNodeDescendants(node);

 			continue;

 		}

 		node = nextNode(node);

 	}

 	return nodeList;

 }

 /**

  * As above, but includes nodes with an ancestor that's already been returned.

  */

 function getAllContainedNodes(range, condition) {

 	if (typeof condition == "undefined") {

 		condition = function() { return true };

 	}

 	var node = range.startContainer;

 	if (node.hasChildNodes()

 	&& range.startOffset < node.childNodes.length) {

 		// A child is contained

 		node = node.childNodes[range.startOffset];

 	} else if (range.startOffset == getNodeLength(node)) {

 		// No descendant can be contained

 		node = nextNodeDescendants(node);

 	} else {

 		// No children; this node at least can't be contained

 		node = nextNode(node);

 	}

 	var stop = range.endContainer;

 	if (stop.hasChildNodes()

 	&& range.endOffset < stop.childNodes.length) {

 		// The node after the last contained node is a child

 		stop = stop.childNodes[range.endOffset];

 	} else {

 		// This node and/or some of its children might be contained

 		stop = nextNodeDescendants(stop);

 	}

 	var nodeList = [];

 	while (isBefore(node, stop)) {

 		if (isContained(node, range)

 		&& condition(node)) {

 			nodeList.push(node);

 		}

 		node = nextNode(node);

 	}

 	return nodeList;

 }

 // Returns either null, or something of the form rgb(x, y, z), or something of

 // the form rgb(x, y, z, w) with w != 0.

 function normalizeColor(color) {

 	if (color.toLowerCase() == "currentcolor") {

 		return null;

 	}

 	if (normalizeColor.resultCache === undefined) {

 		normalizeColor.resultCache = {};

 	}

 	if (normalizeColor.resultCache[color] !== undefined) {

 		return normalizeColor.resultCache[color];

 	}

 	var originalColor = color;

 	var outerSpan = document.createElement("span");

 	document.body.appendChild(outerSpan);

 	outerSpan.style.color = "black";

 	var innerSpan = document.createElement("span");

 	outerSpan.appendChild(innerSpan);

 	innerSpan.style.color = color;

 	color = getComputedStyle(innerSpan).color;

 	if (color == "rgb(0, 0, 0)") {

 		// Maybe it's really black, maybe it's invalid.

 		outerSpan.color = "white";

 		color = getComputedStyle(innerSpan).color;

 		if (color != "rgb(0, 0, 0)") {

 			return normalizeColor.resultCache[originalColor] = null;

 		}

 	}

 	document.body.removeChild(outerSpan);

 	// I rely on the fact that browsers generally provide consistent syntax for

 	// getComputedStyle(), although it's not standardized.  There are only

 	// three exceptions I found:

 	if (/^rgba\([0-9]+, [0-9]+, [0-9]+, 1\)$/.test(color)) {

 		// IE10PP2 seems to do this sometimes.

 		return normalizeColor.resultCache[originalColor] =

 			color.replace("rgba", "rgb").replace(", 1)", ")");

 	}

 	if (color == "transparent") {

 		// IE10PP2, Firefox 7.0a2, and Opera 11.50 all return "transparent" if

 		// the specified value is "transparent".

 		return normalizeColor.resultCache[originalColor] =

 			"rgba(0, 0, 0, 0)";

 	}

 	// Chrome 15 dev adds way too many significant figures.  This isn't a full

 	// fix, it just fixes one case that comes up in tests.

 	color = color.replace(/, 0.496094\)$/, ", 0.5)");

 	return normalizeColor.resultCache[originalColor] = color;

 }

 // Returns either null, or something of the form #xxxxxx.

 function parseSimpleColor(color) {

 	color = normalizeColor(color);

 	var matches = /^rgb\(([0-9]+), ([0-9]+), ([0-9]+)\)$/.exec(color);

 	if (matches) {

 		return "#"

 			+ parseInt(matches[1]).toString(16).replace(/^.$/, "0$&")

 			+ parseInt(matches[2]).toString(16).replace(/^.$/, "0$&")

 			+ parseInt(matches[3]).toString(16).replace(/^.$/, "0$&");

 	}

 	return null;

 }

 //@}

 //////////////////////////////////////////////////////////////////////////////

 /////////////////////////// Edit command functions ///////////////////////////

 //////////////////////////////////////////////////////////////////////////////

 /////////////////////////////////////////////////

 ///// Methods of the HTMLDocument interface /////

 /////////////////////////////////////////////////

 //@{

 var executionStackDepth = 0;

 // Helper function for common behavior.

 function editCommandMethod(command, range, callback) {

 	// Set up our global range magic, but only if we're the outermost function

 	if (executionStackDepth == 0 && typeof range != "undefined") {

 		globalRange = range;

 	} else if (executionStackDepth == 0) {

 		globalRange = null;

 		globalRange = getActiveRange();

 	}

 	executionStackDepth++;

 	try {

 		var ret = callback();

 	} catch(e) {

 		executionStackDepth--;

 		throw e;

 	}

 	executionStackDepth--;

 	return ret;

 }

 function myExecCommand(command, showUi, value, range) {

 	// "All of these methods must treat their command argument ASCII

 	// case-insensitively."

 	command = command.toLowerCase();

 	// "If only one argument was provided, let show UI be false."

 	//

 	// If range was passed, I can't actually detect how many args were passed

 	// . . .

 	if (arguments.length == 1

 	|| (arguments.length >=4 && typeof showUi == "undefined")) {

 		showUi = false;

 	}

 	// "If only one or two arguments were provided, let value be the empty

 	// string."

 	if (arguments.length <= 2

 	|| (arguments.length >=4 && typeof value == "undefined")) {

 		value = "";

 	}

 	return editCommandMethod(command, range, (function(command, showUi, value) { return function() {

 		// "If command is not supported or not enabled, return false."

 		if (!(command in commands) || !myQueryCommandEnabled(command)) {

 			return false;

 		}

 		// "Take the action for command, passing value to the instructions as an

 		// argument."

 		var ret = commands[command].action(value);

 		// Check for bugs

 		if (ret !== true && ret !== false) {

 			throw "execCommand() didn't return true or false: " + ret;

 		}

 		// "If the previous step returned false, return false."

 		if (ret === false) {

 			return false;

 		}

 		// "Return true."

 		return true;

 	}})(command, showUi, value));

 }

 function myQueryCommandEnabled(command, range) {

 	// "All of these methods must treat their command argument ASCII

 	// case-insensitively."

 	command = command.toLowerCase();

 	return editCommandMethod(command, range, (function(command) { return function() {

 		// "Return true if command is both supported and enabled, false

 		// otherwise."

 		if (!(command in commands)) {

 			return false;

 		}

 		// "Among commands defined in this specification, those listed in

 		// Miscellaneous commands are always enabled, except for the cut

 		// command and the paste command. The other commands defined here are

 		// enabled if the active range is not null, its start node is either

 		// editable or an editing host, its end node is either editable or an

 		// editing host, and there is some editing host that is an inclusive

 		// ancestor of both its start node and its end node."

 		return ["copy", "defaultparagraphseparator", "selectall", "stylewithcss",

 		"usecss"].indexOf(command) != -1

 			|| (

 				getActiveRange() !== null

 				&& (isEditable(getActiveRange().startContainer) || isEditingHost(getActiveRange().startContainer))

 				&& (isEditable(getActiveRange().endContainer) || isEditingHost(getActiveRange().endContainer))

 				&& (getInclusiveAncestors(getActiveRange().commonAncestorContainer).some(isEditingHost))

 			);

 	}})(command));

 }

 function myQueryCommandIndeterm(command, range) {

 	// "All of these methods must treat their command argument ASCII

 	// case-insensitively."

 	command = command.toLowerCase();

 	return editCommandMethod(command, range, (function(command) { return function() {

 		// "If command is not supported or has no indeterminacy, return false."

 		if (!(command in commands) || !("indeterm" in commands[command])) {

 			return false;

 		}

 		// "Return true if command is indeterminate, otherwise false."

 		return commands[command].indeterm();

 	}})(command));

 }

 function myQueryCommandState(command, range) {

 	// "All of these methods must treat their command argument ASCII

 	// case-insensitively."

 	command = command.toLowerCase();

 	return editCommandMethod(command, range, (function(command) { return function() {

 		// "If command is not supported or has no state, return false."

 		if (!(command in commands) || !("state" in commands[command])) {

 			return false;

 		}

 		// "If the state override for command is set, return it."

 		if (typeof getStateOverride(command) != "undefined") {

 			return getStateOverride(command);

 		}

 		// "Return true if command's state is true, otherwise false."

 		return commands[command].state();

 	}})(command));

 }

 // "When the queryCommandSupported(command) method on the HTMLDocument

 // interface is invoked, the user agent must return true if command is

 // supported, and false otherwise."

 function myQueryCommandSupported(command) {

 	// "All of these methods must treat their command argument ASCII

 	// case-insensitively."

 	command = command.toLowerCase();

 	return command in commands;

 }

 function myQueryCommandValue(command, range) {

 	// "All of these methods must treat their command argument ASCII

 	// case-insensitively."

 	command = command.toLowerCase();

 	return editCommandMethod(command, range, function() {

 		// "If command is not supported or has no value, return the empty string."

 		if (!(command in commands) || !("value" in commands[command])) {

 			return "";

 		}

 		// "If command is "fontSize" and its value override is set, convert the

 		// value override to an integer number of pixels and return the legacy

 		// font size for the result."

 		if (command == "fontsize"

 		&& getValueOverride("fontsize") !== undefined) {

 			return getLegacyFontSize(getValueOverride("fontsize"));

 		}

 		// "If the value override for command is set, return it."

 		if (typeof getValueOverride(command) != "undefined") {

 			return getValueOverride(command);

 		}

 		// "Return command's value."

 		return commands[command].value();

 	});

 }

 //@}

 //////////////////////////////

 ///// Common definitions /////

 //////////////////////////////

 //@{

 // "An HTML element is an Element whose namespace is the HTML namespace."

 //

 // I allow an extra argument to more easily check whether something is a

 // particular HTML element, like isHtmlElement(node, "OL").  It accepts arrays

 // too, like isHtmlElement(node, ["OL", "UL"]) to check if it's an ol or ul.

 function isHtmlElement(node, tags) {

 	if (typeof tags == "string") {

 		tags = [tags];

 	}

 	if (typeof tags == "object") {

 		tags = tags.map(function(tag) { return tag.toUpperCase() });

 	}

 	return node

 		&& node.nodeType == Node.ELEMENT_NODE

 		&& isHtmlNamespace(node.namespaceURI)

 		&& (typeof tags == "undefined" || tags.indexOf(node.tagName) != -1);

 }

 // "A prohibited paragraph child name is "address", "article", "aside",

 // "blockquote", "caption", "center", "col", "colgroup", "dd", "details",

 // "dir", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer",

 // "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "li",

 // "listing", "menu", "nav", "ol", "p", "plaintext", "pre", "section",

 // "summary", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "ul", or

 // "xmp"."

 var prohibitedParagraphChildNames = ["address", "article", "aside",

 	"blockquote", "caption", "center", "col", "colgroup", "dd", "details",

 	"dir", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer",

 	"form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "li",

 	"listing", "menu", "nav", "ol", "p", "plaintext", "pre", "section",

 	"summary", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "ul",

 	"xmp"];

 // "A prohibited paragraph child is an HTML element whose local name is a

 // prohibited paragraph child name."

 function isProhibitedParagraphChild(node) {

 	return isHtmlElement(node, prohibitedParagraphChildNames);

 }

 // "A block node is either an Element whose "display" property does not have

 // resolved value "inline" or "inline-block" or "inline-table" or "none", or a

 // Document, or a DocumentFragment."

 function isBlockNode(node) {

 	return node

 		&& ((node.nodeType == Node.ELEMENT_NODE && ["inline", "inline-block", "inline-table", "none"].indexOf(getComputedStyle(node).display) == -1)

 		|| node.nodeType == Node.DOCUMENT_NODE

 		|| node.nodeType == Node.DOCUMENT_FRAGMENT_NODE);

 }

 // "An inline node is a node that is not a block node."

 function isInlineNode(node) {

 	return node && !isBlockNode(node);

 }

 // "An editing host is a node that is either an HTML element with a

 // contenteditable attribute set to the true state, or the HTML element child

 // of a Document whose designMode is enabled."

 function isEditingHost(node) {

 	return node

 		&& isHtmlElement(node)

 		&& (node.contentEditable == "true"

 		|| (node.parentNode

 		&& node.parentNode.nodeType == Node.DOCUMENT_NODE

 		&& node.parentNode.designMode == "on"));

 }

 // "Something is editable if it is a node; it is not an editing host; it does

 // not have a contenteditable attribute set to the false state; its parent is

 // an editing host or editable; and either it is an HTML element, or it is an

 // svg or math element, or it is not an Element and its parent is an HTML

 // element."

 function isEditable(node) {

 	return node

 		&& !isEditingHost(node)

 		&& (node.nodeType != Node.ELEMENT_NODE || node.contentEditable != "false")

 		&& (isEditingHost(node.parentNode) || isEditable(node.parentNode))

 		&& (isHtmlElement(node)

 		|| (node.nodeType == Node.ELEMENT_NODE && node.namespaceURI == "http://www.w3.org/2000/svg" && node.localName == "svg")

 		|| (node.nodeType == Node.ELEMENT_NODE && node.namespaceURI == "http://www.w3.org/1998/Math/MathML" && node.localName == "math")

 		|| (node.nodeType != Node.ELEMENT_NODE && isHtmlElement(node.parentNode)));

 }

 // Helper function, not defined in the spec

 function hasEditableDescendants(node) {

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

 		if (isEditable(node.childNodes[i])

 		|| hasEditableDescendants(node.childNodes[i])) {

 			return true;

 		}

 	}

 	return false;

 }

 // "The editing host of node is null if node is neither editable nor an editing

 // host; node itself, if node is an editing host; or the nearest ancestor of

 // node that is an editing host, if node is editable."

 function getEditingHostOf(node) {

 	if (isEditingHost(node)) {

 		return node;

 	} else if (isEditable(node)) {

 		var ancestor = node.parentNode;

 		while (!isEditingHost(ancestor)) {

 			ancestor = ancestor.parentNode;

 		}

 		return ancestor;

 	} else {

 		return null;

 	}

 }

 // "Two nodes are in the same editing host if the editing host of the first is

 // non-null and the same as the editing host of the second."

 function inSameEditingHost(node1, node2) {

 	return getEditingHostOf(node1)

 		&& getEditingHostOf(node1) == getEditingHostOf(node2);

 }

 // "A collapsed line break is a br that begins a line box which has nothing

 // else in it, and therefore has zero height."

 function isCollapsedLineBreak(br) {

 	if (!isHtmlElement(br, "br")) {

 		return false;

 	}

 	// Add a zwsp after it and see if that changes the height of the nearest

 	// non-inline parent.  Note: this is not actually reliable, because the

 	// parent might have a fixed height or something.

 	var ref = br.parentNode;

 	while (getComputedStyle(ref).display == "inline") {

 		ref = ref.parentNode;

 	}

 	var refStyle = ref.hasAttribute("style") ? ref.getAttribute("style") : null;

 	ref.style.height = "auto";

 	ref.style.maxHeight = "none";

 	ref.style.minHeight = "0";

 	var space = document.createTextNode("\u200b");

 	var origHeight = ref.offsetHeight;

 	if (origHeight == 0) {

 		throw "isCollapsedLineBreak: original height is zero, bug?";

 	}

 	br.parentNode.insertBefore(space, br.nextSibling);

 	var finalHeight = ref.offsetHeight;

 	space.parentNode.removeChild(space);

 	if (refStyle === null) {

 		// Without the setAttribute() line, removeAttribute() doesn't work in

 		// Chrome 14 dev.  I have no idea why.

 		ref.setAttribute("style", "");

 		ref.removeAttribute("style");

 	} else {

 		ref.setAttribute("style", refStyle);

 	}

 	// Allow some leeway in case the zwsp didn't create a whole new line, but

 	// only made an existing line slightly higher.  Firefox 6.0a2 shows this

 	// behavior when the first line is bold.

 	return origHeight < finalHeight - 5;

 }

 // "An extraneous line break is a br that has no visual effect, in that

 // removing it from the DOM would not change layout, except that a br that is

 // the sole child of an li is not extraneous."

 //

 // FIXME: This doesn't work in IE, since IE ignores display: none in

 // contenteditable.

 function isExtraneousLineBreak(br) {

 	if (!isHtmlElement(br, "br")) {

 		return false;

 	}

 	if (isHtmlElement(br.parentNode, "li")

 	&& br.parentNode.childNodes.length == 1) {

 		return false;

 	}

 	// Make the line break disappear and see if that changes the block's

 	// height.  Yes, this is an absurd hack.  We have to reset height etc. on

 	// the reference node because otherwise its height won't change if it's not

 	// auto.

 	var ref = br.parentNode;

 	while (getComputedStyle(ref).display == "inline") {

 		ref = ref.parentNode;

 	}

 	var refStyle = ref.hasAttribute("style") ? ref.getAttribute("style") : null;

 	ref.style.height = "auto";

 	ref.style.maxHeight = "none";

 	ref.style.minHeight = "0";

 	var brStyle = br.hasAttribute("style") ? br.getAttribute("style") : null;

 	var origHeight = ref.offsetHeight;

 	if (origHeight == 0) {

 		throw "isExtraneousLineBreak: original height is zero, bug?";

 	}

 	br.setAttribute("style", "display:none");

 	var finalHeight = ref.offsetHeight;

 	if (refStyle === null) {

 		// Without the setAttribute() line, removeAttribute() doesn't work in

 		// Chrome 14 dev.  I have no idea why.

 		ref.setAttribute("style", "");

 		ref.removeAttribute("style");

 	} else {

 		ref.setAttribute("style", refStyle);

 	}

 	if (brStyle === null) {

 		br.removeAttribute("style");

 	} else {

 		br.setAttribute("style", brStyle);

 	}

 	return origHeight == finalHeight;

 }

 // "A whitespace node is either a Text node whose data is the empty string; or

 // a Text node whose data consists only of one or more tabs (0x0009), line

 // feeds (0x000A), carriage returns (0x000D), and/or spaces (0x0020), and whose

 // parent is an Element whose resolved value for "white-space" is "normal" or

 // "nowrap"; or a Text node whose data consists only of one or more tabs

 // (0x0009), carriage returns (0x000D), and/or spaces (0x0020), and whose

 // parent is an Element whose resolved value for "white-space" is "pre-line"."

 function isWhitespaceNode(node) {

 	return node

 		&& node.nodeType == Node.TEXT_NODE

 		&& (node.data == ""

 		|| (

 			/^[\t\n\r ]+$/.test(node.data)

 			&& node.parentNode

 			&& node.parentNode.nodeType == Node.ELEMENT_NODE

 			&& ["normal", "nowrap"].indexOf(getComputedStyle(node.parentNode).whiteSpace) != -1

 		) || (

 			/^[\t\r ]+$/.test(node.data)

 			&& node.parentNode

 			&& node.parentNode.nodeType == Node.ELEMENT_NODE

 			&& getComputedStyle(node.parentNode).whiteSpace == "pre-line"

 		));

 }

 // "node is a collapsed whitespace node if the following algorithm returns

 // true:"

 function isCollapsedWhitespaceNode(node) {

 	// "If node is not a whitespace node, return false."

 	if (!isWhitespaceNode(node)) {

 		return false;

 	}

 	// "If node's data is the empty string, return true."

 	if (node.data == "") {

 		return true;

 	}

 	// "Let ancestor be node's parent."

 	var ancestor = node.parentNode;

 	// "If ancestor is null, return true."

 	if (!ancestor) {

 		return true;

 	}

 	// "If the "display" property of some ancestor of node has resolved value

 	// "none", return true."

 	if (getAncestors(node).some(function(ancestor) {

 		return ancestor.nodeType == Node.ELEMENT_NODE

 			&& getComputedStyle(ancestor).display == "none";

 	})) {

 		return true;

 	}

 	// "While ancestor is not a block node and its parent is not null, set

 	// ancestor to its parent."

 	while (!isBlockNode(ancestor)

 	&& ancestor.parentNode) {

 		ancestor = ancestor.parentNode;

 	}

 	// "Let reference be node."

 	var reference = node;

 	// "While reference is a descendant of ancestor:"

 	while (reference != ancestor) {

 		// "Let reference be the node before it in tree order."

 		reference = previousNode(reference);

 		// "If reference is a block node or a br, return true."

 		if (isBlockNode(reference)

 		|| isHtmlElement(reference, "br")) {

 			return true;

 		}

 		// "If reference is a Text node that is not a whitespace node, or is an

 		// img, break from this loop."

 		if ((reference.nodeType == Node.TEXT_NODE && !isWhitespaceNode(reference))

 		|| isHtmlElement(reference, "img")) {

 			break;

 		}

 	}

 	// "Let reference be node."

 	reference = node;

 	// "While reference is a descendant of ancestor:"

 	var stop = nextNodeDescendants(ancestor);

 	while (reference != stop) {

 		// "Let reference be the node after it in tree order, or null if there

 		// is no such node."

 		reference = nextNode(reference);

 		// "If reference is a block node or a br, return true."

 		if (isBlockNode(reference)

 		|| isHtmlElement(reference, "br")) {

 			return true;

 		}

 		// "If reference is a Text node that is not a whitespace node, or is an

 		// img, break from this loop."

 		if ((reference && reference.nodeType == Node.TEXT_NODE && !isWhitespaceNode(reference))

 		|| isHtmlElement(reference, "img")) {

 			break;

 		}

 	}

 	// "Return false."

 	return false;

 }

 // "Something is visible if it is a node that either is a block node, or a Text

 // node that is not a collapsed whitespace node, or an img, or a br that is not

 // an extraneous line break, or any node with a visible descendant; excluding

 // any node with an ancestor container Element whose "display" property has

 // resolved value "none"."

 function isVisible(node) {

 	if (!node) {

 		return false;

 	}

 	if (getAncestors(node).concat(node)

 	.filter(function(node) { return node.nodeType == Node.ELEMENT_NODE })

 	.some(function(node) { return getComputedStyle(node).display == "none" })) {

 		return false;

 	}

 	if (isBlockNode(node)

 	|| (node.nodeType == Node.TEXT_NODE && !isCollapsedWhitespaceNode(node))

 	|| isHtmlElement(node, "img")

 	|| (isHtmlElement(node, "br") && !isExtraneousLineBreak(node))) {

 		return true;

 	}

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

 		if (isVisible(node.childNodes[i])) {

 			return true;

 		}

 	}

 	return false;

 }

 // "Something is invisible if it is a node that is not visible."

 function isInvisible(node) {

 	return node && !isVisible(node);

 }

 // "A collapsed block prop is either a collapsed line break that is not an

 // extraneous line break, or an Element that is an inline node and whose

 // children are all either invisible or collapsed block props and that has at

 // least one child that is a collapsed block prop."

 function isCollapsedBlockProp(node) {

 	if (isCollapsedLineBreak(node)

 	&& !isExtraneousLineBreak(node)) {

 		return true;

 	}

 	if (!isInlineNode(node)

 	|| node.nodeType != Node.ELEMENT_NODE) {

 		return false;

 	}

 	var hasCollapsedBlockPropChild = false;

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

 		if (!isInvisible(node.childNodes[i])

 		&& !isCollapsedBlockProp(node.childNodes[i])) {

 			return false;

 		}

 		if (isCollapsedBlockProp(node.childNodes[i])) {

 			hasCollapsedBlockPropChild = true;

 		}

 	}

 	return hasCollapsedBlockPropChild;

 }

 // "The active range is the range of the selection given by calling

 // getSelection() on the context object. (Thus the active range may be null.)"

 //

 // We cheat and return globalRange if that's defined.  We also ensure that the

 // active range meets the requirements that selection boundary points are

 // supposed to meet, i.e., that the nodes are both Text or Element nodes that

 // descend from a Document.

 function getActiveRange() {

 	var ret;

 	if (globalRange) {

 		ret = globalRange;

 	} else if (getSelection().rangeCount) {

 		ret = getSelection().getRangeAt(0);

 	} else {

 		return null;

 	}

 	if ([Node.TEXT_NODE, Node.ELEMENT_NODE].indexOf(ret.startContainer.nodeType) == -1

 	|| [Node.TEXT_NODE, Node.ELEMENT_NODE].indexOf(ret.endContainer.nodeType) == -1

 	|| !ret.startContainer.ownerDocument

 	|| !ret.endContainer.ownerDocument

 	|| !isDescendant(ret.startContainer, ret.startContainer.ownerDocument)

 	|| !isDescendant(ret.endContainer, ret.endContainer.ownerDocument)) {

 		throw "Invalid active range; test bug?";

 	}

 	return ret;

 }

 // "For some commands, each HTMLDocument must have a boolean state override

 // and/or a string value override. These do not change the command's state or

 // value, but change the way some algorithms behave, as specified in those

 // algorithms' definitions. Initially, both must be unset for every command.

 // Whenever the number of ranges in the Selection changes to something

 // different, and whenever a boundary point of the range at a given index in

 // the Selection changes to something different, the state override and value

 // override must be unset for every command."

 //

 // We implement this crudely by using setters and getters.  To verify that the

 // selection hasn't changed, we copy the active range and just check the

 // endpoints match.  This isn't really correct, but it's good enough for us.

 // Unset state/value overrides are undefined.  We put everything in a function

 // so no one can access anything except via the provided functions, since

 // otherwise callers might mistakenly use outdated overrides (if the selection

 // has changed).

 var getStateOverride, setStateOverride, unsetStateOverride,

 	getValueOverride, setValueOverride, unsetValueOverride;

 (function() {

 	var stateOverrides = {};

 	var valueOverrides = {};

 	var storedRange = null;

 	function resetOverrides() {

 		if (!storedRange

 		|| storedRange.startContainer != getActiveRange().startContainer

 		|| storedRange.endContainer != getActiveRange().endContainer

 		|| storedRange.startOffset != getActiveRange().startOffset

 		|| storedRange.endOffset != getActiveRange().endOffset) {

 			stateOverrides = {};

 			valueOverrides = {};

 			storedRange = getActiveRange().cloneRange();

 		}

 	}

 	getStateOverride = function(command) {

 		resetOverrides();

 		return stateOverrides[command];

 	};

 	setStateOverride = function(command, newState) {

 		resetOverrides();

 		stateOverrides[command] = newState;

 	};

 	unsetStateOverride = function(command) {

 		resetOverrides();

 		delete stateOverrides[command];

 	}

 	getValueOverride = function(command) {

 		resetOverrides();

 		return valueOverrides[command];

 	}

 	// "The value override for the backColor command must be the same as the

 	// value override for the hiliteColor command, such that setting one sets

 	// the other to the same thing and unsetting one unsets the other."

 	setValueOverride = function(command, newValue) {

 		resetOverrides();

 		valueOverrides[command] = newValue;

 		if (command == "backcolor") {

 			valueOverrides.hilitecolor = newValue;

 		} else if (command == "hilitecolor") {

 			valueOverrides.backcolor = newValue;

 		}

 	}

 	unsetValueOverride = function(command) {

 		resetOverrides();

 		delete valueOverrides[command];

 		if (command == "backcolor") {

 			delete valueOverrides.hilitecolor;

 		} else if (command == "hilitecolor") {

 			delete valueOverrides.backcolor;

 		}

 	}

 })();

 //@}

 /////////////////////////////

 ///// Common algorithms /////

 /////////////////////////////

 ///// Assorted common algorithms /////

 //@{

 // Magic array of extra ranges whose endpoints we want to preserve.

 var extraRanges = [];

 function movePreservingRanges(node, newParent, newIndex) {

 	// For convenience, I allow newIndex to be -1 to mean "insert at the end".

 	if (newIndex == -1) {

 		newIndex = newParent.childNodes.length;

 	}

 	// "When the user agent is to move a Node to a new location, preserving

 	// ranges, it must remove the Node from its original parent (if any), then

 	// insert it in the new location. In doing so, however, it must ignore the

 	// regular range mutation rules, and instead follow these rules:"

 	// "Let node be the moved Node, old parent and old index be the old parent

 	// (which may be null) and index, and new parent and new index be the new

 	// parent and index."

 	var oldParent = node.parentNode;

 	var oldIndex = getNodeIndex(node);

 	// We preserve the global range object, the ranges in the selection, and

 	// any range that's in the extraRanges array.  Any other ranges won't get

 	// updated, because we have no references to them.

 	var ranges = [globalRange].concat(extraRanges);

 	for (var i = 0; i < getSelection().rangeCount; i++) {

 		ranges.push(getSelection().getRangeAt(i));

 	}

 	var boundaryPoints = [];

 	ranges.forEach(function(range) {

 		boundaryPoints.push([range.startContainer, range.startOffset]);

 		boundaryPoints.push([range.endContainer, range.endOffset]);

 	});

 	boundaryPoints.forEach(function(boundaryPoint) {

 		// "If a boundary point's node is the same as or a descendant of node,

 		// leave it unchanged, so it moves to the new location."

 		//

 		// No modifications necessary.

 		// "If a boundary point's node is new parent and its offset is greater

 		// than new index, add one to its offset."

 		if (boundaryPoint[0] == newParent

 		&& boundaryPoint[1] > newIndex) {

 			boundaryPoint[1]++;

 		}

 		// "If a boundary point's node is old parent and its offset is old index or

 		// old index + 1, set its node to new parent and add new index − old index

 		// to its offset."

 		if (boundaryPoint[0] == oldParent

 		&& (boundaryPoint[1] == oldIndex

 		|| boundaryPoint[1] == oldIndex + 1)) {

 			boundaryPoint[0] = newParent;

 			boundaryPoint[1] += newIndex - oldIndex;

 		}

 		// "If a boundary point's node is old parent and its offset is greater than

 		// old index + 1, subtract one from its offset."

 		if (boundaryPoint[0] == oldParent

 		&& boundaryPoint[1] > oldIndex + 1) {

 			boundaryPoint[1]--;

 		}

 	});

 	// Now actually move it and preserve the ranges.

 	if (newParent.childNodes.length == newIndex) {

 		newParent.appendChild(node);

 	} else {

 		newParent.insertBefore(node, newParent.childNodes[newIndex]);

 	}

 	globalRange.setStart(boundaryPoints[0][0], boundaryPoints[0][1]);

 	globalRange.setEnd(boundaryPoints[1][0], boundaryPoints[1][1]);

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

 		extraRanges[i].setStart(boundaryPoints[2*i + 2][0], boundaryPoints[2*i + 2][1]);

 		extraRanges[i].setEnd(boundaryPoints[2*i + 3][0], boundaryPoints[2*i + 3][1]);

 	}

 	getSelection().removeAllRanges();

 	for (var i = 1 + extraRanges.length; i < ranges.length; i++) {

 		var newRange = document.createRange();

 		newRange.setStart(boundaryPoints[2*i][0], boundaryPoints[2*i][1]);

 		newRange.setEnd(boundaryPoints[2*i + 1][0], boundaryPoints[2*i + 1][1]);

 		getSelection().addRange(newRange);

 	}

 }

 function setTagName(element, newName) {

 	// "If element is an HTML element with local name equal to new name, return

 	// element."

 	if (isHtmlElement(element, newName.toUpperCase())) {

 		return element;

 	}

 	// "If element's parent is null, return element."

 	if (!element.parentNode) {

 		return element;

 	}

 	// "Let replacement element be the result of calling createElement(new

 	// name) on the ownerDocument of element."

 	var replacementElement = element.ownerDocument.createElement(newName);

 	// "Insert replacement element into element's parent immediately before

 	// element."

 	element.parentNode.insertBefore(replacementElement, element);

 	// "Copy all attributes of element to replacement element, in order."

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

 		replacementElement.setAttributeNS(element.attributes[i].namespaceURI, element.attributes[i].name, element.attributes[i].value);

 	}

 	// "While element has children, append the first child of element as the

 	// last child of replacement element, preserving ranges."

 	while (element.childNodes.length) {

 		movePreservingRanges(element.firstChild, replacementElement, replacementElement.childNodes.length);

 	}

 	// "Remove element from its parent."

 	element.parentNode.removeChild(element);

 	// "Return replacement element."

 	return replacementElement;

 }

 function removeExtraneousLineBreaksBefore(node) {

 	// "Let ref be the previousSibling of node."

 	var ref = node.previousSibling;

 	// "If ref is null, abort these steps."

 	if (!ref) {

 		return;

 	}

 	// "While ref has children, set ref to its lastChild."

 	while (ref.hasChildNodes()) {

 		ref = ref.lastChild;

 	}

 	// "While ref is invisible but not an extraneous line break, and ref does

 	// not equal node's parent, set ref to the node before it in tree order."

 	while (isInvisible(ref)

 	&& !isExtraneousLineBreak(ref)

 	&& ref != node.parentNode) {

 		ref = previousNode(ref);

 	}

 	// "If ref is an editable extraneous line break, remove it from its

 	// parent."

 	if (isEditable(ref)

 	&& isExtraneousLineBreak(ref)) {

 		ref.parentNode.removeChild(ref);

 	}

 }

 function removeExtraneousLineBreaksAtTheEndOf(node) {

 	// "Let ref be node."

 	var ref = node;

 	// "While ref has children, set ref to its lastChild."

 	while (ref.hasChildNodes()) {

 		ref = ref.lastChild;

 	}

 	// "While ref is invisible but not an extraneous line break, and ref does

 	// not equal node, set ref to the node before it in tree order."

 	while (isInvisible(ref)

 	&& !isExtraneousLineBreak(ref)

 	&& ref != node) {

 		ref = previousNode(ref);

 	}

 	// "If ref is an editable extraneous line break:"

 	if (isEditable(ref)

 	&& isExtraneousLineBreak(ref)) {

 		// "While ref's parent is editable and invisible, set ref to its

 		// parent."

 		while (isEditable(ref.parentNode)

 		&& isInvisible(ref.parentNode)) {

 			ref = ref.parentNode;

 		}

 		// "Remove ref from its parent."

 		ref.parentNode.removeChild(ref);

 	}

 }

 // "To remove extraneous line breaks from a node, first remove extraneous line

 // breaks before it, then remove extraneous line breaks at the end of it."

 function removeExtraneousLineBreaksFrom(node) {

 	removeExtraneousLineBreaksBefore(node);

 	removeExtraneousLineBreaksAtTheEndOf(node);

 }

 //@}

 ///// Wrapping a list of nodes /////

 //@{

 function wrap(nodeList, siblingCriteria, newParentInstructions) {

 	// "If not provided, sibling criteria returns false and new parent

 	// instructions returns null."

 	if (typeof siblingCriteria == "undefined") {

 		siblingCriteria = function() { return false };

 	}

 	if (typeof newParentInstructions == "undefined") {

 		newParentInstructions = function() { return null };

 	}

 	// "If every member of node list is invisible, and none is a br, return

 	// null and abort these steps."

 	if (nodeList.every(isInvisible)

 	&& !nodeList.some(function(node) { return isHtmlElement(node, "br") })) {

 		return null;

 	}

 	// "If node list's first member's parent is null, return null and abort

 	// these steps."

 	if (!nodeList[0].parentNode) {

 		return null;

 	}

 	// "If node list's last member is an inline node that's not a br, and node

 	// list's last member's nextSibling is a br, append that br to node list."

 	if (isInlineNode(nodeList[nodeList.length - 1])

 	&& !isHtmlElement(nodeList[nodeList.length - 1], "br")

 	&& isHtmlElement(nodeList[nodeList.length - 1].nextSibling, "br")) {

 		nodeList.push(nodeList[nodeList.length - 1].nextSibling);

 	}

 	// "While node list's first member's previousSibling is invisible, prepend

 	// it to node list."

 	while (isInvisible(nodeList[0].previousSibling)) {

 		nodeList.unshift(nodeList[0].previousSibling);

 	}

 	// "While node list's last member's nextSibling is invisible, append it to

 	// node list."

 	while (isInvisible(nodeList[nodeList.length - 1].nextSibling)) {

 		nodeList.push(nodeList[nodeList.length - 1].nextSibling);

 	}

 	// "If the previousSibling of the first member of node list is editable and

 	// running sibling criteria on it returns true, let new parent be the

 	// previousSibling of the first member of node list."

 	var newParent;

 	if (isEditable(nodeList[0].previousSibling)

 	&& siblingCriteria(nodeList[0].previousSibling)) {

 		newParent = nodeList[0].previousSibling;

 	// "Otherwise, if the nextSibling of the last member of node list is

 	// editable and running sibling criteria on it returns true, let new parent

 	// be the nextSibling of the last member of node list."

 	} else if (isEditable(nodeList[nodeList.length - 1].nextSibling)

 	&& siblingCriteria(nodeList[nodeList.length - 1].nextSibling)) {

 		newParent = nodeList[nodeList.length - 1].nextSibling;

 	// "Otherwise, run new parent instructions, and let new parent be the

 	// result."

 	} else {

 		newParent = newParentInstructions();

 	}

 	// "If new parent is null, abort these steps and return null."

 	if (!newParent) {

 		return null;

 	}

 	// "If new parent's parent is null:"

 	if (!newParent.parentNode) {

 		// "Insert new parent into the parent of the first member of node list

 		// immediately before the first member of node list."

 		nodeList[0].parentNode.insertBefore(newParent, nodeList[0]);

 		// "If any range has a boundary point with node equal to the parent of

 		// new parent and offset equal to the index of new parent, add one to

 		// that boundary point's offset."

 		//

 		// Only try to fix the global range.

 		if (globalRange.startContainer == newParent.parentNode

 		&& globalRange.startOffset == getNodeIndex(newParent)) {

 			globalRange.setStart(globalRange.startContainer, globalRange.startOffset + 1);

 		}

 		if (globalRange.endContainer == newParent.parentNode

 		&& globalRange.endOffset == getNodeIndex(newParent)) {

 			globalRange.setEnd(globalRange.endContainer, globalRange.endOffset + 1);

 		}

 	}

 	// "Let original parent be the parent of the first member of node list."

 	var originalParent = nodeList[0].parentNode;

 	// "If new parent is before the first member of node list in tree order:"

 	if (isBefore(newParent, nodeList[0])) {

 		// "If new parent is not an inline node, but the last visible child of

 		// new parent and the first visible member of node list are both inline

 		// nodes, and the last child of new parent is not a br, call

 		// createElement("br") on the ownerDocument of new parent and append

 		// the result as the last child of new parent."

 		if (!isInlineNode(newParent)

 		&& isInlineNode([].filter.call(newParent.childNodes, isVisible).slice(-1)[0])

 		&& isInlineNode(nodeList.filter(isVisible)[0])

 		&& !isHtmlElement(newParent.lastChild, "BR")) {

 			newParent.appendChild(newParent.ownerDocument.createElement("br"));

 		}

 		// "For each node in node list, append node as the last child of new

 		// parent, preserving ranges."

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

 			movePreservingRanges(nodeList[i], newParent, -1);

 		}

 	// "Otherwise:"

 	} else {

 		// "If new parent is not an inline node, but the first visible child of

 		// new parent and the last visible member of node list are both inline

 		// nodes, and the last member of node list is not a br, call

 		// createElement("br") on the ownerDocument of new parent and insert

 		// the result as the first child of new parent."

 		if (!isInlineNode(newParent)

 		&& isInlineNode([].filter.call(newParent.childNodes, isVisible)[0])

 		&& isInlineNode(nodeList.filter(isVisible).slice(-1)[0])

 		&& !isHtmlElement(nodeList[nodeList.length - 1], "BR")) {

 			newParent.insertBefore(newParent.ownerDocument.createElement("br"), newParent.firstChild);

 		}

 		// "For each node in node list, in reverse order, insert node as the

 		// first child of new parent, preserving ranges."

 		for (var i = nodeList.length - 1; i >= 0; i--) {

 			movePreservingRanges(nodeList[i], newParent, 0);

 		}

 	}

 	// "If original parent is editable and has no children, remove it from its

 	// parent."

 	if (isEditable(originalParent) && !originalParent.hasChildNodes()) {

 		originalParent.parentNode.removeChild(originalParent);

 	}

 	// "If new parent's nextSibling is editable and running sibling criteria on

 	// it returns true:"

 	if (isEditable(newParent.nextSibling)

 	&& siblingCriteria(newParent.nextSibling)) {

 		// "If new parent is not an inline node, but new parent's last child

 		// and new parent's nextSibling's first child are both inline nodes,

 		// and new parent's last child is not a br, call createElement("br") on

 		// the ownerDocument of new parent and append the result as the last

 		// child of new parent."

 		if (!isInlineNode(newParent)

 		&& isInlineNode(newParent.lastChild)

 		&& isInlineNode(newParent.nextSibling.firstChild)

 		&& !isHtmlElement(newParent.lastChild, "BR")) {

 			newParent.appendChild(newParent.ownerDocument.createElement("br"));

 		}

 		// "While new parent's nextSibling has children, append its first child

 		// as the last child of new parent, preserving ranges."

 		while (newParent.nextSibling.hasChildNodes()) {

 			movePreservingRanges(newParent.nextSibling.firstChild, newParent, -1);

 		}

 		// "Remove new parent's nextSibling from its parent."

 		newParent.parentNode.removeChild(newParent.nextSibling);

 	}

 	// "Remove extraneous line breaks from new parent."

 	removeExtraneousLineBreaksFrom(newParent);

 	// "Return new parent."

 	return newParent;

 }

 //@}

 ///// Allowed children /////

 //@{

 // "A name of an element with inline contents is "a", "abbr", "b", "bdi",

 // "bdo", "cite", "code", "dfn", "em", "h1", "h2", "h3", "h4", "h5", "h6", "i",

 // "kbd", "mark", "p", "pre", "q", "rp", "rt", "ruby", "s", "samp", "small",

 // "span", "strong", "sub", "sup", "u", "var", "acronym", "listing", "strike",

 // "xmp", "big", "blink", "font", "marquee", "nobr", or "tt"."

 var namesOfElementsWithInlineContents = ["a", "abbr", "b", "bdi", "bdo",

 	"cite", "code", "dfn", "em", "h1", "h2", "h3", "h4", "h5", "h6", "i",

 	"kbd", "mark", "p", "pre", "q", "rp", "rt", "ruby", "s", "samp", "small",

 	"span", "strong", "sub", "sup", "u", "var", "acronym", "listing", "strike",

 	"xmp", "big", "blink", "font", "marquee", "nobr", "tt"];

 // "An element with inline contents is an HTML element whose local name is a

 // name of an element with inline contents."

 function isElementWithInlineContents(node) {

 	return isHtmlElement(node, namesOfElementsWithInlineContents);

 }

 function isAllowedChild(child, parent_) {

 	// "If parent is "colgroup", "table", "tbody", "tfoot", "thead", "tr", or

 	// an HTML element with local name equal to one of those, and child is a

 	// Text node whose data does not consist solely of space characters, return

 	// false."

 	if ((["colgroup", "table", "tbody", "tfoot", "thead", "tr"].indexOf(parent_) != -1

 	|| isHtmlElement(parent_, ["colgroup", "table", "tbody", "tfoot", "thead", "tr"]))

 	&& typeof child == "object"

 	&& child.nodeType == Node.TEXT_NODE

 	&& !/^[ \t\n\f\r]*$/.test(child.data)) {

 		return false;

 	}

 	// "If parent is "script", "style", "plaintext", or "xmp", or an HTML

 	// element with local name equal to one of those, and child is not a Text

 	// node, return false."

 	if ((["script", "style", "plaintext", "xmp"].indexOf(parent_) != -1

 	|| isHtmlElement(parent_, ["script", "style", "plaintext", "xmp"]))

 	&& (typeof child != "object" || child.nodeType != Node.TEXT_NODE)) {

 		return false;

 	}

 	// "If child is a Document, DocumentFragment, or DocumentType, return

 	// false."

 	if (typeof child == "object"

 	&& (child.nodeType == Node.DOCUMENT_NODE

 	|| child.nodeType == Node.DOCUMENT_FRAGMENT_NODE

 	|| child.nodeType == Node.DOCUMENT_TYPE_NODE)) {

 		return false;

 	}

 	// "If child is an HTML element, set child to the local name of child."

 	if (isHtmlElement(child)) {

 		child = child.tagName.toLowerCase();

 	}

 	// "If child is not a string, return true."

 	if (typeof child != "string") {

 		return true;

 	}

 	// "If parent is an HTML element:"

 	if (isHtmlElement(parent_)) {

 		// "If child is "a", and parent or some ancestor of parent is an a,

 		// return false."

 		//

 		// "If child is a prohibited paragraph child name and parent or some

 		// ancestor of parent is an element with inline contents, return

 		// false."

 		//

 		// "If child is "h1", "h2", "h3", "h4", "h5", or "h6", and parent or

 		// some ancestor of parent is an HTML element with local name "h1",

 		// "h2", "h3", "h4", "h5", or "h6", return false."

 		var ancestor = parent_;

 		while (ancestor) {

 			if (child == "a" && isHtmlElement(ancestor, "a")) {

 				return false;

 			}

 			if (prohibitedParagraphChildNames.indexOf(child) != -1

 			&& isElementWithInlineContents(ancestor)) {

 				return false;

 			}

 			if (/^h[1-6]$/.test(child)

 			&& isHtmlElement(ancestor)

 			&& /^H[1-6]$/.test(ancestor.tagName)) {

 				return false;

 			}

 			ancestor = ancestor.parentNode;

 		}

 		// "Let parent be the local name of parent."

 		parent_ = parent_.tagName.toLowerCase();

 	}

 	// "If parent is an Element or DocumentFragment, return true."

 	if (typeof parent_ == "object"

 	&& (parent_.nodeType == Node.ELEMENT_NODE

 	|| parent_.nodeType == Node.DOCUMENT_FRAGMENT_NODE)) {

 		return true;

 	}

 	// "If parent is not a string, return false."

 	if (typeof parent_ != "string") {

 		return false;

 	}

 	// "If parent is on the left-hand side of an entry on the following list,

 	// then return true if child is listed on the right-hand side of that

 	// entry, and false otherwise."

 	switch (parent_) {

 		case "colgroup":

 			return child == "col";

 		case "table":

 			return ["caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"].indexOf(child) != -1;

 		case "tbody":

 		case "thead":

 		case "tfoot":

 			return ["td", "th", "tr"].indexOf(child) != -1;

 		case "tr":

 			return ["td", "th"].indexOf(child) != -1;

 		case "dl":

 			return ["dt", "dd"].indexOf(child) != -1;

 		case "dir":

 		case "ol":

 		case "ul":

 			return ["dir", "li", "ol", "ul"].indexOf(child) != -1;

 		case "hgroup":

 			return /^h[1-6]$/.test(child);

 	}

 	// "If child is "body", "caption", "col", "colgroup", "frame", "frameset",

 	// "head", "html", "tbody", "td", "tfoot", "th", "thead", or "tr", return

 	// false."

 	if (["body", "caption", "col", "colgroup", "frame", "frameset", "head",

 	"html", "tbody", "td", "tfoot", "th", "thead", "tr"].indexOf(child) != -1) {

 		return false;

 	}

 	// "If child is "dd" or "dt" and parent is not "dl", return false."

 	if (["dd", "dt"].indexOf(child) != -1

 	&& parent_ != "dl") {

 		return false;

 	}

 	// "If child is "li" and parent is not "ol" or "ul", return false."

 	if (child == "li"

 	&& parent_ != "ol"

 	&& parent_ != "ul") {

 		return false;

 	}

 	// "If parent is on the left-hand side of an entry on the following list

 	// and child is listed on the right-hand side of that entry, return false."

 	var table = [

 		[["a"], ["a"]],

 		[["dd", "dt"], ["dd", "dt"]],

 		[["h1", "h2", "h3", "h4", "h5", "h6"], ["h1", "h2", "h3", "h4", "h5", "h6"]],

 		[["li"], ["li"]],

 		[["nobr"], ["nobr"]],

 		[namesOfElementsWithInlineContents, prohibitedParagraphChildNames],

 		[["td", "th"], ["caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"]],

 	];

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

 		if (table[i][0].indexOf(parent_) != -1

 		&& table[i][1].indexOf(child) != -1) {

 			return false;

 		}

 	}

 	// "Return true."

 	return true;

 }

 //@}

 //////////////////////////////////////

 ///// Inline formatting commands /////

 //////////////////////////////////////

 ///// Inline formatting command definitions /////

 //@{

 // "A node node is effectively contained in a range range if range is not

 // collapsed, and at least one of the following holds:"

 function isEffectivelyContained(node, range) {

 	if (range.collapsed) {

 		return false;

 	}

 	// "node is contained in range."

 	if (isContained(node, range)) {

 		return true;

 	}

 	// "node is range's start node, it is a Text node, and its length is

 	// different from range's start offset."

 	if (node == range.startContainer

 	&& node.nodeType == Node.TEXT_NODE

 	&& getNodeLength(node) != range.startOffset) {

 		return true;

 	}

 	// "node is range's end node, it is a Text node, and range's end offset is

 	// not 0."

 	if (node == range.endContainer

 	&& node.nodeType == Node.TEXT_NODE

 	&& range.endOffset != 0) {

 		return true;

 	}

 	// "node has at least one child; and all its children are effectively

 	// contained in range; and either range's start node is not a descendant of

 	// node or is not a Text node or range's start offset is zero; and either

 	// range's end node is not a descendant of node or is not a Text node or

 	// range's end offset is its end node's length."

 	if (node.hasChildNodes()

 	&& [].every.call(node.childNodes, function(child) { return isEffectivelyContained(child, range) })

 	&& (!isDescendant(range.startContainer, node)

 	|| range.startContainer.nodeType != Node.TEXT_NODE

 	|| range.startOffset == 0)

 	&& (!isDescendant(range.endContainer, node)

 	|| range.endContainer.nodeType != Node.TEXT_NODE

 	|| range.endOffset == getNodeLength(range.endContainer))) {

 		return true;

 	}

 	return false;

 }

 // Like get(All)ContainedNodes(), but for effectively contained nodes.

 function getEffectivelyContainedNodes(range, condition) {

 	if (typeof condition == "undefined") {

 		condition = function() { return true };

 	}

 	var node = range.startContainer;

 	while (isEffectivelyContained(node.parentNode, range)) {

 		node = node.parentNode;

 	}

 	var stop = nextNodeDescendants(range.endContainer);

 	var nodeList = [];

 	while (isBefore(node, stop)) {

 		if (isEffectivelyContained(node, range)

 		&& condition(node)) {

 			nodeList.push(node);

 			node = nextNodeDescendants(node);

 			continue;

 		}

 		node = nextNode(node);

 	}

 	return nodeList;

 }

 function getAllEffectivelyContainedNodes(range, condition) {

 	if (typeof condition == "undefined") {

 		condition = function() { return true };

 	}

 	var node = range.startContainer;

 	while (isEffectivelyContained(node.parentNode, range)) {

 		node = node.parentNode;

 	}

 	var stop = nextNodeDescendants(range.endContainer);

 	var nodeList = [];

 	while (isBefore(node, stop)) {

 		if (isEffectivelyContained(node, range)

 		&& condition(node)) {

 			nodeList.push(node);

 		}

 		node = nextNode(node);

 	}

 	return nodeList;

 }

 // "A modifiable element is a b, em, i, s, span, strong, sub, sup, or u element

 // with no attributes except possibly style; or a font element with no

 // attributes except possibly style, color, face, and/or size; or an a element

 // with no attributes except possibly style and/or href."

 function isModifiableElement(node) {

 	if (!isHtmlElement(node)) {

 		return false;

 	}

 	if (["B", "EM", "I", "S", "SPAN", "STRIKE", "STRONG", "SUB", "SUP", "U"].indexOf(node.tagName) != -1) {

 		if (node.attributes.length == 0) {

 			return true;

 		}

 		if (node.attributes.length == 1

 		&& node.hasAttribute("style")) {

 			return true;

 		}

 	}

 	if (node.tagName == "FONT" || node.tagName == "A") {

 		var numAttrs = node.attributes.length;

 		if (node.hasAttribute("style")) {

 			numAttrs--;

 		}

 		if (node.tagName == "FONT") {

 			if (node.hasAttribute("color")) {

 				numAttrs--;

 			}

 			if (node.hasAttribute("face")) {

 				numAttrs--;

 			}

 			if (node.hasAttribute("size")) {

 				numAttrs--;

 			}

 		}

 		if (node.tagName == "A"

 		&& node.hasAttribute("href")) {

 			numAttrs--;

 		}

 		if (numAttrs == 0) {

 			return true;

 		}

 	}

 	return false;

 }

 function isSimpleModifiableElement(node) {

 	// "A simple modifiable element is an HTML element for which at least one

 	// of the following holds:"

 	if (!isHtmlElement(node)) {

 		return false;

 	}

 	// Only these elements can possibly be a simple modifiable element.

 	if (["A", "B", "EM", "FONT", "I", "S", "SPAN", "STRIKE", "STRONG", "SUB", "SUP", "U"].indexOf(node.tagName) == -1) {

 		return false;

 	}

 	// "It is an a, b, em, font, i, s, span, strike, strong, sub, sup, or u

 	// element with no attributes."

 	if (node.attributes.length == 0) {

 		return true;

 	}

 	// If it's got more than one attribute, everything after this fails.

 	if (node.attributes.length > 1) {

 		return false;

 	}

 	// "It is an a, b, em, font, i, s, span, strike, strong, sub, sup, or u

 	// element with exactly one attribute, which is style, which sets no CSS

 	// properties (including invalid or unrecognized properties)."

 	//

 	// Not gonna try for invalid or unrecognized.

 	if (node.hasAttribute("style")

 	&& node.style.length == 0) {

 		return true;

 	}

 	// "It is an a element with exactly one attribute, which is href."

 	if (node.tagName == "A"

 	&& node.hasAttribute("href")) {

 		return true;

 	}

 	// "It is a font element with exactly one attribute, which is either color,

 	// face, or size."

 	if (node.tagName == "FONT"

 	&& (node.hasAttribute("color")

 	|| node.hasAttribute("face")

 	|| node.hasAttribute("size")

 	)) {

 		return true;

 	}

 	// "It is a b or strong element with exactly one attribute, which is style,

 	// and the style attribute sets exactly one CSS property (including invalid

 	// or unrecognized properties), which is "font-weight"."

 	if ((node.tagName == "B" || node.tagName == "STRONG")

 	&& node.hasAttribute("style")

 	&& node.style.length == 1

 	&& node.style.fontWeight != "") {

 		return true;

 	}

 	// "It is an i or em element with exactly one attribute, which is style,

 	// and the style attribute sets exactly one CSS property (including invalid

 	// or unrecognized properties), which is "font-style"."

 	if ((node.tagName == "I" || node.tagName == "EM")

 	&& node.hasAttribute("style")

 	&& node.style.length == 1

 	&& node.style.fontStyle != "") {

 		return true;

 	}

 	// "It is an a, font, or span element with exactly one attribute, which is

 	// style, and the style attribute sets exactly one CSS property (including

 	// invalid or unrecognized properties), and that property is not

 	// "text-decoration"."

 	if ((node.tagName == "A" || node.tagName == "FONT" || node.tagName == "SPAN")

 	&& node.hasAttribute("style")

 	&& node.style.length == 1

 	&& node.style.textDecoration == "") {

 		return true;

 	}

 	// "It is an a, font, s, span, strike, or u element with exactly one

 	// attribute, which is style, and the style attribute sets exactly one CSS

 	// property (including invalid or unrecognized properties), which is

 	// "text-decoration", which is set to "line-through" or "underline" or

 	// "overline" or "none"."

 	//

 	// The weird extra node.style.length check is for Firefox, which as of

 	// 8.0a2 has annoying and weird behavior here.

 	if (["A", "FONT", "S", "SPAN", "STRIKE", "U"].indexOf(node.tagName) != -1

 	&& node.hasAttribute("style")

 	&& (node.style.length == 1

 	|| (node.style.length == 4

 		&& "MozTextBlink" in node.style

 		&& "MozTextDecorationColor" in node.style

 		&& "MozTextDecorationLine" in node.style

 		&& "MozTextDecorationStyle" in node.style)

 	)

 	&& (node.style.textDecoration == "line-through"

 	|| node.style.textDecoration == "underline"

 	|| node.style.textDecoration == "overline"

 	|| node.style.textDecoration == "none")) {

 		return true;

 	}

 	return false;

 }

 // "A formattable node is an editable visible node that is either a Text node,

 // an img, or a br."

 function isFormattableNode(node) {

 	return isEditable(node)

 		&& isVisible(node)

 		&& (node.nodeType == Node.TEXT_NODE

 		|| isHtmlElement(node, ["img", "br"]));

 }

 // "Two quantities are equivalent values for a command if either both are null,

 // or both are strings and they're equal and the command does not define any

 // equivalent values, or both are strings and the command defines equivalent

 // values and they match the definition."

 function areEquivalentValues(command, val1, val2) {

 	if (val1 === null && val2 === null) {

 		return true;

 	}

 	if (typeof val1 == "string"

 	&& typeof val2 == "string"

 	&& val1 == val2

 	&& !("equivalentValues" in commands[command])) {

 		return true;

 	}

 	if (typeof val1 == "string"

 	&& typeof val2 == "string"

 	&& "equivalentValues" in commands[command]

 	&& commands[command].equivalentValues(val1, val2)) {

 		return true;

 	}

 	return false;

 }

 // "Two quantities are loosely equivalent values for a command if either they

 // are equivalent values for the command, or if the command is the fontSize

 // command; one of the quantities is one of "x-small", "small", "medium",

 // "large", "x-large", "xx-large", or "xxx-large"; and the other quantity is

 // the resolved value of "font-size" on a font element whose size attribute has

 // the corresponding value set ("1" through "7" respectively)."

 function areLooselyEquivalentValues(command, val1, val2) {

 	if (areEquivalentValues(command, val1, val2)) {

 		return true;

 	}

 	if (command != "fontsize"

 	|| typeof val1 != "string"

 	|| typeof val2 != "string") {

 		return false;

 	}

 	// Static variables in JavaScript?

 	var callee = areLooselyEquivalentValues;

 	if (callee.sizeMap === undefined) {

 		callee.sizeMap = {};

 		var font = document.createElement("font");

 		document.body.appendChild(font);

 		["x-small", "small", "medium", "large", "x-large", "xx-large",

 		"xxx-large"].forEach(function(keyword) {

 			font.size = cssSizeToLegacy(keyword);

 			callee.sizeMap[keyword] = getComputedStyle(font).fontSize;

 		});

 		document.body.removeChild(font);

 	}

 	return val1 === callee.sizeMap[val2]

 		|| val2 === callee.sizeMap[val1];

 }

 //@}

 ///// Assorted inline formatting command algorithms /////

 //@{

 function getEffectiveCommandValue(node, command) {

 	// "If neither node nor its parent is an Element, return null."

 	if (node.nodeType != Node.ELEMENT_NODE

 	&& (!node.parentNode || node.parentNode.nodeType != Node.ELEMENT_NODE)) {

 		return null;

 	}

 	// "If node is not an Element, return the effective command value of its

 	// parent for command."

 	if (node.nodeType != Node.ELEMENT_NODE) {

 		return getEffectiveCommandValue(node.parentNode, command);

 	}

 	// "If command is "createLink" or "unlink":"

 	if (command == "createlink" || command == "unlink") {

 		// "While node is not null, and is not an a element that has an href

 		// attribute, set node to its parent."

 		while (node

 		&& (!isHtmlElement(node)

 		|| node.tagName != "A"

 		|| !node.hasAttribute("href"))) {

 			node = node.parentNode;

 		}

 		// "If node is null, return null."

 		if (!node) {

 			return null;

 		}

 		// "Return the value of node's href attribute."

 		return node.getAttribute("href");

 	}

 	// "If command is "backColor" or "hiliteColor":"

 	if (command == "backcolor"

 	|| command == "hilitecolor") {

 		// "While the resolved value of "background-color" on node is any

 		// fully transparent value, and node's parent is an Element, set

 		// node to its parent."

 		//

 		// Another lame hack to avoid flawed APIs.

 		while ((getComputedStyle(node).backgroundColor == "rgba(0, 0, 0, 0)"

 		|| getComputedStyle(node).backgroundColor === ""

 		|| getComputedStyle(node).backgroundColor == "transparent")

 		&& node.parentNode

 		&& node.parentNode.nodeType == Node.ELEMENT_NODE) {

 			node = node.parentNode;

 		}

 		// "Return the resolved value of "background-color" for node."

 		return getComputedStyle(node).backgroundColor;

 	}

 	// "If command is "subscript" or "superscript":"

 	if (command == "subscript" || command == "superscript") {

 		// "Let affected by subscript and affected by superscript be two

 		// boolean variables, both initially false."

 		var affectedBySubscript = false;

 		var affectedBySuperscript = false;

 		// "While node is an inline node:"

 		while (isInlineNode(node)) {

 			var verticalAlign = getComputedStyle(node).verticalAlign;

 			// "If node is a sub, set affected by subscript to true."

 			if (isHtmlElement(node, "sub")) {

 				affectedBySubscript = true;

 			// "Otherwise, if node is a sup, set affected by superscript to

 			// true."

 			} else if (isHtmlElement(node, "sup")) {

 				affectedBySuperscript = true;

 			}

 			// "Set node to its parent."

 			node = node.parentNode;

 		}

 		// "If affected by subscript and affected by superscript are both true,

 		// return the string "mixed"."

 		if (affectedBySubscript && affectedBySuperscript) {

 			return "mixed";

 		}

 		// "If affected by subscript is true, return "subscript"."

 		if (affectedBySubscript) {

 			return "subscript";

 		}

 		// "If affected by superscript is true, return "superscript"."

 		if (affectedBySuperscript) {

 			return "superscript";

 		}

 		// "Return null."

 		return null;

 	}

 	// "If command is "strikethrough", and the "text-decoration" property of

 	// node or any of its ancestors has resolved value containing

 	// "line-through", return "line-through". Otherwise, return null."

 	if (command == "strikethrough") {

 		do {

 			if (getComputedStyle(node).textDecoration.indexOf("line-through") != -1) {

 				return "line-through";

 			}

 			node = node.parentNode;

 		} while (node && node.nodeType == Node.ELEMENT_NODE);

 		return null;

 	}

 	// "If command is "underline", and the "text-decoration" property of node

 	// or any of its ancestors has resolved value containing "underline",

 	// return "underline". Otherwise, return null."

 	if (command == "underline") {

 		do {

 			if (getComputedStyle(node).textDecoration.indexOf("underline") != -1) {

 				return "underline";

 			}

 			node = node.parentNode;

 		} while (node && node.nodeType == Node.ELEMENT_NODE);

 		return null;

 	}

 	if (!("relevantCssProperty" in commands[command])) {

 		throw "Bug: no relevantCssProperty for " + command + " in getEffectiveCommandValue";

 	}

 	// "Return the resolved value for node of the relevant CSS property for

 	// command."

 	return getComputedStyle(node)[commands[command].relevantCssProperty];

 }

 function getSpecifiedCommandValue(element, command) {

 	// "If command is "backColor" or "hiliteColor" and element's display

 	// property does not have resolved value "inline", return null."

 	if ((command == "backcolor" || command == "hilitecolor")

 	&& getComputedStyle(element).display != "inline") {

 		return null;

 	}

 	// "If command is "createLink" or "unlink":"

 	if (command == "createlink" || command == "unlink") {

 		// "If element is an a element and has an href attribute, return the

 		// value of that attribute."

 		if (isHtmlElement(element)

 		&& element.tagName == "A"

 		&& element.hasAttribute("href")) {

 			return element.getAttribute("href");

 		}

 		// "Return null."

 		return null;

 	}

 	// "If command is "subscript" or "superscript":"

 	if (command == "subscript" || command == "superscript") {

 		// "If element is a sup, return "superscript"."

 		if (isHtmlElement(element, "sup")) {

 			return "superscript";

 		}

 		// "If element is a sub, return "subscript"."

 		if (isHtmlElement(element, "sub")) {

 			return "subscript";

 		}

 		// "Return null."

 		return null;

 	}

 	// "If command is "strikethrough", and element has a style attribute set,

 	// and that attribute sets "text-decoration":"

 	if (command == "strikethrough"

 	&& element.style.textDecoration != "") {

 		// "If element's style attribute sets "text-decoration" to a value

 		// containing "line-through", return "line-through"."

 		if (element.style.textDecoration.indexOf("line-through") != -1) {

 			return "line-through";

 		}

 		// "Return null."

 		return null;

 	}

 	// "If command is "strikethrough" and element is a s or strike element,

 	// return "line-through"."

 	if (command == "strikethrough"

 	&& isHtmlElement(element, ["S", "STRIKE"])) {

 		return "line-through";

 	}

 	// "If command is "underline", and element has a style attribute set, and

 	// that attribute sets "text-decoration":"

 	if (command == "underline"

 	&& element.style.textDecoration != "") {

 		// "If element's style attribute sets "text-decoration" to a value

 		// containing "underline", return "underline"."

 		if (element.style.textDecoration.indexOf("underline") != -1) {

 			return "underline";

 		}

 		// "Return null."

 		return null;

 	}

 	// "If command is "underline" and element is a u element, return

 	// "underline"."

 	if (command == "underline"

 	&& isHtmlElement(element, "U")) {

 		return "underline";

 	}

 	// "Let property be the relevant CSS property for command."

 	var property = commands[command].relevantCssProperty;

 	// "If property is null, return null."

 	if (property === null) {

 		return null;

 	}

 	// "If element has a style attribute set, and that attribute has the

 	// effect of setting property, return the value that it sets property to."

 	if (element.style[property] != "") {

 		return element.style[property];

 	}

 	// "If element is a font element that has an attribute whose effect is

 	// to create a presentational hint for property, return the value that the

 	// hint sets property to.  (For a size of 7, this will be the non-CSS value

 	// "xxx-large".)"

 	if (isHtmlNamespace(element.namespaceURI)

 	&& element.tagName == "FONT") {

 		if (property == "color" && element.hasAttribute("color")) {

 			return element.color;

 		}

 		if (property == "fontFamily" && element.hasAttribute("face")) {

 			return element.face;

 		}

 		if (property == "fontSize" && element.hasAttribute("size")) {

 			// This is not even close to correct in general.

 			var size = parseInt(element.size);

 			if (size < 1) {

 				size = 1;

 			}

 			if (size > 7) {

 				size = 7;

 			}

 			return {

 				1: "x-small",

 				2: "small",

 				3: "medium",

 				4: "large",

 				5: "x-large",

 				6: "xx-large",

 				7: "xxx-large"

 			}[size];

 		}

 	}

 	// "If element is in the following list, and property is equal to the

 	// CSS property name listed for it, return the string listed for it."

 	//

 	// A list follows, whose meaning is copied here.

 	if (property == "fontWeight"

 	&& (element.tagName == "B" || element.tagName == "STRONG")) {

 		return "bold";

 	}

 	if (property == "fontStyle"

 	&& (element.tagName == "I" || element.tagName == "EM")) {

 		return "italic";

 	}

 	// "Return null."

 	return null;

 }

 function reorderModifiableDescendants(node, command, newValue) {

 	// "Let candidate equal node."

 	var candidate = node;

 	// "While candidate is a modifiable element, and candidate has exactly one

 	// child, and that child is also a modifiable element, and candidate is not

 	// a simple modifiable element or candidate's specified command value for

 	// command is not equivalent to new value, set candidate to its child."

 	while (isModifiableElement(candidate)

 	&& candidate.childNodes.length == 1

 	&& isModifiableElement(candidate.firstChild)

 	&& (!isSimpleModifiableElement(candidate)

 	|| !areEquivalentValues(command, getSpecifiedCommandValue(candidate, command), newValue))) {

 		candidate = candidate.firstChild;

 	}

 	// "If candidate is node, or is not a simple modifiable element, or its

 	// specified command value is not equivalent to new value, or its effective

 	// command value is not loosely equivalent to new value, abort these

 	// steps."

 	if (candidate == node

 	|| !isSimpleModifiableElement(candidate)

 	|| !areEquivalentValues(command, getSpecifiedCommandValue(candidate, command), newValue)

 	|| !areLooselyEquivalentValues(command, getEffectiveCommandValue(candidate, command), newValue)) {

 		return;

 	}

 	// "While candidate has children, insert the first child of candidate into

 	// candidate's parent immediately before candidate, preserving ranges."

 	while (candidate.hasChildNodes()) {

 		movePreservingRanges(candidate.firstChild, candidate.parentNode, getNodeIndex(candidate));

 	}

 	// "Insert candidate into node's parent immediately after node."

 	node.parentNode.insertBefore(candidate, node.nextSibling);

 	// "Append the node as the last child of candidate, preserving ranges."

 	movePreservingRanges(node, candidate, -1);

 }

 function recordValues(nodeList) {

 	// "Let values be a list of (node, command, specified command value)

 	// triples, initially empty."

 	var values = [];

 	// "For each node in node list, for each command in the list "subscript",

 	// "bold", "fontName", "fontSize", "foreColor", "hiliteColor", "italic",

 	// "strikethrough", and "underline" in that order:"

 	nodeList.forEach(function(node) {

 		["subscript", "bold", "fontname", "fontsize", "forecolor",

 		"hilitecolor", "italic", "strikethrough", "underline"].forEach(function(command) {

 			// "Let ancestor equal node."

 			var ancestor = node;

 			// "If ancestor is not an Element, set it to its parent."

 			if (ancestor.nodeType != Node.ELEMENT_NODE) {

 				ancestor = ancestor.parentNode;

 			}

 			// "While ancestor is an Element and its specified command value

 			// for command is null, set it to its parent."

 			while (ancestor

 			&& ancestor.nodeType == Node.ELEMENT_NODE

 			&& getSpecifiedCommandValue(ancestor, command) === null) {

 				ancestor = ancestor.parentNode;

 			}

 			// "If ancestor is an Element, add (node, command, ancestor's

 			// specified command value for command) to values. Otherwise add

 			// (node, command, null) to values."

 			if (ancestor && ancestor.nodeType == Node.ELEMENT_NODE) {

 				values.push([node, command, getSpecifiedCommandValue(ancestor, command)]);

 			} else {

 				values.push([node, command, null]);

 			}

 		});

 	});

 	// "Return values."

 	return values;

 }

 function restoreValues(values) {

 	// "For each (node, command, value) triple in values:"

 	values.forEach(function(triple) {

 		var node = triple[0];

 		var command = triple[1];

 		var value = triple[2];

 		// "Let ancestor equal node."

 		var ancestor = node;

 		// "If ancestor is not an Element, set it to its parent."

 		if (!ancestor || ancestor.nodeType != Node.ELEMENT_NODE) {

 			ancestor = ancestor.parentNode;

 		}

 		// "While ancestor is an Element and its specified command value for

 		// command is null, set it to its parent."

 		while (ancestor

 		&& ancestor.nodeType == Node.ELEMENT_NODE

 		&& getSpecifiedCommandValue(ancestor, command) === null) {

 			ancestor = ancestor.parentNode;

 		}

 		// "If value is null and ancestor is an Element, push down values on

 		// node for command, with new value null."

 		if (value === null

 		&& ancestor

 		&& ancestor.nodeType == Node.ELEMENT_NODE) {

 			pushDownValues(node, command, null);

 		// "Otherwise, if ancestor is an Element and its specified command

 		// value for command is not equivalent to value, or if ancestor is not

 		// an Element and value is not null, force the value of command to

 		// value on node."

 		} else if ((ancestor

 		&& ancestor.nodeType == Node.ELEMENT_NODE

 		&& !areEquivalentValues(command, getSpecifiedCommandValue(ancestor, command), value))

 		|| ((!ancestor || ancestor.nodeType != Node.ELEMENT_NODE)

 		&& value !== null)) {

 			forceValue(node, command, value);

 		}

 	});

 }

 //@}

 ///// Clearing an element's value /////

 //@{

 function clearValue(element, command) {

 	// "If element is not editable, return the empty list."

 	if (!isEditable(element)) {

 		return [];

 	}

 	// "If element's specified command value for command is null, return the

 	// empty list."

 	if (getSpecifiedCommandValue(element, command) === null) {

 		return [];

 	}

 	// "If element is a simple modifiable element:"

 	if (isSimpleModifiableElement(element)) {

 		// "Let children be the children of element."

 		var children = Array.prototype.slice.call(element.childNodes);

 		// "For each child in children, insert child into element's parent

 		// immediately before element, preserving ranges."

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

 			movePreservingRanges(children[i], element.parentNode, getNodeIndex(element));

 		}

 		// "Remove element from its parent."

 		element.parentNode.removeChild(element);

 		// "Return children."

 		return children;

 	}

 	// "If command is "strikethrough", and element has a style attribute that

 	// sets "text-decoration" to some value containing "line-through", delete

 	// "line-through" from the value."

 	if (command == "strikethrough"

 	&& element.style.textDecoration.indexOf("line-through") != -1) {

 		if (element.style.textDecoration == "line-through") {

 			element.style.textDecoration = "";

 		} else {

 			element.style.textDecoration = element.style.textDecoration.replace("line-through", "");

 		}

 		if (element.getAttribute("style") == "") {

 			element.removeAttribute("style");

 		}

 	}

 	// "If command is "underline", and element has a style attribute that sets

 	// "text-decoration" to some value containing "underline", delete

 	// "underline" from the value."

 	if (command == "underline"

 	&& element.style.textDecoration.indexOf("underline") != -1) {

 		if (element.style.textDecoration == "underline") {

 			element.style.textDecoration = "";

 		} else {

 			element.style.textDecoration = element.style.textDecoration.replace("underline", "");

 		}

 		if (element.getAttribute("style") == "") {

 			element.removeAttribute("style");

 		}

 	}

 	// "If the relevant CSS property for command is not null, unset the CSS

 	// property property of element."

 	if (commands[command].relevantCssProperty !== null) {

 		element.style[commands[command].relevantCssProperty] = '';

 		if (element.getAttribute("style") == "") {

 			element.removeAttribute("style");

 		}

 	}

 	// "If element is a font element:"

 	if (isHtmlNamespace(element.namespaceURI) && element.tagName == "FONT") {

 		// "If command is "foreColor", unset element's color attribute, if set."

 		if (command == "forecolor") {

 			element.removeAttribute("color");

 		}

 		// "If command is "fontName", unset element's face attribute, if set."

 		if (command == "fontname") {

 			element.removeAttribute("face");

 		}

 		// "If command is "fontSize", unset element's size attribute, if set."

 		if (command == "fontsize") {

 			element.removeAttribute("size");

 		}

 	}

 	// "If element is an a element and command is "createLink" or "unlink",

 	// unset the href property of element."

 	if (isHtmlElement(element, "A")

 	&& (command == "createlink" || command == "unlink")) {

 		element.removeAttribute("href");

 	}

 	// "If element's specified command value for command is null, return the

 	// empty list."

 	if (getSpecifiedCommandValue(element, command) === null) {

 		return [];

 	}

 	// "Set the tag name of element to "span", and return the one-node list

 	// consisting of the result."

 	return [setTagName(element, "span")];

 }

 //@}

 ///// Pushing down values /////

 //@{

 function pushDownValues(node, command, newValue) {

 	// "If node's parent is not an Element, abort this algorithm."

 	if (!node.parentNode

 	|| node.parentNode.nodeType != Node.ELEMENT_NODE) {

 		return;

 	}

 	// "If the effective command value of command is loosely equivalent to new

 	// value on node, abort this algorithm."

 	if (areLooselyEquivalentValues(command, getEffectiveCommandValue(node, command), newValue)) {

 		return;

 	}

 	// "Let current ancestor be node's parent."

 	var currentAncestor = node.parentNode;

 	// "Let ancestor list be a list of Nodes, initially empty."

 	var ancestorList = [];

 	// "While current ancestor is an editable Element and the effective command

 	// value of command is not loosely equivalent to new value on it, append

 	// current ancestor to ancestor list, then set current ancestor to its

 	// parent."

 	while (isEditable(currentAncestor)

 	&& currentAncestor.nodeType == Node.ELEMENT_NODE

 	&& !areLooselyEquivalentValues(command, getEffectiveCommandValue(currentAncestor, command), newValue)) {

 		ancestorList.push(currentAncestor);

 		currentAncestor = currentAncestor.parentNode;

 	}

 	// "If ancestor list is empty, abort this algorithm."

 	if (!ancestorList.length) {

 		return;

 	}

 	// "Let propagated value be the specified command value of command on the

 	// last member of ancestor list."

 	var propagatedValue = getSpecifiedCommandValue(ancestorList[ancestorList.length - 1], command);

 	// "If propagated value is null and is not equal to new value, abort this

 	// algorithm."

 	if (propagatedValue === null && propagatedValue != newValue) {

 		return;

 	}

 	// "If the effective command value for the parent of the last member of

 	// ancestor list is not loosely equivalent to new value, and new value is

 	// not null, abort this algorithm."

 	if (newValue !== null

 	&& !areLooselyEquivalentValues(command, getEffectiveCommandValue(ancestorList[ancestorList.length - 1].parentNode, command), newValue)) {

 		return;

 	}

 	// "While ancestor list is not empty:"

 	while (ancestorList.length) {

 		// "Let current ancestor be the last member of ancestor list."

 		// "Remove the last member from ancestor list."

 		var currentAncestor = ancestorList.pop();

 		// "If the specified command value of current ancestor for command is

 		// not null, set propagated value to that value."

 		if (getSpecifiedCommandValue(currentAncestor, command) !== null) {

 			propagatedValue = getSpecifiedCommandValue(currentAncestor, command);

 		}

 		// "Let children be the children of current ancestor."