1
// Copyright 2007 The Closure Library Authors. All Rights Reserved.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS-IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
/**
16
 * @fileoverview Definition of the IE browser specific range wrapper.
17
 * @suppress {missingRequire} Cannot depend on goog.dom.browserrange because it
18
 *     creates a circular dependency.
19
 *
20
 * DO NOT USE THIS FILE DIRECTLY.  Use goog.dom.Range instead.
21
 *
22
 * @author [email protected] (Robby Walker)
23
 */
24

25

26
goog.provide('goog.dom.browserrange.IeRange');
27

28
goog.require('goog.array');
29
goog.require('goog.dom');
30
goog.require('goog.dom.NodeType');
31
goog.require('goog.dom.RangeEndpoint');
32
goog.require('goog.dom.TagName');
33
goog.require('goog.dom.browserrange.AbstractRange');
34
goog.require('goog.log');
35
goog.require('goog.string');
36

37

38

39
/**
40
 * The constructor for IE specific browser ranges.
41
 * @param {TextRange} range The range object.
42
 * @param {Document} doc The document the range exists in.
43
 * @constructor
44
 * @extends {goog.dom.browserrange.AbstractRange}
45
 * @final
46
 */
47
goog.dom.browserrange.IeRange = function(range, doc) {
48
  /**
49
   * Lazy cache of the node containing the entire selection.
50
   * @private {Node}
51
   */
52
  this.parentNode_ = null;
53

54
  /**
55
   * Lazy cache of the node containing the start of the selection.
56
   * @private {Node}
57
   */
58
  this.startNode_ = null;
59

60
  /**
61
   * Lazy cache of the node containing the end of the selection.
62
   * @private {Node}
63
   */
64
  this.endNode_ = null;
65

66
  /**
67
   * Lazy cache of the offset in startNode_ where this range starts.
68
   * @private {number}
69
   */
70
  this.startOffset_ = -1;
71

72
  /**
73
   * Lazy cache of the offset in endNode_ where this range ends.
74
   * @private {number}
75
   */
76
  this.endOffset_ = -1;
77

78
  /**
79
   * The browser range object this class wraps.
80
   * @private {TextRange}
81
   */
82
  this.range_ = range;
83

84
  /**
85
   * The document the range exists in.
86
   * @private {Document}
87
   */
88
  this.doc_ = doc;
89
};
90
goog.inherits(
91
    goog.dom.browserrange.IeRange, goog.dom.browserrange.AbstractRange);
92

93

94
/**
95
 * Logging object.
96
 * @type {goog.log.Logger}
97
 * @private
98
 */
99
goog.dom.browserrange.IeRange.logger_ =
100
    goog.log.getLogger('goog.dom.browserrange.IeRange');
101

102

103
/**
104
 * Returns a browser range spanning the given node's contents.
105
 * @param {Node} node The node to select.
106
 * @return {!TextRange} A browser range spanning the node's contents.
107
 * @private
108
 */
109
goog.dom.browserrange.IeRange.getBrowserRangeForNode_ = function(node) {
110
  var nodeRange = goog.dom.getOwnerDocument(node).body.createTextRange();
111
  if (node.nodeType == goog.dom.NodeType.ELEMENT) {
112
    // Elements are easy.
113
    nodeRange.moveToElementText(node);
114
    // Note(user) : If there are no child nodes of the element, the
115
    // range.htmlText includes the element's outerHTML. The range created above
116
    // is not collapsed, and should be collapsed explicitly.
117
    // Example : node = <div></div>
118
    // But if the node is sth like <br>, it shouldn't be collapsed.
119
    if (goog.dom.browserrange.canContainRangeEndpoint(node) &&
120
        !node.childNodes.length) {
121
      nodeRange.collapse(false);
122
    }
123
  } else {
124
    // Text nodes are hard.
125
    // Compute the offset from the nearest element related position.
126
    var offset = 0;
127
    var sibling = node;
128
    while (sibling = sibling.previousSibling) {
129
      var nodeType = sibling.nodeType;
130
      if (nodeType == goog.dom.NodeType.TEXT) {
131
        offset += sibling.length;
132
      } else if (nodeType == goog.dom.NodeType.ELEMENT) {
133
        // Move to the space after this element.
134
        nodeRange.moveToElementText(sibling);
135
        break;
136
      }
137
    }
138

139
    if (!sibling) {
140
      nodeRange.moveToElementText(node.parentNode);
141
    }
142

143
    nodeRange.collapse(!sibling);
144

145
    if (offset) {
146
      nodeRange.move('character', offset);
147
    }
148

149
    nodeRange.moveEnd('character', node.length);
150
  }
151

152
  return nodeRange;
153
};
154

