rangy-rails 1.3alpha.772.0

data/vendor/assets/javascripts/rangy-cssclassapplier.js

@@ -0,0 +1,935 @@
+/**
+ * Class Applier module for Rangy.
+ * Adds, removes and toggles classes on Ranges and Selections
+ *
+ * Part of Rangy, a cross-browser JavaScript range and selection library
+ * http://code.google.com/p/rangy/
+ *
+ * Depends on Rangy core.
+ *
+ * Copyright 2013, Tim Down
+ * Licensed under the MIT license.
+ * Version: 1.3alpha.772
+ * Build date: 26 February 2013
+ */
+rangy.createModule("CssClassApplier", function(api, module) {
+    api.requireModules( ["WrappedSelection", "WrappedRange"] );
+
+    var dom = api.dom;
+    var DomPosition = dom.DomPosition;
+    var contains = dom.arrayContains;
+
+
+    var defaultTagName = "span";
+
+    function trim(str) {
+        return str.replace(/^\s\s*/, "").replace(/\s\s*$/, "");
+    }
+
+    function hasClass(el, cssClass) {
+        return el.className && new RegExp("(?:^|\\s)" + cssClass + "(?:\\s|$)").test(el.className);
+    }
+
+    function addClass(el, cssClass) {
+        if (el.className) {
+            if (!hasClass(el, cssClass)) {
+                el.className += " " + cssClass;
+            }
+        } else {
+            el.className = cssClass;
+        }
+    }
+
+    var removeClass = (function() {
+        function replacer(matched, whiteSpaceBefore, whiteSpaceAfter) {
+            return (whiteSpaceBefore && whiteSpaceAfter) ? " " : "";
+        }
+
+        return function(el, cssClass) {
+            if (el.className) {
+                el.className = el.className.replace(new RegExp("(^|\\s)" + cssClass + "(\\s|$)"), replacer);
+            }
+        };
+    })();
+
+    function sortClassName(className) {
+        return className.split(/\s+/).sort().join(" ");
+    }
+
+    function getSortedClassName(el) {
+        return sortClassName(el.className);
+    }
+
+    function haveSameClasses(el1, el2) {
+        return getSortedClassName(el1) == getSortedClassName(el2);
+    }
+
+    function compareRanges(r1, r2) {
+        return r1.compareBoundaryPoints(r2.START_TO_START, r2);
+    }
+
+    function movePosition(position, oldParent, oldIndex, newParent, newIndex) {
+        var node = position.node, offset = position.offset;
+
+        var newNode = node, newOffset = offset;
+
+        if (node == newParent && offset > newIndex) {
+            newOffset++;
+        }
+
+        if (node == oldParent && (offset == oldIndex  || offset == oldIndex + 1)) {
+            newNode = newParent;
+            newOffset += newIndex - oldIndex;
+        }
+
+        if (node == oldParent && offset > oldIndex + 1) {
+            newOffset--;
+        }
+
+        position.node = newNode;
+        position.offset = newOffset;
+    }
+
+    function movePreservingPositions(node, newParent, newIndex, positionsToPreserve) {
+        // For convenience, allow newIndex to be -1 to mean "insert at the end".
+        if (newIndex == -1) {
+            newIndex = newParent.childNodes.length;
+        }
+
+        var oldParent = node.parentNode;
+        var oldIndex = dom.getNodeIndex(node);
+
+        for (var i = 0, position; position = positionsToPreserve[i++]; ) {
+            movePosition(position, oldParent, oldIndex, newParent, newIndex);
+        }
+
+        // Now actually move the node.
+        if (newParent.childNodes.length == newIndex) {
+            newParent.appendChild(node);
+        } else {
+            newParent.insertBefore(node, newParent.childNodes[newIndex]);
+        }
+    }
+
+    function moveChildrenPreservingPositions(node, newParent, newIndex, removeNode, positionsToPreserve) {
+        var child, children = [];
+        while ( (child = node.firstChild) ) {
+            movePreservingPositions(child, newParent, newIndex++, positionsToPreserve);
+            children.push(child);
+        }
+        if (removeNode) {
+            node.parentNode.removeChild(node);
+        }
+        return children;
+    }
+
+    function replaceWithOwnChildrenPreservingPositions(element, positionsToPreserve) {
+        return moveChildrenPreservingPositions(element, element.parentNode, dom.getNodeIndex(element), true, positionsToPreserve);
+    }
+
+    function rangeSelectsAnyText(range, textNode) {
+        var textNodeRange = range.cloneRange();
+        textNodeRange.selectNodeContents(textNode);
+
+        var intersectionRange = textNodeRange.intersection(range);
+        var text = intersectionRange ? intersectionRange.toString() : "";
+        textNodeRange.detach();
+
+        return text != "";
+    }
+
+    function getEffectiveTextNodes(range) {
+        var nodes = range.getNodes([3]);
+        
+        // Optimization as per issue 145
+        
+        // Remove non-intersecting text nodes from the start of the range
+        var start = 0, node;
+        while ( (node = nodes[start]) && !rangeSelectsAnyText(range, node) ) {
+            ++start;
+        }
+
+        // Remove non-intersecting text nodes from the start of the range
+        var end = nodes.length - 1;
+        while ( (node = nodes[end]) && !rangeSelectsAnyText(range, node) ) {
+            --end;
+        }
+        
+        return nodes.slice(start, end + 1);
+    }
+
+    function elementsHaveSameNonClassAttributes(el1, el2) {
+        if (el1.attributes.length != el2.attributes.length) return false;
+        for (var i = 0, len = el1.attributes.length, attr1, attr2, name; i < len; ++i) {
+            attr1 = el1.attributes[i];
+            name = attr1.name;
+            if (name != "class") {
+                attr2 = el2.attributes.getNamedItem(name);
+                if (attr1.specified != attr2.specified) return false;
+                if (attr1.specified && attr1.nodeValue !== attr2.nodeValue) return false;
+            }
+        }
+        return true;
+    }
+
+    function elementHasNonClassAttributes(el, exceptions) {
+        for (var i = 0, len = el.attributes.length, attrName; i < len; ++i) {
+            attrName = el.attributes[i].name;
+            if ( !(exceptions && contains(exceptions, attrName)) && el.attributes[i].specified && attrName != "class") {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function elementHasProps(el, props) {
+        var propValue;
+        for (var p in props) {
+            if (props.hasOwnProperty(p)) {
+                propValue = props[p];
+                if (typeof propValue == "object") {
+                    if (!elementHasProps(el[p], propValue)) {
+                        return false;
+                    }
+                } else if (el[p] !== propValue) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    var getComputedStyleProperty = dom.getComputedStyleProperty;
+    var isEditableElement;
+
+    (function() {
+        var testEl = document.createElement("div");
+        if (typeof testEl.isContentEditable == "boolean") {
+            isEditableElement = function(node) {
+                return node && node.nodeType == 1 && node.isContentEditable;
+            };
+        } else {
+            isEditableElement = function(node) {
+                if (!node || node.nodeType != 1 || node.contentEditable == "false") {
+                    return false;
+                }
+                return node.contentEditable == "true" || isEditableElement(node.parentNode);
+            };
+        }
+    })();
+
+    function isEditingHost(node) {
+        var parent;
+        return node && node.nodeType == 1
+            && (( (parent = node.parentNode) && parent.nodeType == 9 && parent.designMode == "on")
+            || (isEditableElement(node) && !isEditableElement(node.parentNode)));
+    }
+
+    function isEditable(node) {
+        return (isEditableElement(node) || (node.nodeType != 1 && isEditableElement(node.parentNode))) && !isEditingHost(node);
+    }
+
+    var inlineDisplayRegex = /^inline(-block|-table)?$/i;
+
+    function isNonInlineElement(node) {
+        return node && node.nodeType == 1 && !inlineDisplayRegex.test(getComputedStyleProperty(node, "display"));
+    }
+
+    // White space characters as defined by HTML 4 (http://www.w3.org/TR/html401/struct/text.html)
+    var htmlNonWhiteSpaceRegex = /[^\r\n\t\f \u200B]/;
+
+    function isUnrenderedWhiteSpaceNode(node) {
+        if (node.data.length == 0) {
+            return true;
+        }
+        if (htmlNonWhiteSpaceRegex.test(node.data)) {
+            return false;
+        }
+        var cssWhiteSpace = getComputedStyleProperty(node.parentNode, "whiteSpace");
+        switch (cssWhiteSpace) {
+            case "pre":
+            case "pre-wrap":
+            case "-moz-pre-wrap":
+                return false;
+            case "pre-line":
+                if (/[\r\n]/.test(node.data)) {
+                    return false;
+                }
+        }
+
+        // We now have a whitespace-only text node that may be rendered depending on its context. If it is adjacent to a
+        // non-inline element, it will not be rendered. This seems to be a good enough definition.
+        return isNonInlineElement(node.previousSibling) || isNonInlineElement(node.nextSibling);
+    }
+
+    function getRangeBoundaries(ranges) {
+        var positions = [], i, range;
+        for (i = 0; range = ranges[i++]; ) {
+            positions.push(
+                new DomPosition(range.startContainer, range.startOffset),
+                new DomPosition(range.endContainer, range.endOffset)
+            );
+        }
+        return positions;
+    }
+
+    function updateRangesFromBoundaries(ranges, positions) {
+        for (var i = 0, range, start, end, len = ranges.length; i < len; ++i) {
+            range = ranges[i];
+            start = positions[i * 2];
+            end = positions[i * 2 + 1];
+            range.setStartAndEnd(start.node, start.offset, end.node, end.offset);
+        }
+    }
+
+    function isSplitPoint(node, offset) {
+        if (dom.isCharacterDataNode(node)) {
+            if (offset == 0) {
+                return !!node.previousSibling;
+            } else if (offset == node.length) {
+                return !!node.nextSibling;
+            } else {
+                return true;
+            }
+        }
+
+        return offset > 0 && offset < node.childNodes.length;
+    }
+
+    function splitNodeAt(node, descendantNode, descendantOffset, positionsToPreserve) {
+        var newNode, parentNode;
+        var splitAtStart = (descendantOffset == 0);
+
+        if (dom.isAncestorOf(descendantNode, node)) {
+            return node;
+        }
+
+        if (dom.isCharacterDataNode(descendantNode)) {
+            var descendantIndex = dom.getNodeIndex(descendantNode);
+            if (descendantOffset == 0) {
+                descendantOffset = descendantIndex;
+            } else if (descendantOffset == descendantNode.length) {
+                descendantOffset = descendantIndex + 1;
+            } else {
+                throw module.createError("splitNodeAt() should not be called with offset in the middle of a data node ("
+                    + descendantOffset + " in " + descendantNode.data);
+            }
+            descendantNode = descendantNode.parentNode;
+        }
+
+        if (isSplitPoint(descendantNode, descendantOffset)) {
+            // descendantNode is now guaranteed not to be a text or other character node
+            newNode = descendantNode.cloneNode(false);
+            parentNode = descendantNode.parentNode;
+            if (newNode.id) {
+                newNode.removeAttribute("id");
+            }
+            var child, newChildIndex = 0;
+
+            while ( (child = descendantNode.childNodes[descendantOffset]) ) {
+                movePreservingPositions(child, newNode, newChildIndex++, positionsToPreserve);
+                //newNode.appendChild(child);
+            }
+            movePreservingPositions(newNode, parentNode, dom.getNodeIndex(descendantNode) + 1, positionsToPreserve);
+            //dom.insertAfter(newNode, descendantNode);
+            return (descendantNode == node) ? newNode : splitNodeAt(node, parentNode, dom.getNodeIndex(newNode), positionsToPreserve);
+        } else if (node != descendantNode) {
+            newNode = descendantNode.parentNode;
+
+            // Work out a new split point in the parent node
+            var newNodeIndex = dom.getNodeIndex(descendantNode);
+
+            if (!splitAtStart) {
+                newNodeIndex++;
+            }
+            return splitNodeAt(node, newNode, newNodeIndex, positionsToPreserve);
+        }
+        return node;
+    }
+
+    function areElementsMergeable(el1, el2) {
+        return el1.tagName == el2.tagName
+            && haveSameClasses(el1, el2)
+            && elementsHaveSameNonClassAttributes(el1, el2)
+            && getComputedStyleProperty(el1, "display") == "inline"
+            && getComputedStyleProperty(el2, "display") == "inline";
+    }
+
+    function createAdjacentMergeableTextNodeGetter(forward) {
+        var propName = forward ? "nextSibling" : "previousSibling";
+
+        return function(textNode, checkParentElement) {
+            var el = textNode.parentNode;
+            var adjacentNode = textNode[propName];
+            if (adjacentNode) {
+                // Can merge if the node's previous/next sibling is a text node
+                if (adjacentNode && adjacentNode.nodeType == 3) {
+                    return adjacentNode;
+                }
+            } else if (checkParentElement) {
+                // Compare text node parent element with its sibling
+                adjacentNode = el[propName];
+                if (adjacentNode && adjacentNode.nodeType == 1 && areElementsMergeable(el, adjacentNode)/* && adjacentNode.hasChildNodes()*/) {
+                    return adjacentNode[forward ? "firstChild" : "lastChild"];
+                }
+            }
+            return null;
+        };
+    }
+
+    var getPreviousMergeableTextNode = createAdjacentMergeableTextNodeGetter(false),
+        getNextMergeableTextNode = createAdjacentMergeableTextNodeGetter(true);
+
+
+    function Merge(firstNode) {
+        this.isElementMerge = (firstNode.nodeType == 1);
+        this.textNodes = [];
+        var firstTextNode = this.isElementMerge ? firstNode.lastChild : firstNode;
+        if (firstTextNode) {
+            this.textNodes[0] = firstTextNode;
+        }
+    }
+
+    Merge.prototype = {
+        doMerge: function(positionsToPreserve) {
+            var textNodes = this.textNodes;
+            var firstTextNode = textNodes[0];
+            if (textNodes.length > 1) {
+                var textParts = [], combinedTextLength = 0, textNode, parent;
+                for (var i = 0, len = textNodes.length, j, position; i < len; ++i) {
+                    textNode = textNodes[i];
+                    parent = textNode.parentNode;
+                    if (i > 0) {
+                        parent.removeChild(textNode);
+                        if (!parent.hasChildNodes()) {
+                            parent.parentNode.removeChild(parent);
+                        }
+                        if (positionsToPreserve) {
+                            for (j = 0; position = positionsToPreserve[j++]; ) {
+                                // Handle case where position is inside the text node being merged into a preceding node
+                                if (position.node == textNode) {
+                                    position.node = firstTextNode;
+                                    position.offset += combinedTextLength;
+                                }
+                            }
+                        }
+                    }
+                    textParts[i] = textNode.data;
+                    combinedTextLength += textNode.data.length;
+                }
+                firstTextNode.data = textParts.join("");
+            }
+            return firstTextNode.data;
+        },
+
+        getLength: function() {
+            var i = this.textNodes.length, len = 0;
+            while (i--) {
+                len += this.textNodes[i].length;
+            }
+            return len;
+        },
+
+        toString: function() {
+            var textBits = [];
+            for (var i = 0, len = this.textNodes.length; i < len; ++i) {
+                textBits[i] = "'" + this.textNodes[i].data + "'";
+            }
+            return "[Merge(" + textBits.join(",") + ")]";
+        }
+    };
+
+    var optionProperties = ["elementTagName", "ignoreWhiteSpace", "applyToEditableOnly", "useExistingElements",
+        "removeEmptyElements"];
+
+    // TODO: Populate this with every attribute name that corresponds to a property with a different name
+    var attrNamesForProperties = {};
+
+    function ClassApplier(cssClass, options, tagNames) {
+        this.cssClass = cssClass;
+        var normalize, i, len, propName;
+
+        var elementPropertiesFromOptions = null;
+
+        // Initialize from options object
+        if (typeof options == "object" && options !== null) {
+            tagNames = options.tagNames;
+            elementPropertiesFromOptions = options.elementProperties;
+
+            for (i = 0; propName = optionProperties[i++]; ) {
+                if (options.hasOwnProperty(propName)) {
+                    this[propName] = options[propName];
+                }
+            }
+            normalize = options.normalize;
+        } else {
+            normalize = options;
+        }
+
+        // Backward compatibility: the second parameter can also be a Boolean indicating to normalize after unapplying
+        this.normalize = (typeof normalize == "undefined") ? true : normalize;
+
+        // Initialize element properties and attribute exceptions
+        this.attrExceptions = [];
+        var el = document.createElement(this.elementTagName);
+        this.elementProperties = this.copyPropertiesToElement(elementPropertiesFromOptions, el, true);
+
+        this.elementSortedClassName = this.elementProperties.hasOwnProperty("className") ?
+            this.elementProperties.className : cssClass;
+
+        // Initialize tag names
+        this.applyToAnyTagName = false;
+        var type = typeof tagNames;
+        if (type == "string") {
+            if (tagNames == "*") {
+                this.applyToAnyTagName = true;
+            } else {
+                this.tagNames = trim(tagNames.toLowerCase()).split(/\s*,\s*/);
+            }
+        } else if (type == "object" && typeof tagNames.length == "number") {
+            this.tagNames = [];
+            for (i = 0, len = tagNames.length; i < len; ++i) {
+                if (tagNames[i] == "*") {
+                    this.applyToAnyTagName = true;
+                } else {
+                    this.tagNames.push(tagNames[i].toLowerCase());
+                }
+            }
+        } else {
+            this.tagNames = [this.elementTagName];
+        }
+    }
+
+    ClassApplier.prototype = {
+        elementTagName: defaultTagName,
+        elementProperties: {},
+        ignoreWhiteSpace: true,
+        applyToEditableOnly: false,
+        useExistingElements: true,
+        removeEmptyElements: true,
+
+        copyPropertiesToElement: function(props, el, createCopy) {
+            var s, elStyle, elProps = {}, elPropsStyle, propValue, elPropValue, attrName;
+
+            for (var p in props) {
+                if (props.hasOwnProperty(p)) {
+                    propValue = props[p];
+                    elPropValue = el[p];
+
+                    // Special case for class. The copied properties object has the applier's CSS class as well as its
+                    // own to simplify checks when removing styling elements
+                    if (p == "className") {
+                        addClass(el, propValue);
+                        addClass(el, this.cssClass);
+                        el[p] = sortClassName(el[p]);
+                        if (createCopy) {
+                            elProps[p] = el[p];
+                        }
+                    }
+
+                    // Special case for style
+                    else if (p == "style") {
+                        elStyle = elPropValue;
+                        if (createCopy) {
+                            elProps[p] = elPropsStyle = {};
+                        }
+                        for (s in props[p]) {
+                            elStyle[s] = propValue[s];
+                            if (createCopy) {
+                                elPropsStyle[s] = elStyle[s];
+                            }
+                        }
+                        this.attrExceptions.push(p);
+                    } else {
+                        el[p] = propValue;
+                        // Copy the property back from the dummy element so that later comparisons to check whether
+                        // elements may be removed are checking against the right value. For example, the href property
+                        // of an element returns a fully qualified URL even if it was previously assigned a relative
+                        // URL.
+                        if (createCopy) {
+                            elProps[p] = el[p];
+
+                            // Not all properties map to identically named attributes
+                            attrName = attrNamesForProperties.hasOwnProperty(p) ? attrNamesForProperties[p] : p;
+                            this.attrExceptions.push(attrName);
+                        }
+                    }
+                }
+            }
+
+            return createCopy ? elProps : "";
+        },
+
+        hasClass: function(node) {
+            return node.nodeType == 1 &&
+                contains(this.tagNames, node.tagName.toLowerCase()) &&
+                hasClass(node, this.cssClass);
+        },
+
+        getSelfOrAncestorWithClass: function(node) {
+            while (node) {
+                if (this.hasClass(node)) {
+                    return node;
+                }
+                node = node.parentNode;
+            }
+            return null;
+        },
+
+        isModifiable: function(node) {
+            return !this.applyToEditableOnly || isEditable(node);
+        },
+
+        // White space adjacent to an unwrappable node can be ignored for wrapping
+        isIgnorableWhiteSpaceNode: function(node) {
+            return this.ignoreWhiteSpace && node && node.nodeType == 3 && isUnrenderedWhiteSpaceNode(node);
+        },
+
+        // Normalizes nodes after applying a CSS class to a Range.
+        postApply: function(textNodes, range, positionsToPreserve, isUndo) {
+            var firstNode = textNodes[0], lastNode = textNodes[textNodes.length - 1];
+
+            var merges = [], currentMerge;
+
+            var rangeStartNode = firstNode, rangeEndNode = lastNode;
+            var rangeStartOffset = 0, rangeEndOffset = lastNode.length;
+
+            var textNode, precedingTextNode;
+
+            // Check for every required merge and create a Merge object for each
+            for (var i = 0, len = textNodes.length; i < len; ++i) {
+                textNode = textNodes[i];
+                precedingTextNode = getPreviousMergeableTextNode(textNode, !isUndo);
+                if (precedingTextNode) {
+                    if (!currentMerge) {
+                        currentMerge = new Merge(precedingTextNode);
+                        merges.push(currentMerge);
+                    }
+                    currentMerge.textNodes.push(textNode);
+                    if (textNode === firstNode) {
+                        rangeStartNode = currentMerge.textNodes[0];
+                        rangeStartOffset = rangeStartNode.length;
+                    }
+                    if (textNode === lastNode) {
+                        rangeEndNode = currentMerge.textNodes[0];
+                        rangeEndOffset = currentMerge.getLength();
+                    }
+                } else {
+                    currentMerge = null;
+                }
+            }
+
+            // Test whether the first node after the range needs merging
+            var nextTextNode = getNextMergeableTextNode(lastNode, !isUndo);
+
+            if (nextTextNode) {
+                if (!currentMerge) {
+                    currentMerge = new Merge(lastNode);
+                    merges.push(currentMerge);
+                }
+                currentMerge.textNodes.push(nextTextNode);
+            }
+
+            // Apply the merges
+            if (merges.length) {
+                for (i = 0, len = merges.length; i < len; ++i) {
+                    merges[i].doMerge(positionsToPreserve);
+                }
+
+                // Set the range boundaries
+                range.setStartAndEnd(rangeStartNode, rangeStartOffset, rangeEndNode, rangeEndOffset);
+            }
+        },
+
+        createContainer: function(doc) {
+            var el = doc.createElement(this.elementTagName);
+            this.copyPropertiesToElement(this.elementProperties, el, false);
+            addClass(el, this.cssClass);
+            return el;
+        },
+
+        applyToTextNode: function(textNode, positionsToPreserve) {
+            var parent = textNode.parentNode;
+            if (parent.childNodes.length == 1 &&
+                    this.useExistingElements &&
+                    contains(this.tagNames, parent.tagName.toLowerCase()) &&
+                    elementHasProps(parent, this.elementProperties)) {
+
+                addClass(parent, this.cssClass);
+            } else {
+                var el = this.createContainer(dom.getDocument(textNode));
+                textNode.parentNode.insertBefore(el, textNode);
+                el.appendChild(textNode);
+            }
+        },
+
+        isRemovable: function(el) {
+            return el.tagName.toLowerCase() == this.elementTagName
+                && getSortedClassName(el) == this.elementSortedClassName
+                && elementHasProps(el, this.elementProperties)
+                && !elementHasNonClassAttributes(el, this.attrExceptions)
+                && this.isModifiable(el);
+        },
+
+        isEmptyContainer: function(el) {
+            var childNodeCount = el.childNodes.length;
+            return el.nodeType == 1
+                && this.isRemovable(el)
+                && (childNodeCount == 0 || (childNodeCount == 1 && this.isEmptyContainer(el.firstChild)));
+        },
+        
+        removeEmptyContainers: function(range) {
+            var applier = this;
+            var nodesToRemove = range.getNodes([1], function(el) {
+                return applier.isEmptyContainer(el);
+            });
+            
+            for (var i = 0, node; node = nodesToRemove[i++]; ) {
+                node.parentNode.removeChild(node);
+            }
+        },
+
+        undoToTextNode: function(textNode, range, ancestorWithClass, positionsToPreserve) {
+            if (!range.containsNode(ancestorWithClass)) {
+                // Split out the portion of the ancestor from which we can remove the CSS class
+                //var parent = ancestorWithClass.parentNode, index = dom.getNodeIndex(ancestorWithClass);
+                var ancestorRange = range.cloneRange();
+                ancestorRange.selectNode(ancestorWithClass);
+                if (ancestorRange.isPointInRange(range.endContainer, range.endOffset)) {
+                    splitNodeAt(ancestorWithClass, range.endContainer, range.endOffset, positionsToPreserve);
+                    range.setEndAfter(ancestorWithClass);
+                }
+                if (ancestorRange.isPointInRange(range.startContainer, range.startOffset)) {
+                    ancestorWithClass = splitNodeAt(ancestorWithClass, range.startContainer, range.startOffset, positionsToPreserve);
+                }
+            }
+            if (this.isRemovable(ancestorWithClass)) {
+                replaceWithOwnChildrenPreservingPositions(ancestorWithClass, positionsToPreserve);
+            } else {
+                removeClass(ancestorWithClass, this.cssClass);
+            }
+        },
+
+        applyToRange: function(range, rangesToPreserve) {
+            rangesToPreserve = rangesToPreserve || [];
+
+            // Create an array of range boundaries to preserve
+            var positionsToPreserve = getRangeBoundaries(rangesToPreserve || []);
+            
+            range.splitBoundariesPreservingPositions(positionsToPreserve);
+
+            // Tidy up the DOM by removing empty containers 
+            if (this.removeEmptyElements) {
+                this.removeEmptyContainers(range);
+            }
+
+            var textNodes = getEffectiveTextNodes(range);
+
+            if (textNodes.length) {
+                for (var i = 0, textNode; textNode = textNodes[i++]; ) {
+                    if (!this.isIgnorableWhiteSpaceNode(textNode) && !this.getSelfOrAncestorWithClass(textNode)
+                            && this.isModifiable(textNode)) {
+                        this.applyToTextNode(textNode, positionsToPreserve);
+                    }
+                }
+                textNode = textNodes[textNodes.length - 1];
+                range.setStartAndEnd(textNodes[0], 0, textNode, textNode.length);
+                if (this.normalize) {
+                    this.postApply(textNodes, range, positionsToPreserve, false);
+                }
+
+                // Update the ranges from the preserved boundary positions
+                updateRangesFromBoundaries(rangesToPreserve, positionsToPreserve);
+            }
+        },
+
+        applyToRanges: function(ranges) {
+
+            var i = ranges.length;
+            while (i--) {
+                this.applyToRange(ranges[i], ranges);
+            }
+
+
+            return ranges;
+        },
+
+        applyToSelection: function(win) {
+            var sel = api.getSelection(win);
+            sel.setRanges( this.applyToRanges(sel.getAllRanges()) );
+        },
+
+        undoToRange: function(range, rangesToPreserve) {
+            // Create an array of range boundaries to preserve
+            rangesToPreserve = rangesToPreserve || [];
+            var positionsToPreserve = getRangeBoundaries(rangesToPreserve);
+
+
+            range.splitBoundariesPreservingPositions(positionsToPreserve);
+
+            // Tidy up the DOM by removing empty containers 
+            if (this.removeEmptyElements) {
+                this.removeEmptyContainers(range, positionsToPreserve);
+            }
+
+            var textNodes = getEffectiveTextNodes(range);
+            var textNode, ancestorWithClass;
+            var lastTextNode = textNodes[textNodes.length - 1];
+
+            if (textNodes.length) {
+                for (var i = 0, len = textNodes.length; i < len; ++i) {
+                    textNode = textNodes[i];
+                    ancestorWithClass = this.getSelfOrAncestorWithClass(textNode);
+                    if (ancestorWithClass && this.isModifiable(textNode)) {
+                        this.undoToTextNode(textNode, range, ancestorWithClass, positionsToPreserve);
+                    }
+
+                    // Ensure the range is still valid
+                    range.setStartAndEnd(textNodes[0], 0, lastTextNode, lastTextNode.length);
+                }
+
+
+                if (this.normalize) {
+                    this.postApply(textNodes, range, positionsToPreserve, true);
+                }
+
+                // Update the ranges from the preserved boundary positions
+                updateRangesFromBoundaries(rangesToPreserve, positionsToPreserve);
+            }
+        },
+
+        undoToRanges: function(ranges) {
+            // Get ranges returned in document order
+            var i = ranges.length;
+
+            while (i--) {
+                this.undoToRange(ranges[i], ranges);
+            }
+
+            return ranges;
+        },
+
+        undoToSelection: function(win) {
+            var sel = api.getSelection(win);
+            var ranges = api.getSelection(win).getAllRanges();
+            this.undoToRanges(ranges);
+            sel.setRanges(ranges);
+        },
+
+        getTextSelectedByRange: function(textNode, range) {
+            var textRange = range.cloneRange();
+            textRange.selectNodeContents(textNode);
+
+            var intersectionRange = textRange.intersection(range);
+            var text = intersectionRange ? intersectionRange.toString() : "";
+            textRange.detach();
+
+            return text;
+        },
+
+        isAppliedToRange: function(range) {
+            if (range.collapsed || range.toString() == "") {
+                return !!this.getSelfOrAncestorWithClass(range.commonAncestorContainer);
+            } else {
+                var textNodes = range.getNodes( [3] );
+                if (textNodes.length)
+                for (var i = 0, textNode; textNode = textNodes[i++]; ) {
+                    if (!this.isIgnorableWhiteSpaceNode(textNode) && rangeSelectsAnyText(range, textNode)
+                            && this.isModifiable(textNode) && !this.getSelfOrAncestorWithClass(textNode)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        },
+
+        isAppliedToRanges: function(ranges) {
+            var i = ranges.length;
+            while (i--) {
+                if (!this.isAppliedToRange(ranges[i])) {
+                    return false;
+                }
+            }
+            return true;
+        },
+
+        isAppliedToSelection: function(win) {
+            var sel = api.getSelection(win);
+            return this.isAppliedToRanges(sel.getAllRanges());
+        },
+
+        toggleRange: function(range) {
+            if (this.isAppliedToRange(range)) {
+                this.undoToRange(range);
+            } else {
+                this.applyToRange(range);
+            }
+        },
+
+        toggleRanges: function(ranges) {
+            if (this.isAppliedToRanges(ranges)) {
+                this.undoToRanges(ranges);
+            } else {
+                this.applyToRanges(ranges);
+            }
+        },
+
+        toggleSelection: function(win) {
+            if (this.isAppliedToSelection(win)) {
+                this.undoToSelection(win);
+            } else {
+                this.applyToSelection(win);
+            }
+        },
+        
+        getElementsWithClassIntersectingRange: function(range) {
+            var elements = [];
+            var applier = this;
+            range.getNodes([3], function(textNode) {
+                var el = applier.getSelfOrAncestorWithClass(textNode);
+                if (el && !contains(elements, el)) {
+                    elements.push(el);
+                }
+            });
+            return elements;
+        },
+
+        getElementsWithClassIntersectingSelection: function(win) {
+            var sel = api.getSelection(win);
+            var elements = [];
+            var applier = this;
+            sel.eachRange(function(range) {
+                var rangeElements = applier.getElementsWithClassIntersectingRange(range);
+                for (var i = 0, el; el = rangeElements[i++]; ) {
+                    if (!contains(elements, el)) {
+                        elements.push(el);
+                    }
+                }
+            });
+            return elements;
+        },
+
+        detach: function() {}
+    };
+
+    function createClassApplier(cssClass, options, tagNames) {
+        return new ClassApplier(cssClass, options, tagNames);
+    }
+
+    ClassApplier.util = {
+        hasClass: hasClass,
+        addClass: addClass,
+        removeClass: removeClass,
+        hasSameClasses: haveSameClasses,
+        replaceWithOwnChildren: replaceWithOwnChildrenPreservingPositions,
+        elementsHaveSameNonClassAttributes: elementsHaveSameNonClassAttributes,
+        elementHasNonClassAttributes: elementHasNonClassAttributes,
+        splitNodeAt: splitNodeAt,
+        isEditableElement: isEditableElement,
+        isEditingHost: isEditingHost,
+        isEditable: isEditable
+    };
+
+    api.CssClassApplier = api.ClassApplier = ClassApplier;
+    api.createCssClassApplier = api.createClassApplier = createClassApplier;
+});