rangy-rails 1.3alpha.780.0 → 1.3alpha.804.0

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

@@ -9,7 +9,977 @@
  *
  * Copyright 2013, Tim Down
  * Licensed under the MIT license.
- * Version: 1.3alpha.780M
- * Build date: 17 May 2013
+ * Version: 1.3alpha.804
+ * Build date: 8 December 2013
  */
-rangy.createModule("ClassApplier",["WrappedSelection"],function(a,b){function g(a){return a.replace(/^\s\s*/,"").replace(/\s\s*$/,"")}function h(a,b){return a.className&&(new RegExp("(?:^|\\s)"+b+"(?:\\s|$)")).test(a.className)}function i(a,b){a.className?h(a,b)||(a.className+=" "+b):a.className=b}function k(a){return a.split(/\s+/).sort().join(" ")}function l(a){return k(a.className)}function m(a,b){return l(a)==l(b)}function n(a,b){return a.compareBoundaryPoints(b.START_TO_START,b)}function o(a,b,c,d,e){var f=a.node,g=a.offset,h=f,i=g;f==d&&g>e&&i++,f==b&&(g==c||g==c+1)&&(h=d,i+=e-c),f==b&&g>c+1&&i--,a.node=h,a.offset=i}function p(a,b,d,e){d==-1&&(d=b.childNodes.length);var f=a.parentNode,g=c.getNodeIndex(a);for(var h=0,i;i=e[h++];)o(i,f,g,b,d);b.childNodes.length==d?b.appendChild(a):b.insertBefore(a,b.childNodes[d])}function q(a,b,c,d,e){var f,g=[];while(f=a.firstChild)p(f,b,c++,e),g.push(f);return d&&a.parentNode.removeChild(a),g}function r(a,b){return q(a,a.parentNode,c.getNodeIndex(a),!0,b)}function s(a,b){var c=a.cloneRange();c.selectNodeContents(b);var d=c.intersection(a),e=d?d.toString():"";return c.detach(),e!=""}function t(a){var b=a.getNodes([3]),c=0,d;while((d=b[c])&&!s(a,d))++c;var e=b.length-1;while((d=b[e])&&!s(a,d))--e;return b.slice(c,e+1)}function u(a,b){if(a.attributes.length!=b.attributes.length)return!1;for(var c=0,d=a.attributes.length,e,f,g;c<d;++c){e=a.attributes[c],g=e.name;if(g!="class"){f=b.attributes.getNamedItem(g);if(e.specified!=f.specified)return!1;if(e.specified&&e.nodeValue!==f.nodeValue)return!1}}return!0}function v(a,b){for(var c=0,d=a.attributes.length,f;c<d;++c){f=a.attributes[c].name;if((!b||!e(b,f))&&a.attributes[c].specified&&f!="class")return!0}return!1}function w(a,b){var c;for(var d in b)if(b.hasOwnProperty(d)){c=b[d];if(typeof c=="object"){if(!w(a[d],c))return!1}else if(a[d]!==c)return!1}return!0}function z(a){var b;return a&&a.nodeType==1&&((b=a.parentNode)&&b.nodeType==9&&b.designMode=="on"||y(a)&&!y(a.parentNode))}function A(a){return(y(a)||a.nodeType!=1&&y(a.parentNode))&&!z(a)}function C(a){return a&&a.nodeType==1&&!B.test(x(a,"display"))}function E(a){if(a.data.length==0)return!0;if(D.test(a.data))return!1;var b=x(a.parentNode,"whiteSpace");switch(b){case"pre":case"pre-wrap":case"-moz-pre-wrap":return!1;case"pre-line":if(/[\r\n]/.test(a.data))return!1}return C(a.previousSibling)||C(a.nextSibling)}function F(a){var b=[],c,e;for(c=0;e=a[c++];)b.push(new d(e.startContainer,e.startOffset),new d(e.endContainer,e.endOffset));return b}function G(a,b){for(var c=0,d,e,f,g=a.length;c<g;++c)d=a[c],e=b[c*2],f=b[c*2+1],d.setStartAndEnd(e.node,e.offset,f.node,f.offset)}function H(a,b){return c.isCharacterDataNode(a)?b==0?!!a.previousSibling:b==a.length?!!a.nextSibling:!0:b>0&&b<a.childNodes.length}function I(a,d,e,f){var g,h,i=e==0;if(c.isAncestorOf(d,a))return a;if(c.isCharacterDataNode(d)){var j=c.getNodeIndex(d);if(e==0)e=j;else{if(e!=d.length)throw b.createError("splitNodeAt() should not be called with offset in the middle of a data node ("+e+" in "+d.data);e=j+1}d=d.parentNode}if(H(d,e)){g=d.cloneNode(!1),h=d.parentNode,g.id&&g.removeAttribute("id");var k,l=0;while(k=d.childNodes[e])p(k,g,l++,f);return p(g,h,c.getNodeIndex(d)+1,f),d==a?g:I(a,h,c.getNodeIndex(g),f)}if(a!=d){g=d.parentNode;var m=c.getNodeIndex(d);return i||m++,I(a,g,m,f)}return a}function J(a,b){return a.tagName==b.tagName&&m(a,b)&&u(a,b)&&x(a,"display")=="inline"&&x(b,"display")=="inline"}function K(a){var b=a?"nextSibling":"previousSibling";return function(c,d){var e=c.parentNode,f=c[b];if(f){if(f&&f.nodeType==3)return f}else if(d){f=e[b];if(f&&f.nodeType==1&&J(e,f))return f[a?"firstChild":"lastChild"]}return null}}function N(a){this.isElementMerge=a.nodeType==1,this.textNodes=[];var b=this.isElementMerge?a.lastChild:a;b&&(this.textNodes[0]=b)}function Q(a,b,c){this.cssClass=a;var d,e,f,h,i=null;if(typeof b=="object"&&b!==null){c=b.tagNames,i=b.elementProperties;for(e=0;h=O[e++];)b.hasOwnProperty(h)&&(this[h]=b[h]);d=b.normalize}else d=b;this.normalize=typeof d=="undefined"?!0:d,this.attrExceptions=[];var j=document.createElement(this.elementTagName);this.elementProperties=this.copyPropertiesToElement(i,j,!0),this.elementSortedClassName=this.elementProperties.hasOwnProperty("className")?this.elementProperties.className:a,this.applyToAnyTagName=!1;var k=typeof c;if(k=="string")c=="*"?this.applyToAnyTagName=!0:this.tagNames=g(c.toLowerCase()).split(/\s*,\s*/);else if(k=="object"&&typeof c.length=="number"){this.tagNames=[];for(e=0,f=c.length;e<f;++e)c[e]=="*"?this.applyToAnyTagName=!0:this.tagNames.push(c[e].toLowerCase())}else this.tagNames=[this.elementTagName]}function R(a,b,c){return new Q(a,b,c)}var c=a.dom,d=c.DomPosition,e=c.arrayContains,f="span",j=function(){function a(a,b,c){return b&&c?" ":""}return function(b,c){b.className&&(b.className=b.className.replace(new RegExp("(^|\\s)"+c+"(\\s|$)"),a))}}(),x=c.getComputedStyleProperty,y;(function(){var a=document.createElement("div");typeof a.isContentEditable=="boolean"?y=function(a){return a&&a.nodeType==1&&a.isContentEditable}:y=function(a){return!a||a.nodeType!=1||a.contentEditable=="false"?!1:a.contentEditable=="true"||y(a.parentNode)}})();var B=/^inline(-block|-table)?$/i,D=/[^\r\n\t\f \u200B]/,L=K(!1),M=K(!0);N.prototype={doMerge:function(a){var b=this.textNodes,c=b[0];if(b.length>1){var d=[],e=0,f,g;for(var h=0,i=b.length,j,k;h<i;++h){f=b[h],g=f.parentNode;if(h>0){g.removeChild(f),g.hasChildNodes()||g.parentNode.removeChild(g);if(a)for(j=0;k=a[j++];)k.node==f&&(k.node=c,k.offset+=e)}d[h]=f.data,e+=f.data.length}c.data=d.join("")}return c.data},getLength:function(){var a=this.textNodes.length,b=0;while(a--)b+=this.textNodes[a].length;return b},toString:function(){var a=[];for(var b=0,c=this.textNodes.length;b<c;++b)a[b]="'"+this.textNodes[b].data+"'";return"[Merge("+a.join(",")+")]"}};var O=["elementTagName","ignoreWhiteSpace","applyToEditableOnly","useExistingElements","removeEmptyElements"],P={};Q.prototype={elementTagName:f,elementProperties:{},ignoreWhiteSpace:!0,applyToEditableOnly:!1,useExistingElements:!0,removeEmptyElements:!0,copyPropertiesToElement:function(a,b,c){var d,e,f={},g,h,j,l;for(var m in a)if(a.hasOwnProperty(m)){h=a[m],j=b[m];if(m=="className")i(b,h),i(b,this.cssClass),b[m]=k(b[m]),c&&(f[m]=b[m]);else if(m=="style"){e=j,c&&(f[m]=g={});for(d in a[m])e[d]=h[d],c&&(g[d]=e[d]);this.attrExceptions.push(m)}else b[m]=h,c&&(f[m]=b[m],l=P.hasOwnProperty(m)?P[m]:m,this.attrExceptions.push(l))}return c?f:""},hasClass:function(a){return a.nodeType==1&&e(this.tagNames,a.tagName.toLowerCase())&&h(a,this.cssClass)},getSelfOrAncestorWithClass:function(a){while(a){if(this.hasClass(a))return a;a=a.parentNode}return null},isModifiable:function(a){return!this.applyToEditableOnly||A(a)},isIgnorableWhiteSpaceNode:function(a){return this.ignoreWhiteSpace&&a&&a.nodeType==3&&E(a)},postApply:function(a,b,c,d){var e=a[0],f=a[a.length-1],g=[],h,i=e,j=f,k=0,l=f.length,m,n;for(var o=0,p=a.length;o<p;++o)m=a[o],n=L(m,!d),n?(h||(h=new N(n),g.push(h)),h.textNodes.push(m),m===e&&(i=h.textNodes[0],k=i.length),m===f&&(j=h.textNodes[0],l=h.getLength())):h=null;var q=M(f,!d);q&&(h||(h=new N(f),g.push(h)),h.textNodes.push(q));if(g.length){for(o=0,p=g.length;o<p;++o)g[o].doMerge(c);b.setStartAndEnd(i,k,j,l)}},createContainer:function(a){var b=a.createElement(this.elementTagName);return this.copyPropertiesToElement(this.elementProperties,b,!1),i(b,this.cssClass),b},applyToTextNode:function(a,b){var d=a.parentNode;if(d.childNodes.length==1&&this.useExistingElements&&e(this.tagNames,d.tagName.toLowerCase())&&w(d,this.elementProperties))i(d,this.cssClass);else{var f=this.createContainer(c.getDocument(a));a.parentNode.insertBefore(f,a),f.appendChild(a)}},isRemovable:function(a){return a.tagName.toLowerCase()==this.elementTagName&&l(a)==this.elementSortedClassName&&w(a,this.elementProperties)&&!v(a,this.attrExceptions)&&this.isModifiable(a)},isEmptyContainer:function(a){var b=a.childNodes.length;return a.nodeType==1&&this.isRemovable(a)&&(b==0||b==1&&this.isEmptyContainer(a.firstChild))},removeEmptyContainers:function(a){var b=this,c=a.getNodes([1],function(a){return b.isEmptyContainer(a)});for(var d=0,e;e=c[d++];)e.parentNode.removeChild(e)},undoToTextNode:function(a,b,c,d){if(!b.containsNode(c)){var e=b.cloneRange();e.selectNode(c),e.isPointInRange(b.endContainer,b.endOffset)&&(I(c,b.endContainer,b.endOffset,d),b.setEndAfter(c)),e.isPointInRange(b.startContainer,b.startOffset)&&(c=I(c,b.startContainer,b.startOffset,d))}this.isRemovable(c)?r(c,d):j(c,this.cssClass)},applyToRange:function(a,b){b=b||[];var c=F(b||[]);a.splitBoundariesPreservingPositions(c),this.removeEmptyElements&&this.removeEmptyContainers(a);var d=t(a);if(d.length){for(var e=0,f;f=d[e++];)!this.isIgnorableWhiteSpaceNode(f)&&!this.getSelfOrAncestorWithClass(f)&&this.isModifiable(f)&&this.applyToTextNode(f,c);f=d[d.length-1],a.setStartAndEnd(d[0],0,f,f.length),this.normalize&&this.postApply(d,a,c,!1),G(b,c)}},applyToRanges:function(a){var b=a.length;while(b--)this.applyToRange(a[b],a);return a},applyToSelection:function(b){var c=a.getSelection(b);c.setRanges(this.applyToRanges(c.getAllRanges()))},undoToRange:function(a,b){b=b||[];var c=F(b);a.splitBoundariesPreservingPositions(c),this.removeEmptyElements&&this.removeEmptyContainers(a,c);var d=t(a),e,f,g=d[d.length-1];if(d.length){for(var h=0,i=d.length;h<i;++h)e=d[h],f=this.getSelfOrAncestorWithClass(e),f&&this.isModifiable(e)&&this.undoToTextNode(e,a,f,c),a.setStartAndEnd(d[0],0,g,g.length);this.normalize&&this.postApply(d,a,c,!0),G(b,c)}},undoToRanges:function(a){var b=a.length;while(b--)this.undoToRange(a[b],a);return a},undoToSelection:function(b){var c=a.getSelection(b),d=a.getSelection(b).getAllRanges();this.undoToRanges(d),c.setRanges(d)},getTextSelectedByRange:function(a,b){var c=b.cloneRange();c.selectNodeContents(a);var d=c.intersection(b),e=d?d.toString():"";return c.detach(),e},isAppliedToRange:function(a){if(a.collapsed||a.toString()=="")return!!this.getSelfOrAncestorWithClass(a.commonAncestorContainer);var b=a.getNodes([3]);if(b.length)for(var c=0,d;d=b[c++];)if(!this.isIgnorableWhiteSpaceNode(d)&&s(a,d)&&this.isModifiable(d)&&!this.getSelfOrAncestorWithClass(d))return!1;return!0},isAppliedToRanges:function(a){var b=a.length;if(b==0)return!1;while(b--)if(!this.isAppliedToRange(a[b]))return!1;return!0},isAppliedToSelection:function(b){var c=a.getSelection(b);return this.isAppliedToRanges(c.getAllRanges())},toggleRange:function(a){this.isAppliedToRange(a)?this.undoToRange(a):this.applyToRange(a)},toggleRanges:function(a){this.isAppliedToRanges(a)?this.undoToRanges(a):this.applyToRanges(a)},toggleSelection:function(a){this.isAppliedToSelection(a)?this.undoToSelection(a):this.applyToSelection(a)},getElementsWithClassIntersectingRange:function(a){var b=[],c=this;return a.getNodes([3],function(a){var d=c.getSelfOrAncestorWithClass(a);d&&!e(b,d)&&b.push(d)}),b},getElementsWithClassIntersectingSelection:function(b){var c=a.getSelection(b),d=[],f=this;return c.eachRange(function(a){var b=f.getElementsWithClassIntersectingRange(a);for(var c=0,g;g=b[c++];)e(d,g)||d.push(g)}),d},detach:function(){}},Q.util={hasClass:h,addClass:i,removeClass:j,hasSameClasses:m,replaceWithOwnChildren:r,elementsHaveSameNonClassAttributes:u,elementHasNonClassAttributes:v,splitNodeAt:I,isEditableElement:y,isEditingHost:z,isEditable:A},a.CssClassApplier=a.ClassApplier=Q,a.createCssClassApplier=a.createClassApplier=R})
+rangy.createModule("ClassApplier", ["WrappedSelection"], function(api, module) {
+    var dom = api.dom;
+    var DomPosition = dom.DomPosition;
+    var contains = dom.arrayContains;
+
+
+    var defaultTagName = "span";
+
+    function each(obj, func) {
+        for (var i in obj) {
+            if (obj.hasOwnProperty(i)) {
+                if (func(i, obj[i]) === false) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    
+    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 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 movePositionWhenRemovingNode(position, parentNode, index) {
+        if (position.node == parentNode && position.offset > index) {
+            --position.offset;
+        }
+    }
+
+    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 removePreservingPositions(node, positionsToPreserve) {
+
+        var oldParent = node.parentNode;
+        var oldIndex = dom.getNodeIndex(node);
+
+        for (var i = 0, position; position = positionsToPreserve[i++]; ) {
+            movePositionWhenRemovingNode(position, oldParent, oldIndex);
+        }
+
+        node.parentNode.removeChild(node);
+    }
+
+    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 === null) != (attr2 === null) ) return false;
+                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 elementHasProperties(el, props) {
+        each(props, function(p, propValue) {
+            if (typeof propValue == "object") {
+                if (!elementHasProperties(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");
+        return typeof testEl.isContentEditable == "boolean" ?
+            function (node) {
+                return node && node.nodeType == 1 && node.isContentEditable;
+            } :
+            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);
+            }
+            movePreservingPositions(newNode, parentNode, dom.getNodeIndex(descendantNode) + 1, positionsToPreserve);
+            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 siblingPropName = forward ? "nextSibling" : "previousSibling";
+
+        return function(textNode, checkParentElement) {
+            var el = textNode.parentNode;
+            var adjacentNode = textNode[siblingPropName];
+            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[siblingPropName];
+                if (adjacentNode && adjacentNode.nodeType == 1 && areElementsMergeable(el, adjacentNode)) {
+                    var adjacentNodeChild = adjacentNode[forward ? "firstChild" : "lastChild"];
+                    if (adjacentNodeChild && adjacentNodeChild.nodeType == 3) {
+                        return adjacentNodeChild;
+                    }
+                }
+            }
+            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 textParts = [];
+            for (var i = 0, len = this.textNodes.length; i < len; ++i) {
+                textParts[i] = "'" + this.textNodes[i].data + "'";
+            }
+            return "[Merge(" + textParts.join(",") + ")]";
+        }
+    };
+
+    var optionProperties = ["elementTagName", "ignoreWhiteSpace", "applyToEditableOnly", "useExistingElements",
+        "removeEmptyElements", "onElementCreate"];
+
+    // TODO: Populate this with every attribute name that corresponds to a property with a different name. Really??
+    var attrNamesForProperties = {};
+
+    function ClassApplier(cssClass, options, tagNames) {
+        var normalize, i, len, propName, applier = this;
+        applier.cssClass = cssClass;
+
+        var elementPropertiesFromOptions = null, elementAttributes = {};
+
+        // Initialize from options object
+        if (typeof options == "object" && options !== null) {
+            tagNames = options.tagNames;
+            elementPropertiesFromOptions = options.elementProperties;
+            elementAttributes = options.elementAttributes;
+
+            for (i = 0; propName = optionProperties[i++]; ) {
+                if (options.hasOwnProperty(propName)) {
+                    applier[propName] = options[propName];
+                }
+            }
+            normalize = options.normalize;
+        } else {
+            normalize = options;
+        }
+
+        // Backward compatibility: the second parameter can also be a Boolean indicating to normalize after unapplying
+        applier.normalize = (typeof normalize == "undefined") ? true : normalize;
+
+        // Initialize element properties and attribute exceptions
+        applier.attrExceptions = [];
+        var el = document.createElement(applier.elementTagName);
+        applier.elementProperties = applier.copyPropertiesToElement(elementPropertiesFromOptions, el, true);
+        each(elementAttributes, function(attrName) {
+            applier.attrExceptions.push(attrName);
+        });
+        applier.elementAttributes = elementAttributes;
+
+        applier.elementSortedClassName = applier.elementProperties.hasOwnProperty("className") ?
+            applier.elementProperties.className : cssClass;
+
+        // Initialize tag names
+        applier.applyToAnyTagName = false;
+        var type = typeof tagNames;
+        if (type == "string") {
+            if (tagNames == "*") {
+                applier.applyToAnyTagName = true;
+            } else {
+                applier.tagNames = trim(tagNames.toLowerCase()).split(/\s*,\s*/);
+            }
+        } else if (type == "object" && typeof tagNames.length == "number") {
+            applier.tagNames = [];
+            for (i = 0, len = tagNames.length; i < len; ++i) {
+                if (tagNames[i] == "*") {
+                    applier.applyToAnyTagName = true;
+                } else {
+                    applier.tagNames.push(tagNames[i].toLowerCase());
+                }
+            }
+        } else {
+            applier.tagNames = [applier.elementTagName];
+        }
+    }
+
+    ClassApplier.prototype = {
+        elementTagName: defaultTagName,
+        elementProperties: {},
+        elementAttributes: {},
+        ignoreWhiteSpace: true,
+        applyToEditableOnly: false,
+        useExistingElements: true,
+        removeEmptyElements: true,
+        onElementCreate: null,
+
+        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 : "";
+        },
+        
+        copyAttributesToElement: function(attrs, el) {
+            for (var attrName in attrs) {
+                if (attrs.hasOwnProperty(attrName)) {
+                    el.setAttribute(attrName, attrs[attrName]);
+                }
+            }
+        },
+
+        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);
+            this.copyAttributesToElement(this.elementAttributes, el);
+            addClass(el, this.cssClass);
+            if (this.onElementCreate) {
+                this.onElementCreate(el, this);
+            }
+            return el;
+        },
+
+        applyToTextNode: function(textNode, positionsToPreserve) {
+            var parent = textNode.parentNode;
+            if (parent.childNodes.length == 1 &&
+                    this.useExistingElements &&
+                    contains(this.tagNames, parent.tagName.toLowerCase()) &&
+                    elementHasProperties(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
+                && elementHasProperties(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);
+            });
+            
+            var rangesToPreserve = [range]
+            var positionsToPreserve = getRangeBoundaries(rangesToPreserve);
+            
+            for (var i = 0, node; node = nodesToRemove[i++]; ) {
+                removePreservingPositions(node, positionsToPreserve);
+            }
+
+            // Update the range from the preserved boundary positions
+            updateRangesFromBoundaries(rangesToPreserve, positionsToPreserve);
+        },
+
+        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;
+            if (i == 0) {
+                return false;
+            }
+            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;
+});