155

156
/**
157
 * Returns a browser range spanning the given nodes.
158
 * @param {Node} startNode The node to start with.
159
 * @param {number} startOffset The offset within the start node.
160
 * @param {Node} endNode The node to end with.
161
 * @param {number} endOffset The offset within the end node.
162
 * @return {!TextRange} A browser range spanning the node's contents.
163
 * @private
164
 */
165
goog.dom.browserrange.IeRange.getBrowserRangeForNodes_ = function(
166
    startNode, startOffset, endNode, endOffset) {
167
  // Create a range starting at the correct start position.
168
  var child, collapse = false;
169
  if (startNode.nodeType == goog.dom.NodeType.ELEMENT) {
170
    if (startOffset > startNode.childNodes.length) {
171
      goog.log.error(
172
          goog.dom.browserrange.IeRange.logger_,
173
          'Cannot have startOffset > startNode child count');
174
    }
175
    child = startNode.childNodes[startOffset];
176
    collapse = !child;
177
    startNode = child || startNode.lastChild || startNode;
178
    startOffset = 0;
179
  }
180
  var leftRange =
181
      goog.dom.browserrange.IeRange.getBrowserRangeForNode_(startNode);
182

183
  // This happens only when startNode is a text node.
184
  if (startOffset) {
185
    leftRange.move('character', startOffset);
186
  }
187

188

189
  // The range movements in IE are still an approximation to the standard W3C
190
  // behavior, and IE has its trickery when it comes to htmlText and text
191
  // properties of the range. So we short-circuit computation whenever we can.
192
  if (startNode == endNode && startOffset == endOffset) {
193
    leftRange.collapse(true);
194
    return leftRange;
195
  }
196

197
  // This can happen only when the startNode is an element, and there is no node
198
  // at the given offset. We start at the last point inside the startNode in
199
  // that case.
200
  if (collapse) {
201
    leftRange.collapse(false);
202
  }
203

204
  // Create a range that ends at the right position.
205
  collapse = false;
206
  if (endNode.nodeType == goog.dom.NodeType.ELEMENT) {
207
    if (endOffset > endNode.childNodes.length) {
208
      goog.log.error(
209
          goog.dom.browserrange.IeRange.logger_,
210
          'Cannot have endOffset > endNode child count');
211
    }
212
    child = endNode.childNodes[endOffset];
213
    endNode = child || endNode.lastChild || endNode;
214
    endOffset = 0;
215
    collapse = !child;
216
  }
217
  var rightRange =
218
      goog.dom.browserrange.IeRange.getBrowserRangeForNode_(endNode);
219
  rightRange.collapse(!collapse);
220
  if (endOffset) {
221
    rightRange.moveEnd('character', endOffset);
222
  }
223

224
  // Merge and return.
225
  leftRange.setEndPoint('EndToEnd', rightRange);
226
  return leftRange;
227
};
228

229

230
/**
231
 * Create a range object that selects the given node's text.
232
 * @param {Node} node The node to select.
233
 * @return {!goog.dom.browserrange.IeRange} An IE range wrapper object.
234
 */
235
goog.dom.browserrange.IeRange.createFromNodeContents = function(node) {
236
  var range = new goog.dom.browserrange.IeRange(
237
      goog.dom.browserrange.IeRange.getBrowserRangeForNode_(node),
238
      goog.dom.getOwnerDocument(node));
239

240
  if (!goog.dom.browserrange.canContainRangeEndpoint(node)) {
241
    range.startNode_ = range.endNode_ = range.parentNode_ = node.parentNode;
242
    range.startOffset_ = goog.array.indexOf(range.parentNode_.childNodes, node);
243
    range.endOffset_ = range.startOffset_ + 1;
244
  } else {
245
    // Note(user) : Emulate the behavior of W3CRange - Go to deepest possible
246
    // range containers on both edges. It seems W3CRange did this to match the
247
    // IE behavior, and now it is a circle. Changing W3CRange may break clients
248
    // in all sorts of ways.
249
    var tempNode, leaf = node;
250
    while ((tempNode = leaf.firstChild) &&
251
           goog.dom.browserrange.canContainRangeEndpoint(tempNode)) {
252
      leaf = tempNode;
253
    }
254
    range.startNode_ = leaf;
255
    range.startOffset_ = 0;
256

257
    leaf = node;
258
    while ((tempNode = leaf.lastChild) &&
259
           goog.dom.browserrange.canContainRangeEndpoint(tempNode)) {
260
      leaf = tempNode;
261
    }
262
    range.endNode_ = leaf;
263
    range.endOffset_ = leaf.nodeType == goog.dom.NodeType.ELEMENT ?
264
        leaf.childNodes.length :
265
        leaf.length;
266
    range.parentNode_ = node;
267
  }
268
  return range;
269
};
270

