https://rockbarn.com/public/assets/js/browserify_src/bundle_browserify.js

34        "extractContents", "cloneContents", "insertNode", "surroundContents", "cloneRange", "toString", "detach"];
35
36    var textRangeProperties = ["boundingHeight", "boundingLeft", "boundingTop", "boundingWidth", "htmlText", "text"];
37
38    // Subset of TextRange's full set of methods that we're interested in
39    var textRangeMethods = ["collapse", "compareEndPoints", "duplicate", "moveToElementText", "parentElement", "select",
40        "setEndPoint", "getBoundingClientRect"];
41
42    /*----------------------------------------------------------------------------------------------------------------*/
43
44    // Trio of functions taken from Peter Michaux's article:
45    // http://peter.michaux.ca/articles/feature-detection-state-of-the-art-browser-scripting
46    function isHostMethod(o, p) {
47        var t = typeof o[p];
48        return t == FUNCTION || (!!(t == OBJECT && o[p])) || t == "unknown";
49    }
50
51    function isHostObject(o, p) {
52        return !!(typeof o[p] == OBJECT && o[p]);
53    }
54
55    function isHostProperty(o, p) {
56        return typeof o[p] != UNDEFINED;
57    }
58
59    // Creates a convenience function to save verbose repeated calls to tests functions
60    function createMultiplePropertyTest(testFunc) {
61        return function(o, props) {
62            var i = props.length;
63            while (i--) {
64                if (!testFunc(o, props[i])) {
65                    return false;
66                }
67            }
68            return true;
69        };
70    }
71
72    // Next trio of functions are a convenience to save verbose repeated calls to previous two functions
73    var areHostMethods = createMultiplePropertyTest(isHostMethod);
74    var areHostObjects = createMultiplePropertyTest(isHostObject);
75    var areHostProperties = createMultiplePropertyTest(isHostProperty);
76
77    function isTextRange(range) {
78        return range && areHostMethods(range, textRangeMethods) && areHostProperties(range, textRangeProperties);
79    }
80
81    function getBody(doc) {
82        return isHostObject(doc, "body") ? doc.body : doc.getElementsByTagName("body")[0];
83    }
84
85    var forEach = [].forEach ?
86        function(arr, func) {
87            arr.forEach(func);
88        } :
89        function(arr, func) {
90            for (var i = 0, len = arr.length; i < len; ++i) {
91                func(arr[i], i);
92            }
93        };
94
95    var modules = {};
96
97    var isBrowser = (typeof window != UNDEFINED && typeof document != UNDEFINED);
98
99    var util = {
100        isHostMethod: isHostMethod,
101        isHostObject: isHostObject,
102        isHostProperty: isHostProperty,
103        areHostMethods: areHostMethods,
104        areHostObjects: areHostObjects,
105        areHostProperties: areHostProperties,
106        isTextRange: isTextRange,
107        getBody: getBody,
108        forEach: forEach
109    };
110
111    var api = {
112        version: "1.3.1-dev",
113        initialized: false,
114        isBrowser: isBrowser,
115        supported: true,
116        util: util,
117        features: {},
118        modules: modules,
119        config: {
120            alertOnFail: false,
121            alertOnWarn: false,
122            preferTextRange: false,
123            autoInitialize: (typeof rangyAutoInitialize == UNDEFINED) ? true : rangyAutoInitialize
124        }
125    };
126
127    function consoleLog(msg) {
128        if (typeof console != UNDEFINED && isHostMethod(console, "log")) {
129            console.log(msg);
130        }
131    }
132
133    function alertOrLog(msg, shouldAlert) {
134        if (isBrowser && shouldAlert) {
135            alert(msg);
136        } else  {
137            consoleLog(msg);
138        }
139    }
140
141    function fail(reason) {
142        api.initialized = true;
143        api.supported = false;
144        alertOrLog("Rangy is not supported in this environment. Reason: " + reason, api.config.alertOnFail);
145    }
146
147    api.fail = fail;
148
149    function warn(msg) {
150        alertOrLog("Rangy warning: " + msg, api.config.alertOnWarn);
151    }
152
153    api.warn = warn;
154
155    // Add utility extend() method
156    var extend;
157    if ({}.hasOwnProperty) {
158        util.extend = extend = function(obj, props, deep) {
159            var o, p;
160            for (var i in props) {
161                if (props.hasOwnProperty(i)) {
162                    o = obj[i];
163                    p = props[i];
164                    if (deep && o !== null && typeof o == "object" && p !== null && typeof p == "object") {
165                        extend(o, p, true);
166                    }
167                    obj[i] = p;
168                }
169            }
170            // Special case for toString, which does not show up in for...in loops in IE <= 8
171            if (props.hasOwnProperty("toString")) {
172                obj.toString = props.toString;
173            }
174            return obj;
175        };
176
177        util.createOptions = function(optionsParam, defaults) {
178            var options = {};
179            extend(options, defaults);
180            if (optionsParam) {
181                extend(options, optionsParam);
182            }
183            return options;
184        };
185    } else {
186        fail("hasOwnProperty not supported");
187    }
188
189    // Test whether we're in a browser and bail out if not
190    if (!isBrowser) {
191        fail("Rangy can only run in a browser");
192    }
193
194    // Test whether Array.prototype.slice can be relied on for NodeLists and use an alternative toArray() if not
195    (function() {
196        var toArray;
197
198        if (isBrowser) {
199            var el = document.createElement("div");
200            el.appendChild(document.createElement("span"));
201            var slice = [].slice;
202            try {
203                if (slice.call(el.childNodes, 0)[0].nodeType == 1) {
204                    toArray = function(arrayLike) {
205                        return slice.call(arrayLike, 0);
206                    };
207                }
208            } catch (e) {}
209        }
210
211        if (!toArray) {
212            toArray = function(arrayLike) {
213                var arr = [];
214                for (var i = 0, len = arrayLike.length; i < len; ++i) {
215                    arr[i] = arrayLike[i];
216                }
217                return arr;
218            };
219        }
220
221        util.toArray = toArray;
222    })();
223
224    // Very simple event handler wrapper function that doesn't attempt to solve issues such as "this" handling or
225    // normalization of event properties
226    var addListener;
227    if (isBrowser) {
228        if (isHostMethod(document, "addEventListener")) {
229            addListener = function(obj, eventType, listener) {
230                obj.addEventListener(eventType, listener, false);
231            };
232        } else if (isHostMethod(document, "attachEvent")) {
233            addListener = function(obj, eventType, listener) {
234                obj.attachEvent("on" + eventType, listener);
235            };
236        } else {
237            fail("Document does not have required addEventListener or attachEvent method");
238        }
239
240        util.addListener = addListener;
241    }
242
243    var initListeners = [];
244
245    function getErrorDesc(ex) {
246        return ex.message || ex.description || String(ex);
247    }
248
249    // Initialization
250    function init() {
251        if (!isBrowser || api.initialized) {
252            return;
253        }
254        var testRange;
255        var implementsDomRange = false, implementsTextRange = false;
256
257        // First, perform basic feature tests
258
259        if (isHostMethod(document, "createRange")) {
260            testRange = document.createRange();
261            if (areHostMethods(testRange, domRangeMethods) && areHostProperties(testRange, domRangeProperties)) {
262                implementsDomRange = true;
263            }
264        }
265
266        var body = getBody(document);
267        if (!body || body.nodeName.toLowerCase() != "body") {
268            fail("No body element found");
269            return;
270        }
271
272        if (body && isHostMethod(body, "createTextRange")) {
273            testRange = body.createTextRange();
274            if (isTextRange(testRange)) {
275                implementsTextRange = true;
276            }
277        }
278
279        if (!implementsDomRange && !implementsTextRange) {
280            fail("Neither Range nor TextRange are available");
281            return;
282        }
283
284        api.initialized = true;
285        api.features = {
286            implementsDomRange: implementsDomRange,
287            implementsTextRange: implementsTextRange
288        };
289
290        // Initialize modules
291        var module, errorMessage;
292        for (var moduleName in modules) {
293            if ( (module = modules[moduleName]) instanceof Module ) {
294                module.init(module, api);
295            }
296        }
297
298        // Call init listeners
299        for (var i = 0, len = initListeners.length; i < len; ++i) {
300            try {
301                initListeners[i](api);
302            } catch (ex) {
303                errorMessage = "Rangy init listener threw an exception. Continuing. Detail: " + getErrorDesc(ex);
304                consoleLog(errorMessage);
305            }
306        }
307    }
308
309    function deprecationNotice(deprecated, replacement, module) {
310        if (module) {
311            deprecated += " in module " + module.name;
312        }
313        api.warn("DEPRECATED: " + deprecated + " is deprecated. Please use " +
314        replacement + " instead.");
315    }
316
317    function createAliasForDeprecatedMethod(owner, deprecated, replacement, module) {
318        owner[deprecated] = function() {
319            deprecationNotice(deprecated, replacement, module);
320            return owner[replacement].apply(owner, util.toArray(arguments));
321        };
322    }
323
324    util.deprecationNotice = deprecationNotice;
325    util.createAliasForDeprecatedMethod = createAliasForDeprecatedMethod;
326
327    // Allow external scripts to initialize this library in case it's loaded after the document has loaded
328    api.init = init;
329
330    // Execute listener immediately if already initialized
331    api.addInitListener = function(listener) {
332        if (api.initialized) {
333            listener(api);
334        } else {
335            initListeners.push(listener);
336        }
337    };
338
339    var shimListeners = [];
340
341    api.addShimListener = function(listener) {
342        shimListeners.push(listener);
343    };
344
345    function shim(win) {
346        win = win || window;
347        init();
348
349        // Notify listeners
350        for (var i = 0, len = shimListeners.length; i < len; ++i) {
351            shimListeners[i](win);
352        }
353    }
354
355    if (isBrowser) {
356        api.shim = api.createMissingNativeApi = shim;
357        createAliasForDeprecatedMethod(api, "createMissingNativeApi", "shim");
358    }
359
360    function Module(name, dependencies, initializer) {
361        this.name = name;
362        this.dependencies = dependencies;
363        this.initialized = false;
364        this.supported = false;
365        this.initializer = initializer;
366    }
367
368    Module.prototype = {
369        init: function() {
370            var requiredModuleNames = this.dependencies || [];
371            for (var i = 0, len = requiredModuleNames.length, requiredModule, moduleName; i < len; ++i) {
372                moduleName = requiredModuleNames[i];
373
374                requiredModule = modules[moduleName];
375                if (!requiredModule || !(requiredModule instanceof Module)) {
376                    throw new Error("required module '" + moduleName + "' not found");
377                }
378
379                requiredModule.init();
380
381                if (!requiredModule.supported) {
382                    throw new Error("required module '" + moduleName + "' not supported");
383                }
384            }
385
386            // Now run initializer
387            this.initializer(this);
388        },
389
390        fail: function(reason) {
391            this.initialized = true;
392            this.supported = false;
393            throw new Error(reason);
394        },
395
396        warn: function(msg) {
397            api.warn("Module " + this.name + ": " + msg);
398        },
399
400        deprecationNotice: function(deprecated, replacement) {
401            api.warn("DEPRECATED: " + deprecated + " in module " + this.name + " is deprecated. Please use " +
402                replacement + " instead");
403        },
404
405        createError: function(msg) {
406            return new Error("Error in Rangy " + this.name + " module: " + msg);
407        }
408    };
409
410    function createModule(name, dependencies, initFunc) {
411        var newModule = new Module(name, dependencies, function(module) {
412            if (!module.initialized) {
413                module.initialized = true;
414                try {
415                    initFunc(api, module);
416                    module.supported = true;
417                } catch (ex) {
418                    var errorMessage = "Module '" + name + "' failed to load: " + getErrorDesc(ex);
419                    consoleLog(errorMessage);
420                    if (ex.stack) {
421                        consoleLog(ex.stack);
422                    }
423                }
424            }
425        });
426        modules[name] = newModule;
427        return newModule;
428    }
429
430    api.createModule = function(name) {
431        // Allow 2 or 3 arguments (second argument is an optional array of dependencies)
432        var initFunc, dependencies;
433        if (arguments.length == 2) {
434            initFunc = arguments[1];
435            dependencies = [];
436        } else {
437            initFunc = arguments[2];
438            dependencies = arguments[1];
439        }
440
441        var module = createModule(name, dependencies, initFunc);
442
443        // Initialize the module immediately if the core is already initialized
444        if (api.initialized && api.supported) {
445            module.init();
446        }
447    };
448
449    api.createCoreModule = function(name, dependencies, initFunc) {
450        createModule(name, dependencies, initFunc);
451    };
452
453    /*----------------------------------------------------------------------------------------------------------------*/
454
455    // Ensure rangy.rangePrototype and rangy.selectionPrototype are available immediately
456
457    function RangePrototype() {}
458    api.RangePrototype = RangePrototype;
459    api.rangePrototype = new RangePrototype();
460
461    function SelectionPrototype() {}
462    api.selectionPrototype = new SelectionPrototype();
463
464    /*----------------------------------------------------------------------------------------------------------------*/
465
466    // DOM utility methods used by Rangy
467    api.createCoreModule("DomUtil", [], function(api, module) {
468        var UNDEF = "undefined";
469        var util = api.util;
470        var getBody = util.getBody;
471
472        // Perform feature tests
473        if (!util.areHostMethods(document, ["createDocumentFragment", "createElement", "createTextNode"])) {
474            module.fail("document missing a Node creation method");
475        }
476
477        if (!util.isHostMethod(document, "getElementsByTagName")) {
478            module.fail("document missing getElementsByTagName method");
479        }
480
481        var el = document.createElement("div");
482        if (!util.areHostMethods(el, ["insertBefore", "appendChild", "cloneNode"] ||
483                !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]))) {
484            module.fail("Incomplete Element implementation");
485        }
486
487        // innerHTML is required for Range's createContextualFragment method
488        if (!util.isHostProperty(el, "innerHTML")) {
489            module.fail("Element is missing innerHTML property");
490        }
491
492        var textNode = document.createTextNode("test");
493        if (!util.areHostMethods(textNode, ["splitText", "deleteData", "insertData", "appendData", "cloneNode"] ||
494                !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]) ||
495                !util.areHostProperties(textNode, ["data"]))) {
496            module.fail("Incomplete Text Node implementation");
497        }
498
499        /*----------------------------------------------------------------------------------------------------------------*/
500
501        // Removed use of indexOf because of a bizarre bug in Opera that is thrown in one of the Acid3 tests. I haven't been
502        // able to replicate it outside of the test. The bug is that indexOf returns -1 when called on an Array that
503        // contains just the document as a single element and the value searched for is the document.
504        var arrayContains = /*Array.prototype.indexOf ?
505            function(arr, val) {
506                return arr.indexOf(val) > -1;
507            }:*/
508
509            function(arr, val) {
510                var i = arr.length;
511                while (i--) {
512                    if (arr[i] === val) {
513                        return true;
514                    }
515                }
516                return false;
517            };
518
519        // Opera 11 puts HTML elements in the null namespace, it seems, and IE 7 has undefined namespaceURI
520        function isHtmlNamespace(node) {
521            var ns;
522            return typeof node.namespaceURI == UNDEF || ((ns = node.namespaceURI) === null || ns == "http://www.w3.org/1999/xhtml");
523        }
524
525        function parentElement(node) {
526            var parent = node.parentNode;
527            return (parent.nodeType == 1) ? parent : null;
528        }
529
530        function getNodeIndex(node) {
531            var i = 0;
532            while( (node = node.previousSibling) ) {
533                ++i;
534            }
535            return i;
536        }
537
538        function getNodeLength(node) {
539            switch (node.nodeType) {
540                case 7:
541                case 10:
542                    return 0;
543                case 3:
544                case 8:
545                    return node.length;
546                default:
547                    return node.childNodes.length;
548            }
549        }
550
551        function getCommonAncestor(node1, node2) {
552            var ancestors = [], n;
553            for (n = node1; n; n = n.parentNode) {
554                ancestors.push(n);
555            }
556
557            for (n = node2; n; n = n.parentNode) {
558                if (arrayContains(ancestors, n)) {
559                    return n;
560                }
561            }
562
563            return null;
564        }
565
566        function isAncestorOf(ancestor, descendant, selfIsAncestor) {
567            var n = selfIsAncestor ? descendant : descendant.parentNode;
568            while (n) {
569                if (n === ancestor) {
570                    return true;
571                } else {
572                    n = n.parentNode;
573                }
574            }
575            return false;
576        }
577
578        function isOrIsAncestorOf(ancestor, descendant) {
579            return isAncestorOf(ancestor, descendant, true);
580        }
581
582        function getClosestAncestorIn(node, ancestor, selfIsAncestor) {
583            var p, n = selfIsAncestor ? node : node.parentNode;
584            while (n) {
585                p = n.parentNode;
586                if (p === ancestor) {
587                    return n;
588                }
589                n = p;
590            }
591            return null;
592        }
593
594        function isCharacterDataNode(node) {
595            var t = node.nodeType;
596            return t == 3 || t == 4 || t == 8 ; // Text, CDataSection or Comment
597        }
598
599        function isTextOrCommentNode(node) {
600            if (!node) {
601                return false;
602            }
603            var t = node.nodeType;
604            return t == 3 || t == 8 ; // Text or Comment
605        }
606
607        function insertAfter(node, precedingNode) {
608            var nextNode = precedingNode.nextSibling, parent = precedingNode.parentNode;
609            if (nextNode) {
610                parent.insertBefore(node, nextNode);
611            } else {
612                parent.appendChild(node);
613            }
614            return node;
615        }
616
617        // Note that we cannot use splitText() because it is bugridden in IE 9.
618        function splitDataNode(node, index, positionsToPreserve) {
619            var newNode = node.cloneNode(false);
620            newNode.deleteData(0, index);
621            node.deleteData(index, node.length - index);
622            insertAfter(newNode, node);
623
624            // Preserve positions
625            if (positionsToPreserve) {
626                for (var i = 0, position; position = positionsToPreserve[i++]; ) {
627                    // Handle case where position was inside the portion of node after the split point
628                    if (position.node == node && position.offset > index) {
629                        position.node = newNode;
630                        position.offset -= index;
631                    }
632                    // Handle the case where the position is a node offset within node's parent
633                    else if (position.node == node.parentNode && position.offset > getNodeIndex(node)) {
634                        ++position.offset;
635                    }
636                }
637            }
638            return newNode;
639        }
640
641        function getDocument(node) {
642            if (node.nodeType == 9) {
643                return node;
644            } else if (typeof node.ownerDocument != UNDEF) {
645                return node.ownerDocument;
646            } else if (typeof node.document != UNDEF) {
647                return node.document;
648            } else if (node.parentNode) {
649                return getDocument(node.parentNode);
650            } else {
651                throw module.createError("getDocument: no document found for node");
652            }
653        }
654
655        function getWindow(node) {
656            var doc = getDocument(node);
657            if (typeof doc.defaultView != UNDEF) {
658                return doc.defaultView;
659            } else if (typeof doc.parentWindow != UNDEF) {
660                return doc.parentWindow;
661            } else {
662                throw module.createError("Cannot get a window object for node");
663            }
664        }
665
666        function getIframeDocument(iframeEl) {
667            if (typeof iframeEl.contentDocument != UNDEF) {
668                return iframeEl.contentDocument;
669            } else if (typeof iframeEl.contentWindow != UNDEF) {
670                return iframeEl.contentWindow.document;
671            } else {
672                throw module.createError("getIframeDocument: No Document object found for iframe element");
673            }
674        }
675
676        function getIframeWindow(iframeEl) {
677            if (typeof iframeEl.contentWindow != UNDEF) {
678                return iframeEl.contentWindow;
679            } else if (typeof iframeEl.contentDocument != UNDEF) {
680                return iframeEl.contentDocument.defaultView;
681            } else {

726            var nodeC, root, childA, childB, n;
727            if (nodeA == nodeB) {
728                // Case 1: nodes are the same
729                return offsetA === offsetB ? 0 : (offsetA < offsetB) ? -1 : 1;
730            } else if ( (nodeC = getClosestAncestorIn(nodeB, nodeA, true)) ) {
731                // Case 2: node C (container B or an ancestor) is a child node of A
732                return offsetA <= getNodeIndex(nodeC) ? -1 : 1;
733            } else if ( (nodeC = getClosestAncestorIn(nodeA, nodeB, true)) ) {
734                // Case 3: node C (container A or an ancestor) is a child node of B
735                return getNodeIndex(nodeC) < offsetB  ? -1 : 1;
736            } else {
737                root = getCommonAncestor(nodeA, nodeB);
738                if (!root) {
739                    throw new Error("comparePoints error: nodes have no common ancestor");
740                }
741
742                // Case 4: containers are siblings or descendants of siblings
743                childA = (nodeA === root) ? root : getClosestAncestorIn(nodeA, root, true);
744                childB = (nodeB === root) ? root : getClosestAncestorIn(nodeB, root, true);
745
746                if (childA === childB) {
747                    // This shouldn't be possible
748                    throw module.createError("comparePoints got to case 4 and childA and childB are the same!");
749                } else {
750                    n = root.firstChild;
751                    while (n) {
752                        if (n === childA) {
753                            return -1;
754                        } else if (n === childB) {
755                            return 1;
756                        }
757                        n = n.nextSibling;
758                    }
759                }
760            }
761        }
762
763        /*----------------------------------------------------------------------------------------------------------------*/
764
765        // Test for IE's crash (IE 6/7) or exception (IE >= 8) when a reference to garbage-collected text node is queried
766        var crashyTextNodes = false;
767
768        function isBrokenNode(node) {
769            var n;
770            try {
771                n = node.parentNode;
772                return false;
773            } catch (e) {
774                return true;
775            }
776        }
777
778        (function() {
779            var el = document.createElement("b");
780            el.innerHTML = "1";
781            var textNode = el.firstChild;
782            el.innerHTML = "<br />";
783            crashyTextNodes = isBrokenNode(textNode);
784
785            api.features.crashyTextNodes = crashyTextNodes;
786        })();
787
788        /*----------------------------------------------------------------------------------------------------------------*/
789
790        function inspectNode(node) {
791            if (!node) {
792                return "[No node]";
793            }
794            if (crashyTextNodes && isBrokenNode(node)) {
795                return "[Broken node]";
796            }
797            if (isCharacterDataNode(node)) {
798                return '"' + node.data + '"';
799            }
800            if (node.nodeType == 1) {
801                var idAttr = node.id ? ' id="' + node.id + '"' : "";
802                return "<" + node.nodeName + idAttr + ">[index:" + getNodeIndex(node) + ",length:" + node.childNodes.length + "][" + (node.innerHTML || "[innerHTML not supported]").slice(0, 25) + "]";
803            }
804            return node.nodeName;
805        }
806
807        function fragmentFromNodeChildren(node) {
808            var fragment = getDocument(node).createDocumentFragment(), child;
809            while ( (child = node.firstChild) ) {
810                fragment.appendChild(child);
811            }
812            return fragment;
813        }
814
815        var getComputedStyleProperty;
816        if (typeof window.getComputedStyle != UNDEF) {
817            getComputedStyleProperty = function(el, propName) {
818                return getWindow(el).getComputedStyle(el, null)[propName];
819            };
820        } else if (typeof document.documentElement.currentStyle != UNDEF) {
821            getComputedStyleProperty = function(el, propName) {
822                return el.currentStyle ? el.currentStyle[propName] : "";
823            };
824        } else {
825            module.fail("No means of obtaining computed style properties found");
826        }
827
828        function createTestElement(doc, html, contentEditable) {
829            var body = getBody(doc);
830            var el = doc.createElement("div");
831            el.contentEditable = "" + !!contentEditable;
832            if (html) {
833                el.innerHTML = html;
834            }
835
836            // Insert the test element at the start of the body to prevent scrolling to the bottom in iOS (issue #292)
837            var bodyFirstChild = body.firstChild;
838            if (bodyFirstChild) {
839                body.insertBefore(el, bodyFirstChild);
840            } else {
841                body.appendChild(el);
842            }
843
844            return el;
845        }
846
847        function removeNode(node) {
848            return node.parentNode.removeChild(node);
849        }
850
851        function NodeIterator(root) {
852            this.root = root;
853            this._next = root;
854        }
855
856        NodeIterator.prototype = {
857            _current: null,
858
859            hasNext: function() {
860                return !!this._next;
861            },
862
863            next: function() {
864                var n = this._current = this._next;
865                var child, next;
866                if (this._current) {
867                    child = n.firstChild;
868                    if (child) {
869                        this._next = child;
870                    } else {
871                        next = null;
872                        while ((n !== this.root) && !(next = n.nextSibling)) {
873                            n = n.parentNode;
874                        }
875                        this._next = next;
876                    }
877                }
878                return this._current;
879            },
880
881            detach: function() {
882                this._current = this._next = this.root = null;
883            }
884        };
885
886        function createIterator(root) {
887            return new NodeIterator(root);
888        }
889
890        function DomPosition(node, offset) {
891            this.node = node;
892            this.offset = offset;
893        }
894
895        DomPosition.prototype = {
896            equals: function(pos) {
897                return !!pos && this.node === pos.node && this.offset == pos.offset;
898            },
899
900            inspect: function() {
901                return "[DomPosition(" + inspectNode(this.node) + ":" + this.offset + ")]";
902            },
903
904            toString: function() {
905                return this.inspect();
906            }
907        };
908
909        function DOMException(codeName) {
910            this.code = this[codeName];
911            this.codeName = codeName;
912            this.message = "DOMException: " + this.codeName;
913        }
914
915        DOMException.prototype = {
916            INDEX_SIZE_ERR: 1,
917            HIERARCHY_REQUEST_ERR: 3,
918            WRONG_DOCUMENT_ERR: 4,
919            NO_MODIFICATION_ALLOWED_ERR: 7,
920            NOT_FOUND_ERR: 8,
921            NOT_SUPPORTED_ERR: 9,
922            INVALID_STATE_ERR: 11,
923            INVALID_NODE_TYPE_ERR: 24
924        };
925
926        DOMException.prototype.toString = function() {
927            return this.message;
928        };
929
930        api.dom = {
931            arrayContains: arrayContains,
932            isHtmlNamespace: isHtmlNamespace,
933            parentElement: parentElement,
934            getNodeIndex: getNodeIndex,
935            getNodeLength: getNodeLength,
936            getCommonAncestor: getCommonAncestor,
937            isAncestorOf: isAncestorOf,
938            isOrIsAncestorOf: isOrIsAncestorOf,
939            getClosestAncestorIn: getClosestAncestorIn,
940            isCharacterDataNode: isCharacterDataNode,
941            isTextOrCommentNode: isTextOrCommentNode,
942            insertAfter: insertAfter,
943            splitDataNode: splitDataNode,
944            getDocument: getDocument,
945            getWindow: getWindow,
946            getIframeWindow: getIframeWindow,
947            getIframeDocument: getIframeDocument,
948            getBody: getBody,
949            isWindow: isWindow,
950            getContentDocument: getContentDocument,
951            getRootContainer: getRootContainer,
952            comparePoints: comparePoints,
953            isBrokenNode: isBrokenNode,
954            inspectNode: inspectNode,
955            getComputedStyleProperty: getComputedStyleProperty,
956            createTestElement: createTestElement,
957            removeNode: removeNode,
958            fragmentFromNodeChildren: fragmentFromNodeChildren,
959            createIterator: createIterator,
960            DomPosition: DomPosition
961        };
962
963        api.DOMException = DOMException;
964    });
965
966    /*----------------------------------------------------------------------------------------------------------------*/
967
968    // Pure JavaScript implementation of DOM Range
969    api.createCoreModule("DomRange", ["DomUtil"], function(api, module) {
970        var dom = api.dom;
971        var util = api.util;
972        var DomPosition = dom.DomPosition;
973        var DOMException = api.DOMException;
974
975        var isCharacterDataNode = dom.isCharacterDataNode;
976        var getNodeIndex = dom.getNodeIndex;
977        var isOrIsAncestorOf = dom.isOrIsAncestorOf;
978        var getDocument = dom.getDocument;
979        var comparePoints = dom.comparePoints;
980        var splitDataNode = dom.splitDataNode;
981        var getClosestAncestorIn = dom.getClosestAncestorIn;
982        var getNodeLength = dom.getNodeLength;
983        var arrayContains = dom.arrayContains;
984        var getRootContainer = dom.getRootContainer;
985        var crashyTextNodes = api.features.crashyTextNodes;
986
987        var removeNode = dom.removeNode;
988
989        /*----------------------------------------------------------------------------------------------------------------*/
990
991        // Utility functions
992
993        function isNonTextPartiallySelected(node, range) {
994            return (node.nodeType != 3) &&
995                   (isOrIsAncestorOf(node, range.startContainer) || isOrIsAncestorOf(node, range.endContainer));
996        }
997
998        function getRangeDocument(range) {
999            return range.document || getDocument(range.startContainer);
1000        }
1001
1002        function getRangeRoot(range) {
1003            return getRootContainer(range.startContainer);
1004        }
1005
1006        function getBoundaryBeforeNode(node) {
1007            return new DomPosition(node.parentNode, getNodeIndex(node));
1008        }
1009
1010        function getBoundaryAfterNode(node) {
1011            return new DomPosition(node.parentNode, getNodeIndex(node) + 1);
1012        }
1013
1014        function insertNodeAtPosition(node, n, o) {
1015            var firstNodeInserted = node.nodeType == 11 ? node.firstChild : node;
1016            if (isCharacterDataNode(n)) {
1017                if (o == n.length) {
1018                    dom.insertAfter(node, n);
1019                } else {
1020                    n.parentNode.insertBefore(node, o == 0 ? n : splitDataNode(n, o));
1021                }
1022            } else if (o >= n.childNodes.length) {
1023                n.appendChild(node);
1024            } else {
1025                n.insertBefore(node, n.childNodes[o]);
1026            }
1027            return firstNodeInserted;
1028        }
1029
1030        function rangesIntersect(rangeA, rangeB, touchingIsIntersecting) {
1031            assertRangeValid(rangeA);
1032            assertRangeValid(rangeB);
1033
1034            if (getRangeDocument(rangeB) != getRangeDocument(rangeA)) {
1035                throw new DOMException("WRONG_DOCUMENT_ERR");
1036            }
1037
1038            var startComparison = comparePoints(rangeA.startContainer, rangeA.startOffset, rangeB.endContainer, rangeB.endOffset),
1039                endComparison = comparePoints(rangeA.endContainer, rangeA.endOffset, rangeB.startContainer, rangeB.startOffset);
1040
1041            return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;
1042        }
1043
1044        function cloneSubtree(iterator) {
1045            var partiallySelected;
1046            for (var node, frag = getRangeDocument(iterator.range).createDocumentFragment(), subIterator; node = iterator.next(); ) {
1047                partiallySelected = iterator.isPartiallySelectedSubtree();
1048                node = node.cloneNode(!partiallySelected);
1049                if (partiallySelected) {
1050                    subIterator = iterator.getSubtreeIterator();
1051                    node.appendChild(cloneSubtree(subIterator));
1052                    subIterator.detach();
1053                }
1054
1055                if (node.nodeType == 10) { // DocumentType
1056                    throw new DOMException("HIERARCHY_REQUEST_ERR");
1057                }
1058                frag.appendChild(node);
1059            }
1060            return frag;
1061        }
1062
1063        function iterateSubtree(rangeIterator, func, iteratorState) {
1064            var it, n;
1065            iteratorState = iteratorState || { stop: false };
1066            for (var node, subRangeIterator; node = rangeIterator.next(); ) {
1067                if (rangeIterator.isPartiallySelectedSubtree()) {
1068                    if (func(node) === false) {
1069                        iteratorState.stop = true;
1070                        return;
1071                    } else {
1072                        // The node is partially selected by the Range, so we can use a new RangeIterator on the portion of
1073                        // the node selected by the Range.
1074                        subRangeIterator = rangeIterator.getSubtreeIterator();
1075                        iterateSubtree(subRangeIterator, func, iteratorState);
1076                        subRangeIterator.detach();
1077                        if (iteratorState.stop) {
1078                            return;
1079                        }
1080                    }
1081                } else {
1082                    // The whole node is selected, so we can use efficient DOM iteration to iterate over the node and its

1591: "";
1592                } else {
1593                    var textParts = [], iterator = new RangeIterator(this, true);
1594                    iterateSubtree(iterator, function(node) {
1595                        // Accept only text or CDATA nodes, not comments
1596                        if (node.nodeType == 3 || node.nodeType == 4) {
1597                            textParts.push(node.data);
1598                        }
1599                    });
1600                    iterator.detach();
1601                    return textParts.join("");
1602                }
1603            },
1604
1605            // The methods below are all non-standard. The following batch were introduced by Mozilla but have since
1606            // been removed from Mozilla.
1607
1608            compareNode: function(node) {
1609                assertRangeValid(this);
1610
1611                var parent = node.parentNode;
1612                var nodeIndex = getNodeIndex(node);
1613
1614                if (!parent) {
1615                    throw new DOMException("NOT_FOUND_ERR");
1616                }
1617
1618                var startComparison = this.comparePoint(parent, nodeIndex),
1619                    endComparison = this.comparePoint(parent, nodeIndex + 1);
1620
1621                if (startComparison < 0) { // Node starts before
1622                    return (endComparison > 0) ? n_b_a : n_b;
1623                } else {
1624                    return (endComparison > 0) ? n_a : n_i;
1625                }
1626            },
1627
1628            comparePoint: function(node, offset) {
1629                assertRangeValid(this);
1630                assertNode(node, "HIERARCHY_REQUEST_ERR");
1631                assertSameDocumentOrFragment(node, this.startContainer);
1632
1633                if (comparePoints(node, offset, this.startContainer, this.startOffset) < 0) {
1634                    return -1;
1635                } else if (comparePoints(node, offset, this.endContainer, this.endOffset) > 0) {
1636                    return 1;
1637                }
1638                return 0;
1639            },
1640
1641            createContextualFragment: createContextualFragment,
1642
1643            toHtml: function() {
1644                return rangeToHtml(this);
1645            },
1646
1647            // touchingIsIntersecting determines whether this method considers a node that borders a range intersects
1648            // with it (as in WebKit) or not (as in Gecko pre-1.9, and the default)
1649            intersectsNode: function(node, touchingIsIntersecting) {
1650                assertRangeValid(this);
1651                if (getRootContainer(node) != getRangeRoot(this)) {
1652                    return false;
1653                }
1654
1655                var parent = node.parentNode, offset = getNodeIndex(node);
1656                if (!parent) {
1657                    return true;
1658                }
1659
1660                var startComparison = comparePoints(parent, offset, this.endContainer, this.endOffset),
1661                    endComparison = comparePoints(parent, offset + 1, this.startContainer, this.startOffset);
1662
1663                return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;
1664            },
1665
1666            isPointInRange: function(node, offset) {
1667                assertRangeValid(this);
1668                assertNode(node, "HIERARCHY_REQUEST_ERR");
1669                assertSameDocumentOrFragment(node, this.startContainer);
1670
1671                return (comparePoints(node, offset, this.startContainer, this.startOffset) >= 0) &&
1672                       (comparePoints(node, offset, this.endContainer, this.endOffset) <= 0);
1673            },
1674
1675            // The methods below are non-standard and invented by me.
1676
1677            // Sharing a boundary start-to-end or end-to-start does not count as intersection.
1678            intersectsRange: function(range) {
1679                return rangesIntersect(this, range, false);
1680            },
1681
1682            // Sharing a boundary start-to-end or end-to-start does count as intersection.
1683            intersectsOrTouchesRange: function(range) {
1684                return rangesIntersect(this, range, true);
1685            },
1686
1687            intersection: function(range) {
1688                if (this.intersectsRange(range)) {
1689                    var startComparison = comparePoints(this.startContainer, this.startOffset, range.startContainer, range.startOffset),
1690                        endComparison = comparePoints(this.endContainer, this.endOffset, range.endContainer, range.endOffset);
1691
1692                    var intersectionRange = this.cloneRange();
1693                    if (startComparison == -1) {
1694                        intersectionRange.setStart(range.startContainer, range.startOffset);
1695                    }
1696                    if (endComparison == 1) {
1697                        intersectionRange.setEnd(range.endContainer, range.endOffset);
1698                    }
1699                    return intersectionRange;
1700                }
1701                return null;
1702            },
1703
1704            union: function(range) {
1705                if (this.intersectsOrTouchesRange(range)) {
1706                    var unionRange = this.cloneRange();
1707                    if (comparePoints(range.startContainer, range.startOffset, this.startContainer, this.startOffset) == -1) {
1708                        unionRange.setStart(range.startContainer, range.startOffset);
1709                    }
1710                    if (comparePoints(range.endContainer, range.endOffset, this.endContainer, this.endOffset) == 1) {
1711                        unionRange.setEnd(range.endContainer, range.endOffset);
1712                    }
1713                    return unionRange;
1714                } else {
1715                    throw new DOMException("Ranges do not intersect");
1716                }
1717            },
1718
1719            containsNode: function(node, allowPartial) {
1720                if (allowPartial) {
1721                    return this.intersectsNode(node, false);
1722                } else {
1723                    return this.compareNode(node) == n_i;
1724                }
1725            },
1726
1727            containsNodeContents: function(node) {
1728                return this.comparePoint(node, 0) >= 0 && this.comparePoint(node, getNodeLength(node)) <= 0;
1729            },
1730
1731            containsRange: function(range) {
1732                var intersection = this.intersection(range);
1733                return intersection !== null && range.equals(intersection);
1734            },
1735
1736            containsNodeText: function(node) {
1737                var nodeRange = this.cloneRange();
1738                nodeRange.selectNode(node);
1739                var textNodes = nodeRange.getNodes([3]);
1740                if (textNodes.length > 0) {
1741                    nodeRange.setStart(textNodes[0], 0);
1742                    var lastTextNode = textNodes.pop();
1743                    nodeRange.setEnd(lastTextNode, lastTextNode.length);
1744                    return this.containsRange(nodeRange);
1745                } else {
1746                    return this.containsNodeContents(node);
1747                }
1748            },
1749
1750            getNodes: function(nodeTypes, filter) {
1751                assertRangeValid(this);
1752                return getNodesInRange(this, nodeTypes, filter);
1753            },
1754
1755            getDocument: function() {
1756                return getRangeDocument(this);
1757            },
1758
1759            collapseBefore: function(node) {
1760                this.setEndBefore(node);
1761                this.collapse(false);
1762            },
1763
1764            collapseAfter: function(node) {
1765                this.setStartAfter(node);
1766                this.collapse(true);
1767            },
1768
1769            getBookmark: function(containerNode) {
1770                var doc = getRangeDocument(this);
1771                var preSelectionRange = api.createRange(doc);
1772                containerNode = containerNode || dom.getBody(doc);
1773                preSelectionRange.selectNodeContents(containerNode);
1774                var range = this.intersection(preSelectionRange);
1775                var start = 0, end = 0;
1776                if (range) {
1777                    preSelectionRange.setEnd(range.startContainer, range.startOffset);
1778                    start = preSelectionRange.toString().length;
1779                    end = start + range.toString().length;
1780                }
1781
1782                return {
1783                    start: start,
1784                    end: end,
1785                    containerNode: containerNode
1786                };
1787            },
1788
1789            moveToBookmark: function(bookmark) {
1790                var containerNode = bookmark.containerNode;
1791                var charIndex = 0;
1792                this.setStart(containerNode, 0);
1793                this.collapse(true);
1794                var nodeStack = [containerNode], node, foundStart = false, stop = false;
1795                var nextCharIndex, i, childNodes;
1796
1797                while (!stop && (node = nodeStack.pop())) {
1798                    if (node.nodeType == 3) {
1799                        nextCharIndex = charIndex + node.length;
1800                        if (!foundStart && bookmark.start >= charIndex && bookmark.start <= nextCharIndex) {
1801                            this.setStart(node, bookmark.start - charIndex);
1802                            foundStart = true;
1803                        }
1804                        if (foundStart && bookmark.end >= charIndex && bookmark.end <= nextCharIndex) {
1805                            this.setEnd(node, bookmark.end - charIndex);
1806                            stop = true;
1807                        }
1808                        charIndex = nextCharIndex;
1809                    } else {
1810                        childNodes = node.childNodes;
1811                        i = childNodes.length;
1812                        while (i--) {
1813                            nodeStack.push(childNodes[i]);
1814                        }
1815                    }
1816                }
1817            },
1818
1819            getName: function() {
1820                return "DomRange";
1821            },
1822
1823            equals: function(range) {
1824                return Range.rangesEqual(this, range);
1825            },
1826
1827            isValid: function() {
1828                return isRangeValid(this);
1829            },
1830
1831            inspect: function() {
1832                return inspect(this);
1833            },
1834
1835            detach: function() {
1836                // In DOM4, detach() is now a no-op.
1837            }
1838        });
1839
1840        function copyComparisonConstantsToObject(obj) {
1841            obj.START_TO_START = s2s;
1842            obj.START_TO_END = s2e;
1843            obj.END_TO_END = e2e;
1844            obj.END_TO_START = e2s;
1845
1846            obj.NODE_BEFORE = n_b;
1847            obj.NODE_AFTER = n_a;
1848            obj.NODE_BEFORE_AND_AFTER = n_b_a;
1849            obj.NODE_INSIDE = n_i;
1850        }
1851
1852        function copyComparisonConstants(constructor) {
1853            copyComparisonConstantsToObject(constructor);
1854            copyComparisonConstantsToObject(constructor.prototype);
1855        }
1856
1857        function createRangeContentRemover(remover, boundaryUpdater) {
1858            return function() {
1859                assertRangeValid(this);
1860
1861                var sc = this.startContainer, so = this.startOffset, root = this.commonAncestorContainer;
1862
1863                var iterator = new RangeIterator(this, true);
1864
1865                // Work out where to position the range after content removal
1866                var node, boundary;
1867                if (sc !== root) {
1868                    node = getClosestAncestorIn(sc, root, true);
1869                    boundary = getBoundaryAfterNode(node);
1870                    sc = boundary.node;
1871                    so = boundary.offset;
1872                }
1873
1874                // Check none of the range is read-only
1875                iterateSubtree(iterator, assertNodeNotReadOnly);
1876
1877                iterator.reset();
1878
1879                // Remove the content
1880                var returnValue = remover(iterator);
1881                iterator.detach();
1882
1883                // Move to the new position
1884                boundaryUpdater(this, sc, so, sc, so);
1885
1886                return returnValue;
1887            };
1888        }
1889
1890        function createPrototypeRange(constructor, boundaryUpdater) {
1891            function createBeforeAfterNodeSetter(isBefore, isStart) {
1892                return function(node) {
1893                    assertValidNodeType(node, beforeAfterNodeTypes);
1894                    assertValidNodeType(getRootContainer(node), rootContainerNodeTypes);
1895
1896                    var boundary = (isBefore ? getBoundaryBeforeNode : getBoundaryAfterNode)(node);
1897                    (isStart ? setRangeStart : setRangeEnd)(this, boundary.node, boundary.offset);
1898                };
1899            }
1900
1901            function setRangeStart(range, node, offset) {
1902                var ec = range.endContainer, eo = range.endOffset;
1903                if (node !== range.startContainer || offset !== range.startOffset) {
1904                    // Check the root containers of the range and the new boundary, and also check whether the new boundary
1905                    // is after the current end. In either case, collapse the range to the new position
1906                    if (getRootContainer(node) != getRootContainer(ec) || comparePoints(node, offset, ec, eo) == 1) {
1907                        ec = node;
1908                        eo = offset;
1909                    }
1910                    boundaryUpdater(range, node, offset, ec, eo);
1911                }
1912            }
1913
1914            function setRangeEnd(range, node, offset) {
1915                var sc = range.startContainer, so = range.startOffset;
1916                if (node !== range.endContainer || offset !== range.endOffset) {
1917                    // Check the root containers of the range and the new boundary, and also check whether the new boundary
1918                    // is after the current end. In either case, collapse the range to the new position
1919                    if (getRootContainer(node) != getRootContainer(sc) || comparePoints(node, offset, sc, so) == -1) {
1920                        sc = node;
1921                        so = offset;
1922                    }
1923                    boundaryUpdater(range, sc, so, node, offset);
1924                }
1925            }
1926
1927            // Set up inheritance
1928            var F = function() {};
1929            F.prototype = api.rangePrototype;
1930            constructor.prototype = new F();
1931
1932            util.extend(constructor.prototype, {
1933                setStart: function(node, offset) {
1934                    assertNoDocTypeNotationEntityAncestor(node, true);
1935                    assertValidOffset(node, offset);
1936
1937                    setRangeStart(this, node, offset);
1938                },
1939
1940                setEnd: function(node, offset) {
1941                    assertNoDocTypeNotationEntityAncestor(node, true);
1942                    assertValidOffset(node, offset);
1943
1944                    setRangeEnd(this, node, offset);
1945                },
1946
1947                /**
1948                 * Convenience method to set a range's start and end boundaries. Overloaded as follows:
1949                 * - Two parameters (node, offset) creates a collapsed range at that position
1950                 * - Three parameters (node, startOffset, endOffset) creates a range contained with node starting at
1951                 *   startOffset and ending at endOffset
1952                 * - Four parameters (startNode, startOffset, endNode, endOffset) creates a range starting at startOffset in
1953                 *   startNode and ending at endOffset in endNode
1954                 */
1955                setStartAndEnd: function() {
1956                    var args = arguments;
1957                    var sc = args[0], so = args[1], ec = sc, eo = so;
1958
1959                    switch (args.length) {
1960                        case 3:
1961                            eo = args[2];
1962                            break;
1963                        case 4:
1964                            ec = args[2];
1965                            eo = args[3];
1966                            break;
1967                    }
1968
1969                    boundaryUpdater(this, sc, so, ec, eo);
1970                },
1971
1972                setBoundary: function(node, offset, isStart) {
1973                    this["set" + (isStart ? "Start" : "End")](node, offset);
1974                },
1975
1976                setStartBefore: createBeforeAfterNodeSetter(true, true),
1977                setStartAfter: createBeforeAfterNodeSetter(false, true),
1978                setEndBefore: createBeforeAfterNodeSetter(true, false),
1979                setEndAfter: createBeforeAfterNodeSetter(false, false),
1980
1981                collapse: function(isStart) {
1982                    assertRangeValid(this);
1983                    if (isStart) {
1984                        boundaryUpdater(this, this.startContainer, this.startOffset, this.startContainer, this.startOffset);
1985                    } else {
1986                        boundaryUpdater(this, this.endContainer, this.endOffset, this.endContainer, this.endOffset);
1987                    }
1988                },
1989
1990                selectNodeContents: function(node) {
1991                    assertNoDocTypeNotationEntityAncestor(node, true);
1992
1993                    boundaryUpdater(this, node, 0, node, getNodeLength(node));
1994                },
1995
1996                selectNode: function(node) {
1997                    assertNoDocTypeNotationEntityAncestor(node, false);
1998                    assertValidNodeType(node, beforeAfterNodeTypes);
1999
2000                    var start = getBoundaryBeforeNode(node), end = getBoundaryAfterNode(node);
2001                    boundaryUpdater(this, start.node, start.offset, end.node, end.offset);
2002                },
2003
2004                extractContents: createRangeContentRemover(extractSubtree, boundaryUpdater),
2005
2006                deleteContents: createRangeContentRemover(deleteSubtree, boundaryUpdater),
2007
2008                canSurroundContents: function() {
2009                    assertRangeValid(this);
2010                    assertNodeNotReadOnly(this.startContainer);
2011                    assertNodeNotReadOnly(this.endContainer);
2012
2013                    // Check if the contents can be surrounded. Specifically, this means whether the range partially selects
2014                    // no non-text nodes.
2015                    var iterator = new RangeIterator(this, true);
2016                    var boundariesInvalid = (iterator._first && isNonTextPartiallySelected(iterator._first, this) ||
2017                            (iterator._last && isNonTextPartiallySelected(iterator._last, this)));
2018                    iterator.detach();
2019                    return !boundariesInvalid;
2020                },
2021
2022                splitBoundaries: function() {
2023                    splitRangeBoundaries(this);
2024                },
2025
2026                splitBoundariesPreservingPositions: function(positionsToPreserve) {
2027                    splitRangeBoundaries(this, positionsToPreserve);
2028                },
2029
2030                normalizeBoundaries: function() {
2031                    assertRangeValid(this);
2032
2033                    var sc = this.startContainer, so = this.startOffset, ec = this.endContainer, eo = this.endOffset;
2034
2035                    var mergeForward = function(node) {
2036                        var sibling = node.nextSibling;
2037                        if (sibling && sibling.nodeType == node.nodeType) {
2038                            ec = node;
2039                            eo = node.length;
2040                            node.appendData(sibling.data);
2041                            removeNode(sibling);
2042                        }
2043                    };
2044
2045                    var mergeBackward = function(node) {
2046                        var sibling = node.previousSibling;
2047                        if (sibling && sibling.nodeType == node.nodeType) {
2048                            sc = node;
2049                            var nodeLength = node.length;
2050                            so = sibling.length;
2051                            node.insertData(0, sibling.data);
2052                            removeNode(sibling);
2053                            if (sc == ec) {
2054                                eo += so;
2055                                ec = sc;
2056                            } else if (ec == node.parentNode) {
2057                                var nodeIndex = getNodeIndex(node);
2058                                if (eo == nodeIndex) {
2059                                    ec = node;
2060                                    eo = nodeLength;
2061                                } else if (eo > nodeIndex) {
2062                                    eo--;
2063                                }
2064                            }
2065                        }
2066                    };
2067
2068                    var normalizeStart = true;
2069                    var sibling;
2070
2071                    if (isCharacterDataNode(ec)) {
2072                        if (eo == ec.length) {
2073                            mergeForward(ec);
2074                        } else if (eo == 0) {
2075                            sibling = ec.previousSibling;
2076                            if (sibling && sibling.nodeType == ec.nodeType) {
2077                                eo = sibling.length;
2078                                if (sc == ec) {
2079                                    normalizeStart = false;

2257                // insertNode() is never delegated to the native range.
2258
2259                rangeProto.surroundContents = function(node) {
2260                    this.nativeRange.surroundContents(node);
2261                    updateRangeProperties(this);
2262                };
2263
2264                rangeProto.collapse = function(isStart) {
2265                    this.nativeRange.collapse(isStart);
2266                    updateRangeProperties(this);
2267                };
2268
2269                rangeProto.cloneRange = function() {
2270                    return new WrappedRange(this.nativeRange.cloneRange());
2271                };
2272
2273                rangeProto.refresh = function() {
2274                    updateRangeProperties(this);
2275                };
2276
2277                rangeProto.toString = function() {
2278                    return this.nativeRange.toString();
2279                };
2280
2281                // Create test range and node for feature detection
2282
2283                var testTextNode = document.createTextNode("test");
2284                getBody(document).appendChild(testTextNode);
2285                var range = document.createRange();
2286
2287                /*--------------------------------------------------------------------------------------------------------*/
2288
2289                // Test for Firefox 2 bug that prevents moving the start of a Range to a point after its current end and
2290                // correct for it
2291
2292                range.setStart(testTextNode, 0);
2293                range.setEnd(testTextNode, 0);
2294
2295                try {
2296                    range.setStart(testTextNode, 1);
2297
2298                    rangeProto.setStart = function(node, offset) {
2299                        this.nativeRange.setStart(node, offset);
2300                        updateRangeProperties(this);
2301                    };
2302
2303                    rangeProto.setEnd = function(node, offset) {
2304                        this.nativeRange.setEnd(node, offset);
2305                        updateRangeProperties(this);
2306                    };
2307
2308                    createBeforeAfterNodeSetter = function(name) {
2309                        return function(node) {
2310                            this.nativeRange[name](node);
2311                            updateRangeProperties(this);
2312                        };
2313                    };
2314
2315                } catch(ex) {
2316
2317                    rangeProto.setStart = function(node, offset) {
2318                        try {
2319                            this.nativeRange.setStart(node, offset);
2320                        } catch (ex) {
2321                            this.nativeRange.setEnd(node, offset);
2322                            this.nativeRange.setStart(node, offset);
2323                        }
2324                        updateRangeProperties(this);
2325                    };
2326
2327                    rangeProto.setEnd = function(node, offset) {
2328                        try {
2329                            this.nativeRange.setEnd(node, offset);
2330                        } catch (ex) {
2331                            this.nativeRange.setStart(node, offset);
2332                            this.nativeRange.setEnd(node, offset);
2333                        }
2334                        updateRangeProperties(this);
2335                    };
2336
2337                    createBeforeAfterNodeSetter = function(name, oppositeName) {
2338                        return function(node) {
2339                            try {
2340                                this.nativeRange[name](node);
2341                            } catch (ex) {
2342                                this.nativeRange[oppositeName](node);
2343                                this.nativeRange[name](node);
2344                            }
2345                            updateRangeProperties(this);
2346                        };
2347                    };
2348                }
2349
2350                rangeProto.setStartBefore = createBeforeAfterNodeSetter("setStartBefore", "setEndBefore");
2351                rangeProto.setStartAfter = createBeforeAfterNodeSetter("setStartAfter", "setEndAfter");
2352                rangeProto.setEndBefore = createBeforeAfterNodeSetter("setEndBefore", "setStartBefore");
2353                rangeProto.setEndAfter = createBeforeAfterNodeSetter("setEndAfter", "setStartAfter");
2354
2355                /*--------------------------------------------------------------------------------------------------------*/
2356
2357                // Always use DOM4-compliant selectNodeContents implementation: it's simpler and less code than testing
2358                // whether the native implementation can be trusted
2359                rangeProto.selectNodeContents = function(node) {
2360                    this.setStartAndEnd(node, 0, dom.getNodeLength(node));
2361                };
2362
2363                /*--------------------------------------------------------------------------------------------------------*/
2364
2365                // Test for and correct WebKit bug that has the behaviour of compareBoundaryPoints round the wrong way for
2366                // constants START_TO_END and END_TO_START: https://bugs.webkit.org/show_bug.cgi?id=20738
2367
2368                range.selectNodeContents(testTextNode);
2369                range.setEnd(testTextNode, 3);
2370
2371                var range2 = document.createRange();
2372                range2.selectNodeContents(testTextNode);
2373                range2.setEnd(testTextNode, 4);
2374                range2.setStart(testTextNode, 2);
2375
2376                if (range.compareBoundaryPoints(range.START_TO_END, range2) == -1 &&
2377                        range.compareBoundaryPoints(range.END_TO_START, range2) == 1) {
2378                    // This is the wrong way round, so correct for it
2379
2380                    rangeProto.compareBoundaryPoints = function(type, range) {
2381                        range = range.nativeRange || range;
2382                        if (type == range.START_TO_END) {
2383                            type = range.END_TO_START;
2384                        } else if (type == range.END_TO_START) {
2385                            type = range.START_TO_END;
2386                        }
2387                        return this.nativeRange.compareBoundaryPoints(type, range);
2388                    };
2389                } else {
2390                    rangeProto.compareBoundaryPoints = function(type, range) {
2391                        return this.nativeRange.compareBoundaryPoints(type, range.nativeRange || range);
2392                    };
2393                }
2394
2395                /*--------------------------------------------------------------------------------------------------------*/
2396
2397                // Test for IE deleteContents() and extractContents() bug and correct it. See issue 107.
2398
2399                var el = document.createElement("div");
2400                el.innerHTML = "123";
2401                var textNode = el.firstChild;
2402                var body = getBody(document);
2403                body.appendChild(el);
2404
2405                range.setStart(textNode, 1);
2406                range.setEnd(textNode, 2);
2407                range.deleteContents();
2408
2409                if (textNode.data == "13") {
2410                    // Behaviour is correct per DOM4 Range so wrap the browser's implementation of deleteContents() and
2411                    // extractContents()
2412                    rangeProto.deleteContents = function() {
2413                        this.nativeRange.deleteContents();
2414                        updateRangeProperties(this);
2415                    };
2416
2417                    rangeProto.extractContents = function() {
2418                        var frag = this.nativeRange.extractContents();
2419                        updateRangeProperties(this);
2420                        return frag;
2421                    };
2422                } else {
2423                }
2424
2425                body.removeChild(el);
2426                body = null;
2427
2428                /*--------------------------------------------------------------------------------------------------------*/
2429
2430                // Test for existence of createContextualFragment and delegate to it if it exists
2431                if (util.isHostMethod(range, "createContextualFragment")) {
2432                    rangeProto.createContextualFragment = function(fragmentStr) {
2433                        return this.nativeRange.createContextualFragment(fragmentStr);
2434                    };
2435                }
2436
2437                /*--------------------------------------------------------------------------------------------------------*/
2438
2439                // Clean up
2440                getBody(document).removeChild(testTextNode);
2441
2442                rangeProto.getName = function() {
2443                    return "WrappedRange";
2444                };
2445
2446                api.WrappedRange = WrappedRange;
2447
2448                api.createNativeRange = function(doc) {
2449                    doc = getContentDocument(doc, module, "createNativeRange");
2450                    return doc.createRange();
2451                };
2452            })();
2453        }
2454
2455        if (api.features.implementsTextRange) {
2456            /*
2457            This is a workaround for a bug where IE returns the wrong container element from the TextRange's parentElement()
2458            method. For example, in the following (where pipes denote the selection boundaries):
2459
2460            <ul id="ul"><li id="a">| a </li><li id="b"> b |</li></ul>
2461
2462            var range = document.selection.createRange();
2463            alert(range.parentElement().id); // Should alert "ul" but alerts "b"
2464
2465            This method returns the common ancestor node of the following:
2466            - the parentElement() of the textRange
2467            - the parentElement() of the textRange after calling collapse(true)
2468            - the parentElement() of the textRange after calling collapse(false)
2469            */
2470            var getTextRangeContainerElement = function(textRange) {
2471                var parentEl = textRange.parentElement();
2472                var range = textRange.duplicate();
2473                range.collapse(true);
2474                var startEl = range.parentElement();
2475                range = textRange.duplicate();
2476                range.collapse(false);
2477                var endEl = range.parentElement();
2478                var startEndContainer = (startEl == endEl) ? startEl : dom.getCommonAncestor(startEl, endEl);
2479
2480                return startEndContainer == parentEl ? startEndContainer : dom.getCommonAncestor(parentEl, startEndContainer);
2481            };
2482
2483            var textRangeIsCollapsed = function(textRange) {
2484                return textRange.compareEndPoints("StartToEnd", textRange) == 0;
2485            };
2486
2487            // Gets the boundary of a TextRange expressed as a node and an offset within that node. This function started
2488            // out as an improved version of code found in Tim Cameron Ryan's IERange (http://code.google.com/p/ierange/)
2489            // but has grown, fixing problems with line breaks in preformatted text, adding workaround for IE TextRange
2490            // bugs, handling for inputs and images, plus optimizations.
2491            var getTextRangeBoundaryPosition = function(textRange, wholeRangeContainerElement, isStart, isCollapsed, startInfo) {
2492                var workingRange = textRange.duplicate();
2493                workingRange.collapse(isStart);
2494                var containerElement = workingRange.parentElement();
2495
2496                // Sometimes collapsing a TextRange that's at the start of a text node can move it into the previous node, so
2497                // check for that
2498                if (!dom.isOrIsAncestorOf(wholeRangeContainerElement, containerElement)) {
2499                    containerElement = wholeRangeContainerElement;
2500                }
2501
2502
2503                // Deal with nodes that cannot "contain rich HTML markup". In practice, this means form inputs, images and