271

272
/**
273
 * Static method that returns the proper type of browser range.
274
 * @param {Node} startNode The node to start with.
275
 * @param {number} startOffset The offset within the start node.
276
 * @param {Node} endNode The node to end with.
277
 * @param {number} endOffset The offset within the end node.
278
 * @return {!goog.dom.browserrange.AbstractRange} A wrapper object.
279
 */
280
goog.dom.browserrange.IeRange.createFromNodes = function(
281
    startNode, startOffset, endNode, endOffset) {
282
  var range = new goog.dom.browserrange.IeRange(
283
      goog.dom.browserrange.IeRange.getBrowserRangeForNodes_(
284
          startNode, startOffset, endNode, endOffset),
285
      goog.dom.getOwnerDocument(startNode));
286
  range.startNode_ = startNode;
287
  range.startOffset_ = startOffset;
288
  range.endNode_ = endNode;
289
  range.endOffset_ = endOffset;
290
  return range;
291
};
292

293

294
/**
295
 * @return {!goog.dom.browserrange.IeRange} A clone of this range.
296
 * @override
297
 */
298
goog.dom.browserrange.IeRange.prototype.clone = function() {
299
  var range =
300
      new goog.dom.browserrange.IeRange(this.range_.duplicate(), this.doc_);
301
  range.parentNode_ = this.parentNode_;
302
  range.startNode_ = this.startNode_;
303
  range.endNode_ = this.endNode_;
304
  return range;
305
};
306

307

308
/** @override */
309
goog.dom.browserrange.IeRange.prototype.getBrowserRange = function() {
310
  return this.range_;
311
};
312

313

314
/**
315
 * Clears the cached values for containers.
316
 * @private
317
 */
318
goog.dom.browserrange.IeRange.prototype.clearCachedValues_ = function() {
319
  this.parentNode_ = this.startNode_ = this.endNode_ = null;
320
  this.startOffset_ = this.endOffset_ = -1;
321
};
322

323

324
/** @override */
325
goog.dom.browserrange.IeRange.prototype.getContainer = function() {
326
  if (!this.parentNode_) {
327
    var selectText = this.range_.text;
328

329
    // If the selection ends with spaces, we need to remove these to get the
330
    // parent container of only the real contents.  This is to get around IE's
331
    // inconsistency where it selects the spaces after a word when you double
332
    // click, but leaves out the spaces during execCommands.
333
    var range = this.range_.duplicate();
334
    // We can't use goog.string.trimRight, as that will remove other whitespace
335
    // too.
336
    var rightTrimmedSelectText = selectText.replace(/ +$/, '');
337
    var numSpacesAtEnd = selectText.length - rightTrimmedSelectText.length;
338
    if (numSpacesAtEnd) {
339
      range.moveEnd('character', -numSpacesAtEnd);
340
    }
341

342
    // Get the parent node.  This should be the end, but alas, it is not.
343
    var parent = range.parentElement();
344

345
    var htmlText = range.htmlText;
346
    var htmlTextLen = goog.string.stripNewlines(htmlText).length;
347
    if (this.isCollapsed() && htmlTextLen > 0) {
348
      return (this.parentNode_ = parent);
349
    }
350

351
    // Deal with selection bug where IE thinks one of the selection's children
352
    // is actually the selection's parent. Relies on the assumption that the
353
    // HTML text of the parent container is longer than the length of the
354
    // selection's HTML text.
355

356
    // Also note IE will sometimes insert \r and \n whitespace, which should be
357
    // disregarded. Otherwise the loop may run too long and return wrong parent
358
    while (htmlTextLen > goog.string.stripNewlines(parent.outerHTML).length) {
359
      parent = parent.parentNode;
360
    }
361

362
    // Deal with IE's selecting the outer tags when you double click
363
    // If the innerText is the same, then we just want the inner node
364
    while (parent.childNodes.length == 1 &&
365
           parent.innerText ==
366
               goog.dom.browserrange.IeRange.getNodeText_(parent.firstChild)) {
367
      // A container should be an element which can have children or a text
368
      // node. Elements like IMG, BR, etc. can not be containers.
369
      if (!goog.dom.browserrange.canContainRangeEndpoint(parent.firstChild)) {
370
        break;
371
      }
372
      parent = parent.firstChild;
373
    }
374

375
    // If the selection is empty, we may need to do extra work to position it
376
    // properly.
377
    if (selectText.length == 0) {
378
      parent = this.findDeepestContainer_(parent);
379
    }
380

381
    this.parentNode_ = parent;
382
  }
383

384
  return this.parentNode_;
385
};
386

387

388
/**
389
 * Helper method to find the deepest parent for this range, starting
390
 * the search from {@code node}, which must contain the range.
391
 * @param {Node} node The node to start the search from.
392
 * @return {Node} The deepest parent for this range.
393
 * @private
394
 */
395
goog.dom.browserrange.IeRange.prototype.findDeepestContainer_ = function(node) {
396
  var childNodes = node.childNodes;
397
  for (var i = 0, len = childNodes.length; i < len; i++) {
398
    var child = childNodes[i];
399

400
    if (goog.dom.browserrange.canContainRangeEndpoint(child)) {
401
      var childRange =
402
          goog.dom.browserrange.IeRange.getBrowserRangeForNode_(child);
403
      var start = goog.dom.RangeEndpoint.START;
404
      var end = goog.dom.RangeEndpoint.END;
405

406
      // There are two types of erratic nodes where the range over node has
407
      // different htmlText than the node's outerHTML.
408
      // Case 1 - A node with magic &nbsp; child. In this case :
409
      //    nodeRange.htmlText shows &nbsp; ('<p>&nbsp;</p>), while
410
      //    node.outerHTML doesn't show the magic node (<p></p>).
411
      // Case 2 - Empty span. In this case :
412
      //    node.outerHTML shows '<span></span>'
413
      //    node.htmlText is just empty string ''.
414
      var isChildRangeErratic = (childRange.htmlText != child.outerHTML);
415

416
      // Moreover the inRange comparison fails only when the
417
      var isNativeInRangeErratic = this.isCollapsed() && isChildRangeErratic;
418

419
      // In case 2 mentioned above, childRange is also collapsed. So we need to
420
      // compare start of this range with both start and end of child range.
421
      var inChildRange = isNativeInRangeErratic ?
422
          (this.compareBrowserRangeEndpoints(childRange, start, start) >= 0 &&
423
           this.compareBrowserRangeEndpoints(childRange, start, end) <= 0) :
424
          this.range_.inRange(childRange);
425
      if (inChildRange) {
426
        return this.findDeepestContainer_(child);
427
      }
428
    }
429
  }
430

431
  return node;
432
};
433

434

435
/** @override */
436
goog.dom.browserrange.IeRange.prototype.getStartNode = function() {
437
  if (!this.startNode_) {
438
    this.startNode_ = this.getEndpointNode_(goog.dom.RangeEndpoint.START);
439
    if (this.isCollapsed()) {
440
      this.endNode_ = this.startNode_;
441
    }
442
  }
443
  return this.startNode_;
444
};
445

446

447
/** @override */
448
goog.dom.browserrange.IeRange.prototype.getStartOffset = function() {
449
  if (this.startOffset_ < 0) {
450
    this.startOffset_ = this.getOffset_(goog.dom.RangeEndpoint.START);
451
    if (this.isCollapsed()) {
452
      this.endOffset_ = this.startOffset_;
453
    }
454
  }
455
  return this.startOffset_;
456
};
457

458

459
/** @override */
460
goog.dom.browserrange.IeRange.prototype.getEndNode = function() {
461
  if (this.isCollapsed()) {
462
    return this.getStartNode();
463
  }
464
  if (!this.endNode_) {
465
    this.endNode_ = this.getEndpointNode_(goog.dom.RangeEndpoint.END);
466
  }
467
  return this.endNode_;
468
};
469

470

471
/** @override */
472
goog.dom.browserrange.IeRange.prototype.getEndOffset = function() {
473
  if (this.isCollapsed()) {
474
    return this.getStartOffset();
475
  }
476
  if (this.endOffset_ < 0) {
477
    this.endOffset_ = this.getOffset_(goog.dom.RangeEndpoint.END);
478
    if (this.isCollapsed()) {
479
      this.startOffset_ = this.endOffset_;
480
    }
481
  }
482
  return this.endOffset_;
483
};
484

485

486
/** @override */
487
goog.dom.browserrange.IeRange.prototype.compareBrowserRangeEndpoints = function(
488
    range, thisEndpoint, otherEndpoint) {
489
  return this.range_.compareEndPoints(
490
      (thisEndpoint == goog.dom.RangeEndpoint.START ? 'Start' : 'End') + 'To' +
491
          (otherEndpoint == goog.dom.RangeEndpoint.START ? 'Start' : 'End'),
492
      range);
493
};
494

495

496
/**
497
 * Recurses to find the correct node for the given endpoint.
498
 * @param {goog.dom.RangeEndpoint} endpoint The endpoint to get the node for.
499
 * @param {Node=} opt_node Optional node to start the search from.
500
 * @return {Node} The deepest node containing the endpoint.
501
 * @private
502
 */
503
goog.dom.browserrange.IeRange.prototype.getEndpointNode_ = function(
504
    endpoint, opt_node) {
505

506
  /** @type {Node} */
507
  var node = opt_node || this.getContainer();
508

509
  // If we're at a leaf in the DOM, we're done.
510
  if (!node || !node.firstChild) {
511
    return node;
512
  }
513

514
  var start = goog.dom.RangeEndpoint.START, end = goog.dom.RangeEndpoint.END;
515
  var isStartEndpoint = endpoint == start;
516

517
  // Find the first/last child that overlaps the selection.
518
  // NOTE(user) : One of the children can be the magic &nbsp; node. This
519
  // node will have only nodeType property as valid and accessible. All other
520
  // dom related properties like ownerDocument, parentNode, nextSibling etc
521
  // cause error when accessed. Therefore use the for-loop on childNodes to
522
  // iterate.
523
  for (var j = 0, length = node.childNodes.length; j < length; j++) {
524
    var i = isStartEndpoint ? j : length - j - 1;
525
    var child = node.childNodes[i];
526
    var childRange;
527
    try {
528
      childRange = goog.dom.browserrange.createRangeFromNodeContents(child);
529
    } catch (e) {
530
      // If the child is the magic &nbsp; node, then the above will throw
531
      // error. The magic node exists only when editing using keyboard, so can
532
      // not add any unit test.
533
      continue;
534
    }
535
    var ieRange = childRange.getBrowserRange();
536

537
    // Case 1 : Finding end points when this range is collapsed.
538
    // Note that in case of collapsed range, getEnd{Node,Offset} call
539
    // getStart{Node,Offset}.
540
    if (this.isCollapsed()) {
541
      // Handle situations where caret is not in a text node. In such cases,
542
      // the adjacent child won't be a valid range endpoint container.
543
      if (!goog.dom.browserrange.canContainRangeEndpoint(child)) {
544
        // The following handles a scenario like <div><BR>[caret]<BR></div>,
545
        // where point should be (div, 1).
546
        if (this.compareBrowserRangeEndpoints(ieRange, start, start) == 0) {
547
          this.startOffset_ = this.endOffset_ = i;
548
          return node;
549
        }
550
      } else if (childRange.containsRange(this)) {
551
        // For collapsed range, we should invert the containsRange check with
552
        // childRange.
553
        return this.getEndpointNode_(endpoint, child);
554
      }
555

556
      // Case 2 - The first child encountered to have overlap this range is
557
      // contained entirely in this range.
558
    } else if (this.containsRange(childRange)) {
559
      // If it is an element which can not be a range endpoint container, the
560
      // current child offset can be used to deduce the endpoint offset.
561
      if (!goog.dom.browserrange.canContainRangeEndpoint(child)) {
562
        // Container can't be any deeper, so current node is the container.
563
        if (isStartEndpoint) {
564
          this.startOffset_ = i;
565
        } else {
566
          this.endOffset_ = i + 1;
567
        }
568
        return node;
569
      }
570

571
      // If child can contain range endpoints, recurse inside this child.
572
      return this.getEndpointNode_(endpoint, child);
573

574
      // Case 3 - Partial non-adjacency overlap.
575
    } else if (
576
        this.compareBrowserRangeEndpoints(ieRange, start, end) < 0 &&
577
        this.compareBrowserRangeEndpoints(ieRange, end, start) > 0) {
578
      // If this child overlaps the selection partially, recurse down to find
579
      // the first/last child the next level down that overlaps the selection
580
      // completely. We do not consider edge-adjacency (== 0) as overlap.
581
      return this.getEndpointNode_(endpoint, child);
582
    }
583
  }
584

585
  // None of the children of this node overlapped the selection, that means
586
  // the selection starts/ends in this node directly.
587
  return node;
588
};
589

590

591
/**
592
 * Compares one endpoint of this range with the endpoint of a node.
593
 * For internal methods, we should prefer this method to containsNode.
594
 * containsNode has a lot of false negatives when we're dealing with
595
 * {@code <br>} tags.
596
 *
597
 * @param {Node} node The node to compare against.
598
 * @param {goog.dom.RangeEndpoint} thisEndpoint The endpoint of this range
599
 *     to compare with.
600
 * @param {goog.dom.RangeEndpoint} otherEndpoint The endpoint of the node
601
 *     to compare with.
602
 * @return {number} 0 if the endpoints are equal, negative if this range
603
 *     endpoint comes before the other node endpoint, and positive otherwise.
604
 * @private
605
 */
606
goog.dom.browserrange.IeRange.prototype.compareNodeEndpoints_ = function(
607
    node, thisEndpoint, otherEndpoint) {
608
  /** @suppress {missingRequire} Circular dep with browserrange */
609
  return this.range_.compareEndPoints(
610
      (thisEndpoint == goog.dom.RangeEndpoint.START ? 'Start' : 'End') + 'To' +
611
          (otherEndpoint == goog.dom.RangeEndpoint.START ? 'Start' : 'End'),
612
      goog.dom.browserrange.createRangeFromNodeContents(node)
613
          .getBrowserRange());
614
};
615

616

617
/**
618
 * Returns the offset into the start/end container.
619
 * @param {goog.dom.RangeEndpoint} endpoint The endpoint to get the offset for.
620
 * @param {Node=} opt_container The container to get the offset relative to.
621
 *     Defaults to the value returned by getStartNode/getEndNode.
622
 * @return {number} The offset.
623
 * @private
624
 */
625
goog.dom.browserrange.IeRange.prototype.getOffset_ = function(
626
    endpoint, opt_container) {
627
  var isStartEndpoint = endpoint == goog.dom.RangeEndpoint.START;
628
  var container = opt_container ||
629
      (isStartEndpoint ? this.getStartNode() : this.getEndNode());
630

631
  if (container.nodeType == goog.dom.NodeType.ELEMENT) {
632
    // Find the first/last child that overlaps the selection
633
    var children = container.childNodes;
634
    var len = children.length;
635
    var edge = isStartEndpoint ? 0 : len - 1;
636
    var sign = isStartEndpoint ? 1 : -1;
637

638
    // We find the index in the child array of the endpoint of the selection.
639
    for (var i = edge; i >= 0 && i < len; i += sign) {
640
      var child = children[i];
641
      // Ignore the child nodes, which could be end point containers.
642
      /** @suppress {missingRequire} Circular dep with browserrange */
643
      if (goog.dom.browserrange.canContainRangeEndpoint(child)) {
644
        continue;
645
      }
646
      // Stop looping when we reach the edge of the selection.
647
      var endPointCompare =
648
          this.compareNodeEndpoints_(child, endpoint, endpoint);
649
      if (endPointCompare == 0) {
650
        return isStartEndpoint ? i : i + 1;
651
      }
652
    }
653

654
    // When starting from the end in an empty container, we erroneously return
655
    // -1: fix this to return 0.
656
    return i == -1 ? 0 : i;
657
  } else {
658
    // Get a temporary range object.
659
    var range = this.range_.duplicate();
660

661
    // Create a range that selects the entire container.
662
    var nodeRange =
663
        goog.dom.browserrange.IeRange.getBrowserRangeForNode_(container);
664

665
    // Now, intersect our range with the container range - this should give us
666
    // the part of our selection that is in the container.
667
    range.setEndPoint(isStartEndpoint ? 'EndToEnd' : 'StartToStart', nodeRange);
668

669
    var rangeLength = range.text.length;
670
    return isStartEndpoint ? container.length - rangeLength : rangeLength;
671
  }
672
};
673

674

675
/**
676
 * Returns the text of the given node.  Uses IE specific properties.
677
 * @param {Node} node The node to retrieve the text of.
678
 * @return {string} The node's text.
679
 * @private
680
 */
681
goog.dom.browserrange.IeRange.getNodeText_ = function(node) {
682
  return node.nodeType == goog.dom.NodeType.TEXT ? node.nodeValue :
683
                                                   node.innerText;
684
};
685

686

687
/**
688
 * Tests whether this range is valid (i.e. whether its endpoints are still in
689
 * the document).  A range becomes invalid when, after this object was created,
690
 * either one or both of its endpoints are removed from the document.  Use of
691
 * an invalid range can lead to runtime errors, particularly in IE.
692
 * @return {boolean} Whether the range is valid.
693
 */
694
goog.dom.browserrange.IeRange.prototype.isRangeInDocument = function() {
695
  var range = this.doc_.body.createTextRange();
696
  range.moveToElementText(this.doc_.body);
697

698
  return this.containsRange(
699
      new goog.dom.browserrange.IeRange(range, this.doc_), true);
700
};
701

702

703
/** @override */
704
goog.dom.browserrange.IeRange.prototype.isCollapsed = function() {
705
  // Note(user) : The earlier implementation used (range.text == ''), but this
706
  // fails when (range.htmlText == '<br>')
707
  // Alternative: this.range_.htmlText == '';
708
  return this.range_.compareEndPoints('StartToEnd', this.range_) == 0;
709
};
710

711

712
/** @override */
713
goog.dom.browserrange.IeRange.prototype.getText = function() {
714
  return this.range_.text;
715
};
716

717

718
/** @override */
719
goog.dom.browserrange.IeRange.prototype.getValidHtml = function() {
720
  return this.range_.htmlText;
721
};
722

723

724
// SELECTION MODIFICATION
725

726

727
/** @override */
728
goog.dom.browserrange.IeRange.prototype.select = function(opt_reverse) {
729
  // IE doesn't support programmatic reversed selections.
730
  this.range_.select();
731
};
732

733

734
/** @override */
735
goog.dom.browserrange.IeRange.prototype.removeContents = function() {
736
  // NOTE: Sometimes htmlText is non-empty, but the range is actually empty.
737
  // TODO(gboyer): The htmlText check is probably unnecessary, but I left it in
738
  // for paranoia.
739
  if (!this.isCollapsed() && this.range_.htmlText) {
740
    // Store some before-removal state.
741
    var startNode = this.getStartNode();
742
    var endNode = this.getEndNode();
743
    var oldText = this.range_.text;
744

745
    // IE sometimes deletes nodes unrelated to the selection.  This trick fixes
746
    // that problem most of the time.  Even though it looks like a no-op, it is
747
    // somehow changing IE's internal state such that empty unrelated nodes are
748
    // no longer deleted.
749
    var clone = this.range_.duplicate();
750
    clone.moveStart('character', 1);
751
    clone.moveStart('character', -1);
752

753
    // However, sometimes moving the start back and forth ends up changing the
754
    // range.
755
    // TODO(gboyer): This condition used to happen for empty ranges, but (1)
756
    // never worked, and (2) the isCollapsed call should protect against empty
757
    // ranges better than before.  However, this is left for paranoia.
758
    if (clone.text == oldText) {
759
      this.range_ = clone;
760
    }
761

762
    // Use the browser's native deletion code.
763
    this.range_.text = '';
764
    this.clearCachedValues_();
765

766
    // Unfortunately, when deleting a portion of a single text node, IE creates
767
    // an extra text node unlike other browsers which just change the text in
768
    // the node.  We normalize for that behavior here, making IE behave like all
769
    // the other browsers.
770
    var newStartNode = this.getStartNode();
771
    var newStartOffset = this.getStartOffset();
772

773
    try {
774
      var sibling = startNode.nextSibling;
775
      if (startNode == endNode && startNode.parentNode &&
776
          startNode.nodeType == goog.dom.NodeType.TEXT && sibling &&
777
          sibling.nodeType == goog.dom.NodeType.TEXT) {
778
        startNode.nodeValue += sibling.nodeValue;
779
        goog.dom.removeNode(sibling);
780

781
        // Make sure to reselect the appropriate position.
782
        this.range_ =
783
            goog.dom.browserrange.IeRange.getBrowserRangeForNode_(newStartNode);
784
        this.range_.move('character', newStartOffset);
785
        this.clearCachedValues_();
786
      }
787
    } catch (e) {
788
      // IE throws errors on orphaned nodes.
789
    }
790
  }
791
};
792

793

794
/**
795
 * @param {TextRange} range The range to get a dom helper for.
796
 * @return {!goog.dom.DomHelper} A dom helper for the document the range
797
 *     resides in.
798
 * @private
799
 */
800
goog.dom.browserrange.IeRange.getDomHelper_ = function(range) {
801
  return goog.dom.getDomHelper(range.parentElement());
802
};
803

804

805
/**
806
 * Pastes the given element into the given range, returning the resulting
807
 * element.
808
 * @param {TextRange} range The range to paste into.
809
 * @param {Element} element The node to insert a copy of.
810
 * @param {goog.dom.DomHelper=} opt_domHelper DOM helper object for the document
811
 *     the range resides in.
812
 * @return {Element} The resulting copy of element.
813
 * @private
814
 */
815
goog.dom.browserrange.IeRange.pasteElement_ = function(
816
    range, element, opt_domHelper) {
817
  opt_domHelper =
818
      opt_domHelper || goog.dom.browserrange.IeRange.getDomHelper_(range);
819

820
  // Make sure the node has a unique id.
821
  var id;
822
  var originalId = id = element.id;
823
  if (!id) {
824
    id = element.id = goog.string.createUniqueString();
825
  }
826

827
  // Insert (a clone of) the node.
828
  range.pasteHTML(element.outerHTML);
829

830
  // Pasting the outerHTML of the modified element into the document creates
831
  // a clone of the element argument.  We want to return a reference to the
832
  // clone, not the original.  However we need to remove the temporary ID
833
  // first.
834
  element = opt_domHelper.getElement(id);
835

836
  // If element is null here, we failed.
837
  if (element) {
838
    if (!originalId) {
839
      element.removeAttribute('id');
840
    }
841
  }
842

843
  return element;
844
};
845

846

847
/** @override */
848
goog.dom.browserrange.IeRange.prototype.surroundContents = function(element) {
849
  // Make sure the element is detached from the document.
850
  goog.dom.removeNode(element);
851

852
  // IE more or less guarantees that range.htmlText is well-formed & valid.
853
  element.innerHTML = this.range_.htmlText;
854
  element = goog.dom.browserrange.IeRange.pasteElement_(this.range_, element);
855

856
  // If element is null here, we failed.
857
  if (element) {
858
    this.range_.moveToElementText(element);
859
  }
860

861
  this.clearCachedValues_();
862

863
  return element;
864
};
865

866

867
/**
868
 * Internal handler for inserting a node.
869
 * @param {TextRange} clone A clone of this range's browser range object.
870
 * @param {Node} node The node to insert.
871
 * @param {boolean} before Whether to insert the node before or after the range.
872
 * @param {goog.dom.DomHelper=} opt_domHelper The dom helper to use.
873
 * @return {Node} The resulting copy of node.
874
 * @private
875
 */
876
goog.dom.browserrange.IeRange.insertNode_ = function(
877
    clone, node, before, opt_domHelper) {
878
  // Get a DOM helper.
879
  opt_domHelper =
880
      opt_domHelper || goog.dom.browserrange.IeRange.getDomHelper_(clone);
881

882
  // If it's not an element, wrap it in one.
883
  var isNonElement;
884
  if (node.nodeType != goog.dom.NodeType.ELEMENT) {
885
    isNonElement = true;
886
    node = opt_domHelper.createDom(goog.dom.TagName.DIV, null, node);
887
  }
888

889
  clone.collapse(before);
890
  node = goog.dom.browserrange.IeRange.pasteElement_(
891
      clone,
892
      /** @type {!Element} */ (node), opt_domHelper);
893

894
  // If we didn't want an element, unwrap the element and return the node.
895
  if (isNonElement) {
896
    // pasteElement_() may have returned a copy of the wrapper div, and the
897
    // node it wraps could also be a new copy. So we must extract that new
898
    // node from the new wrapper.
899
    var newNonElement = node.firstChild;
900
    opt_domHelper.flattenElement(node);
901
    node = newNonElement;
902
  }
903

904
  return node;
905
};
906

907

908
/** @override */
909
goog.dom.browserrange.IeRange.prototype.insertNode = function(node, before) {
910
  var output = goog.dom.browserrange.IeRange.insertNode_(
911
      this.range_.duplicate(), node, before);
912
  this.clearCachedValues_();
913
  return output;
914
};
915

916

917
/** @override */
918
goog.dom.browserrange.IeRange.prototype.surroundWithNodes = function(
919
    startNode, endNode) {
920
  var clone1 = this.range_.duplicate();
921
  var clone2 = this.range_.duplicate();
922
  goog.dom.browserrange.IeRange.insertNode_(clone1, startNode, true);
923
  goog.dom.browserrange.IeRange.insertNode_(clone2, endNode, false);
924

925
  this.clearCachedValues_();
926
};
927

928

929
/** @override */
930
goog.dom.browserrange.IeRange.prototype.collapse = function(toStart) {
931
  this.range_.collapse(toStart);
932

933
  if (toStart) {
934
    this.endNode_ = this.startNode_;
935
    this.endOffset_ = this.startOffset_;
936
  } else {
937
    this.startNode_ = this.endNode_;
938
    this.startOffset_ = this.endOffset_;
939
  }
940
};
941

942