third_party/WebKit/Source/devtools/front_end/platform/DOMExtension.js

   1 /*
   2  * Copyright (C) 2007 Apple Inc.  All rights reserved.
   3  * Copyright (C) 2012 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * Contains diff method based on Javascript Diff Algorithm By John Resig
  30  * http://ejohn.org/files/jsdiff.js (released under the MIT license).
  31  */
  32
  33 /**
  34  * @param {number} offset
  35  * @param {string} stopCharacters
  36  * @param {!Node} stayWithinNode
  37  * @param {string=} direction
  38  * @return {!Range}
  39  */
  40 Node.prototype.rangeOfWord = function(offset, stopCharacters, stayWithinNode, direction)
  41 {
  42     var startNode;
  43     var startOffset = 0;
  44     var endNode;
  45     var endOffset = 0;
  46
  47     if (!stayWithinNode)
  48         stayWithinNode = this;
  49
  50     if (!direction || direction === "backward" || direction === "both") {
  51         var node = this;
  52         while (node) {
  53             if (node === stayWithinNode) {
  54                 if (!startNode)
  55                     startNode = stayWithinNode;
  56                 break;
  57             }
  58
  59             if (node.nodeType === Node.TEXT_NODE) {
  60                 var start = (node === this ? (offset - 1) : (node.nodeValue.length - 1));
  61                 for (var i = start; i >= 0; --i) {
  62                     if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
  63                         startNode = node;
  64                         startOffset = i + 1;
  65                         break;
  66                     }
  67                 }
  68             }
  69
  70             if (startNode)
  71                 break;
  72
  73             node = node.traversePreviousNode(stayWithinNode);
  74         }
  75
  76         if (!startNode) {
  77             startNode = stayWithinNode;
  78             startOffset = 0;
  79         }
  80     } else {
  81         startNode = this;
  82         startOffset = offset;
  83     }
  84
  85     if (!direction || direction === "forward" || direction === "both") {
  86         node = this;
  87         while (node) {
  88             if (node === stayWithinNode) {
  89                 if (!endNode)
  90                     endNode = stayWithinNode;
  91                 break;
  92             }
  93
  94             if (node.nodeType === Node.TEXT_NODE) {
  95                 var start = (node === this ? offset : 0);
  96                 for (var i = start; i < node.nodeValue.length; ++i) {
  97                     if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
  98                         endNode = node;
  99                         endOffset = i;
 100                         break;
 101                     }
 102                 }
 103             }
 104
 105             if (endNode)
 106                 break;
 107
 108             node = node.traverseNextNode(stayWithinNode);
 109         }
 110
 111         if (!endNode) {
 112             endNode = stayWithinNode;
 113             endOffset = stayWithinNode.nodeType === Node.TEXT_NODE ? stayWithinNode.nodeValue.length : stayWithinNode.childNodes.length;
 114         }
 115     } else {
 116         endNode = this;
 117         endOffset = offset;
 118     }
 119
 120     var result = this.ownerDocument.createRange();
 121     result.setStart(startNode, startOffset);
 122     result.setEnd(endNode, endOffset);
 123
 124     return result;
 125 }
 126
 127 /**
 128  * @param {!Node=} stayWithin
 129  * @return {?Node}
 130  */
 131 Node.prototype.traverseNextTextNode = function(stayWithin)
 132 {
 133     var node = this.traverseNextNode(stayWithin);
 134     if (!node)
 135         return null;
 136     var nonTextTags = { "STYLE": 1, "SCRIPT": 1 };
 137     while (node && (node.nodeType !== Node.TEXT_NODE || nonTextTags[node.parentElement.nodeName]))
 138         node = node.traverseNextNode(stayWithin);
 139
 140     return node;
 141 }
 142
 143 /**
 144  * @param {number|undefined} x
 145  * @param {number|undefined} y
 146  * @param {!Element=} relativeTo
 147  */
 148 Element.prototype.positionAt = function(x, y, relativeTo)
 149 {
 150     var shift = {x: 0, y: 0};
 151     if (relativeTo)
 152        shift = relativeTo.boxInWindow(this.ownerDocument.defaultView);
 153
 154     if (typeof x === "number")
 155         this.style.setProperty("left", (shift.x + x) + "px");
 156     else
 157         this.style.removeProperty("left");
 158
 159     if (typeof y === "number")
 160         this.style.setProperty("top", (shift.y + y) + "px");
 161     else
 162         this.style.removeProperty("top");
 163
 164     if (typeof x === "number" || typeof y === "number")
 165         this.style.setProperty("position", "absolute");
 166     else
 167         this.style.removeProperty("position");
 168 }
 169
 170 /**
 171  * @return {boolean}
 172  */
 173 Element.prototype.isScrolledToBottom = function()
 174 {
 175     // This code works only for 0-width border.
 176     // The scrollTop, clientHeight and scrollHeight are computed in double values internally.
 177     // However, they are exposed to javascript differently, each being either rounded (via
 178     // round, ceil or floor functions) or left intouch.
 179     // This adds up a total error up to 2.
 180     return Math.abs(this.scrollTop + this.clientHeight - this.scrollHeight) <= 2;
 181 }
 182
 183 /**
 184  * @param {!Node} fromNode
 185  * @param {!Node} toNode
 186  */
 187 function removeSubsequentNodes(fromNode, toNode)
 188 {
 189     for (var node = fromNode; node && node !== toNode; ) {
 190         var nodeToRemove = node;
 191         node = node.nextSibling;
 192         nodeToRemove.remove();
 193     }
 194 }
 195
 196 /**
 197  * @param {!Event} event
 198  * @return {boolean}
 199  */
 200 Element.prototype.containsEventPoint = function(event)
 201 {
 202     var box = this.getBoundingClientRect();
 203     return box.left < event.x  && event.x < box.right &&
 204            box.top < event.y && event.y < box.bottom;
 205 }
 206
 207 /**
 208  * @param {!Array.<string>} nameArray
 209  * @return {?Node}
 210  */
 211 Node.prototype.enclosingNodeOrSelfWithNodeNameInArray = function(nameArray)
 212 {
 213     for (var node = this; node && node !== this.ownerDocument; node = node.parentNodeOrShadowHost()) {
 214         for (var i = 0; i < nameArray.length; ++i) {
 215             if (node.nodeName.toLowerCase() === nameArray[i].toLowerCase())
 216                 return node;
 217         }
 218     }
 219     return null;
 220 }
 221
 222 /**
 223  * @param {string} nodeName
 224  * @return {?Node}
 225  */
 226 Node.prototype.enclosingNodeOrSelfWithNodeName = function(nodeName)
 227 {
 228     return this.enclosingNodeOrSelfWithNodeNameInArray([nodeName]);
 229 }
 230
 231 /**
 232  * @param {string} className
 233  * @param {!Element=} stayWithin
 234  * @return {?Element}
 235  */
 236 Node.prototype.enclosingNodeOrSelfWithClass = function(className, stayWithin)
 237 {
 238     return this.enclosingNodeOrSelfWithClassList([className], stayWithin);
 239 }
 240
 241 /**
 242  * @param {!Array.<string>} classNames
 243  * @param {!Element=} stayWithin
 244  * @return {?Element}
 245  */
 246 Node.prototype.enclosingNodeOrSelfWithClassList = function(classNames, stayWithin)
 247 {
 248     for (var node = this; node && node !== stayWithin && node !== this.ownerDocument; node = node.parentNodeOrShadowHost()) {
 249         if (node.nodeType === Node.ELEMENT_NODE) {
 250             var containsAll = true;
 251             for (var i = 0; i < classNames.length && containsAll; ++i) {
 252                 if (!node.classList.contains(classNames[i]))
 253                     containsAll = false;
 254             }
 255             if (containsAll)
 256                 return /** @type {!Element} */ (node);
 257         }
 258     }
 259     return null;
 260 }
 261
 262 /**
 263  * @return {?Element}
 264  */
 265 Node.prototype.parentElementOrShadowHost = function()
 266 {
 267     var node = this.parentNode;
 268     if (!node)
 269         return null;
 270     if (node.nodeType === Node.ELEMENT_NODE)
 271         return /** @type {!Element} */ (node);
 272     if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE)
 273         return /** @type {!Element} */ (node.host);
 274     return null;
 275 }
 276
 277 /**
 278  * @return {?Node}
 279  */
 280 Node.prototype.parentNodeOrShadowHost = function()
 281 {
 282     return this.parentNode || this.host || null;
 283 }
 284
 285 /**
 286  * @return {?Selection}
 287  */
 288 Node.prototype.getComponentSelection = function()
 289 {
 290     var parent = this.parentNode;
 291     while (parent && parent.nodeType !== Node.DOCUMENT_FRAGMENT_NODE)
 292         parent = parent.parentNode;
 293     return parent instanceof ShadowRoot ? parent.getSelection() : this.window().getSelection();
 294 }
 295
 296
 297 /**
 298  * @return {boolean}
 299  */
 300 Node.prototype.isComponentSelectionCollapsed = function()
 301 {
 302     // FIXME: crbug.com/447523, use selection.isCollapsed when it is fixed for shadow dom.
 303     var selection = this.getComponentSelection();
 304     return selection && selection.rangeCount ? selection.getRangeAt(0).collapsed : true;
 305 }
 306
 307 /**
 308  * @return {!Selection}
 309  */
 310 Node.prototype.getDeepSelection = function()
 311 {
 312     var activeElement = this.ownerDocument.activeElement;
 313     var shadowRoot = null;
 314     while (activeElement && activeElement.shadowRoot) {
 315         shadowRoot = activeElement.shadowRoot;
 316         activeElement = shadowRoot.activeElement;
 317     }
 318
 319     return shadowRoot ? shadowRoot.getSelection() : this.window().getSelection();
 320 }
 321
 322 /**
 323  * @return {!Window}
 324  */
 325 Node.prototype.window = function()
 326 {
 327     return this.ownerDocument.defaultView;
 328 }
 329
 330 /**
 331  * @param {string} query
 332  * @return {?Node}
 333  */
 334 Element.prototype.query = function(query)
 335 {
 336     return this.ownerDocument.evaluate(query, this, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
 337 }
 338
 339 Element.prototype.removeChildren = function()
 340 {
 341     if (this.firstChild)
 342         this.textContent = "";
 343 }
 344
 345 /**
 346  * @return {boolean}
 347  */
 348 Element.prototype.isInsertionCaretInside = function()
 349 {
 350     var selection = this.getComponentSelection();
 351     if (!selection.rangeCount || !selection.isCollapsed)
 352         return false;
 353     var selectionRange = selection.getRangeAt(0);
 354     return selectionRange.startContainer.isSelfOrDescendant(this);
 355 }
 356
 357 /**
 358  * @param {string} tagName
 359  * @param {string=} customElementType
 360  * @return {!Element}
 361  * @suppressGlobalPropertiesCheck
 362  */
 363 function createElement(tagName, customElementType)
 364 {
 365     return document.createElement(tagName, customElementType || "");
 366 }
 367
 368 /**
 369  * @param {string} type
 370  * @param {boolean} bubbles
 371  * @param {boolean} cancelable
 372  * @return {!Event}
 373  * @suppressGlobalPropertiesCheck
 374  */
 375 function createEvent(type, bubbles, cancelable)
 376 {
 377     var event = document.createEvent("Event");
 378     event.initEvent(type, bubbles, cancelable);
 379     return event;
 380 }
 381
 382 /**
 383  * @param {number|string} data
 384  * @return {!Text}
 385  * @suppressGlobalPropertiesCheck
 386  */
 387 function createTextNode(data)
 388 {
 389     return document.createTextNode(data);
 390 }
 391
 392 /**
 393  * @param {string} elementName
 394  * @param {string=} className
 395  * @param {string=} customElementType
 396  * @return {!Element}
 397  */
 398 Document.prototype.createElementWithClass = function(elementName, className, customElementType)
 399 {
 400     var element = this.createElement(elementName, customElementType || "");
 401     if (className)
 402         element.className = className;
 403     return element;
 404 }
 405
 406 /**
 407  * @param {string} elementName
 408  * @param {string=} className
 409  * @param {string=} customElementType
 410  * @return {!Element}
 411  * @suppressGlobalPropertiesCheck
 412  */
 413 function createElementWithClass(elementName, className, customElementType)
 414 {
 415     return document.createElementWithClass(elementName, className, customElementType);
 416 }
 417
 418 /**
 419  * @param {string} childType
 420  * @param {string=} className
 421  * @return {!Element}
 422  */
 423 Document.prototype.createSVGElement = function(childType, className)
 424 {
 425     var element = this.createElementNS("http://www.w3.org/2000/svg", childType);
 426     if (className)
 427         element.setAttribute("class", className);
 428     return element;
 429 }
 430
 431 /**
 432  * @param {string} childType
 433  * @param {string=} className
 434  * @return {!Element}
 435  * @suppressGlobalPropertiesCheck
 436  */
 437 function createSVGElement(childType, className)
 438 {
 439     return document.createSVGElement(childType, className);
 440 }
 441
 442 /**
 443  * @return {!DocumentFragment}
 444  * @suppressGlobalPropertiesCheck
 445  */
 446 function createDocumentFragment()
 447 {
 448     return document.createDocumentFragment();
 449 }
 450
 451 /**
 452  * @param {string} elementName
 453  * @param {string=} className
 454  * @param {string=} customElementType
 455  * @return {!Element}
 456  */
 457 Element.prototype.createChild = function(elementName, className, customElementType)
 458 {
 459     var element = this.ownerDocument.createElementWithClass(elementName, className, customElementType);
 460     this.appendChild(element);
 461     return element;
 462 }
 463
 464 DocumentFragment.prototype.createChild = Element.prototype.createChild;
 465
 466 /**
 467  * @param {string} text
 468  * @return {!Text}
 469  */
 470 Element.prototype.createTextChild = function(text)
 471 {
 472     var element = this.ownerDocument.createTextNode(text);
 473     this.appendChild(element);
 474     return element;
 475 }
 476
 477 DocumentFragment.prototype.createTextChild = Element.prototype.createTextChild;
 478
 479 /**
 480  * @param {...string} var_args
 481  */
 482 Element.prototype.createTextChildren = function(var_args)
 483 {
 484     for (var i = 0, n = arguments.length; i < n; ++i)
 485         this.createTextChild(arguments[i]);
 486 }
 487
 488 DocumentFragment.prototype.createTextChildren = Element.prototype.createTextChildren;
 489
 490 /**
 491  * @return {number}
 492  */
 493 Element.prototype.totalOffsetLeft = function()
 494 {
 495     return this.totalOffset().left;
 496 }
 497
 498 /**
 499  * @return {number}
 500  */
 501 Element.prototype.totalOffsetTop = function()
 502 {
 503     return this.totalOffset().top;
 504 }
 505
 506 /**
 507  * @return {!{left: number, top: number}}
 508  */
 509 Element.prototype.totalOffset = function()
 510 {
 511     var rect = this.getBoundingClientRect();
 512     return { left: rect.left, top: rect.top };
 513 }
 514
 515 /**
 516  * @return {!{left: number, top: number}}
 517  */
 518 Element.prototype.scrollOffset = function()
 519 {
 520     var curLeft = 0;
 521     var curTop = 0;
 522     for (var element = this; element; element = element.scrollParent) {
 523         curLeft += element.scrollLeft;
 524         curTop += element.scrollTop;
 525     }
 526     return { left: curLeft, top: curTop };
 527 }
 528
 529 /**
 530  * @param {string} childType
 531  * @param {string=} className
 532  * @return {!Element}
 533  */
 534 Element.prototype.createSVGChild = function(childType, className)
 535 {
 536     var child = this.ownerDocument.createSVGElement(childType, className);
 537     this.appendChild(child);
 538     return child;
 539 }
 540
 541 /**
 542  * @constructor
 543  * @param {number=} x
 544  * @param {number=} y
 545  * @param {number=} width
 546  * @param {number=} height
 547  */
 548 function AnchorBox(x, y, width, height)
 549 {
 550     this.x = x || 0;
 551     this.y = y || 0;
 552     this.width = width || 0;
 553     this.height = height || 0;
 554 }
 555
 556 /**
 557  * @param {!AnchorBox} box
 558  * @return {!AnchorBox}
 559  */
 560 AnchorBox.prototype.relativeTo = function(box)
 561 {
 562     return new AnchorBox(
 563         this.x - box.x, this.y - box.y, this.width, this.height);
 564 }
 565
 566 /**
 567  * @param {!Element} element
 568  * @return {!AnchorBox}
 569  */
 570 AnchorBox.prototype.relativeToElement = function(element)
 571 {
 572     return this.relativeTo(element.boxInWindow(element.ownerDocument.defaultView));
 573 }
 574
 575 /**
 576  * @param {?AnchorBox} anchorBox
 577  * @return {boolean}
 578  */
 579 AnchorBox.prototype.equals = function(anchorBox)
 580 {
 581     return !!anchorBox && this.x === anchorBox.x && this.y === anchorBox.y && this.width === anchorBox.width && this.height === anchorBox.height;
 582 }
 583
 584 /**
 585  * @param {!Window} targetWindow
 586  * @return {!AnchorBox}
 587  */
 588 Element.prototype.offsetRelativeToWindow = function(targetWindow)
 589 {
 590     var elementOffset = new AnchorBox();
 591     var curElement = this;
 592     var curWindow = this.ownerDocument.defaultView;
 593     while (curWindow && curElement) {
 594         elementOffset.x += curElement.totalOffsetLeft();
 595         elementOffset.y += curElement.totalOffsetTop();
 596         if (curWindow === targetWindow)
 597             break;
 598
 599         curElement = curWindow.frameElement;
 600         curWindow = curWindow.parent;
 601     }
 602
 603     return elementOffset;
 604 }
 605
 606 /**
 607  * @param {!Window=} targetWindow
 608  * @return {!AnchorBox}
 609  */
 610 Element.prototype.boxInWindow = function(targetWindow)
 611 {
 612     targetWindow = targetWindow || this.ownerDocument.defaultView;
 613
 614     var anchorBox = this.offsetRelativeToWindow(window);
 615     anchorBox.width = Math.min(this.offsetWidth, window.innerWidth - anchorBox.x);
 616     anchorBox.height = Math.min(this.offsetHeight, window.innerHeight - anchorBox.y);
 617
 618     return anchorBox;
 619 }
 620
 621 /**
 622  * @param {string} text
 623  */
 624 Element.prototype.setTextAndTitle = function(text)
 625 {
 626     this.textContent = text;
 627     this.title = text;
 628 }
 629
 630 KeyboardEvent.prototype.__defineGetter__("data", function()
 631 {
 632     // Emulate "data" attribute from DOM 3 TextInput event.
 633     // See http://www.w3.org/TR/DOM-Level-3-Events/#events-Events-TextEvent-data
 634     switch (this.type) {
 635         case "keypress":
 636             if (!this.ctrlKey && !this.metaKey)
 637                 return String.fromCharCode(this.charCode);
 638             else
 639                 return "";
 640         case "keydown":
 641         case "keyup":
 642             if (!this.ctrlKey && !this.metaKey && !this.altKey)
 643                 return String.fromCharCode(this.which);
 644             else
 645                 return "";
 646     }
 647 });
 648
 649 /**
 650  * @param {boolean=} preventDefault
 651  */
 652 Event.prototype.consume = function(preventDefault)
 653 {
 654     this.stopImmediatePropagation();
 655     if (preventDefault)
 656         this.preventDefault();
 657     this.handled = true;
 658 }
 659
 660 /**
 661  * @param {number=} start
 662  * @param {number=} end
 663  * @return {!Text}
 664  */
 665 Text.prototype.select = function(start, end)
 666 {
 667     start = start || 0;
 668     end = end || this.textContent.length;
 669
 670     if (start < 0)
 671         start = end + start;
 672
 673     var selection = this.getComponentSelection();
 674     selection.removeAllRanges();
 675     var range = this.ownerDocument.createRange();
 676     range.setStart(this, start);
 677     range.setEnd(this, end);
 678     selection.addRange(range);
 679     return this;
 680 }
 681
 682 /**
 683  * @return {?number}
 684  */
 685 Element.prototype.selectionLeftOffset = function()
 686 {
 687     // Calculate selection offset relative to the current element.
 688
 689     var selection = this.getComponentSelection();
 690     if (!selection.containsNode(this, true))
 691         return null;
 692
 693     var leftOffset = selection.anchorOffset;
 694     var node = selection.anchorNode;
 695
 696     while (node !== this) {
 697         while (node.previousSibling) {
 698             node = node.previousSibling;
 699             leftOffset += node.textContent.length;
 700         }
 701         node = node.parentNodeOrShadowHost();
 702     }
 703
 704     return leftOffset;
 705 }
 706
 707 /**
 708  * @param {...!Node} var_args
 709  */
 710 Node.prototype.appendChildren = function(var_args)
 711 {
 712     for (var i = 0, n = arguments.length; i < n; ++i)
 713         this.appendChild(arguments[i]);
 714 }
 715
 716 /**
 717  * @return {string}
 718  */
 719 Node.prototype.deepTextContent = function()
 720 {
 721     return this.childTextNodes().map(function (node) { return node.textContent; }).join("");
 722 }
 723
 724 /**
 725  * @return {!Array.<!Node>}
 726  */
 727 Node.prototype.childTextNodes = function()
 728 {
 729     var node = this.traverseNextTextNode(this);
 730     var result = [];
 731     var nonTextTags = { "STYLE": 1, "SCRIPT": 1 };
 732     while (node) {
 733         if (!nonTextTags[node.parentElement.nodeName])
 734             result.push(node);
 735         node = node.traverseNextTextNode(this);
 736     }
 737     return result;
 738 }
 739
 740 /**
 741  * @param {?Node} node
 742  * @return {boolean}
 743  */
 744 Node.prototype.isAncestor = function(node)
 745 {
 746     if (!node)
 747         return false;
 748
 749     var currentNode = node.parentNodeOrShadowHost();
 750     while (currentNode) {
 751         if (this === currentNode)
 752             return true;
 753         currentNode = currentNode.parentNodeOrShadowHost();
 754     }
 755     return false;
 756 }
 757
 758 /**
 759  * @param {?Node} descendant
 760  * @return {boolean}
 761  */
 762 Node.prototype.isDescendant = function(descendant)
 763 {
 764     return !!descendant && descendant.isAncestor(this);
 765 }
 766
 767 /**
 768  * @param {?Node} node
 769  * @return {boolean}
 770  */
 771 Node.prototype.isSelfOrAncestor = function(node)
 772 {
 773     return !!node && (node === this || this.isAncestor(node));
 774 }
 775
 776 /**
 777  * @param {?Node} node
 778  * @return {boolean}
 779  */
 780 Node.prototype.isSelfOrDescendant = function(node)
 781 {
 782     return !!node && (node === this || this.isDescendant(node));
 783 }
 784
 785 /**
 786  * @param {!Node=} stayWithin
 787  * @return {?Node}
 788  */
 789 Node.prototype.traverseNextNode = function(stayWithin)
 790 {
 791     if (this.shadowRoot)
 792         return this.shadowRoot;
 793
 794     var distributedNodes = this.getDistributedNodes ? this.getDistributedNodes() : [];
 795
 796     if (distributedNodes.length)
 797         return distributedNodes[0];
 798
 799     if (this.firstChild)
 800         return this.firstChild;
 801
 802     var node = this;
 803     while (node) {
 804         if (stayWithin && node === stayWithin)
 805             return null;
 806
 807         var sibling = nextSibling(node);
 808         if (sibling)
 809             return sibling;
 810
 811         node = insertionPoint(node) || node.parentNodeOrShadowHost();
 812     }
 813
 814     /**
 815      * @param {!Node} node
 816      * @return {?Node}
 817      */
 818     function nextSibling(node)
 819     {
 820         var parent = insertionPoint(node);
 821         if (!parent)
 822             return node.nextSibling;
 823         var distributedNodes = parent.getDistributedNodes ? parent.getDistributedNodes() : [];
 824
 825         var position = Array.prototype.indexOf.call(distributedNodes, node);
 826         if (position + 1 < distributedNodes.length)
 827             return distributedNodes[position + 1];
 828         return null;
 829     }
 830
 831     /**
 832      * @param {!Node} node
 833      * @return {?Node}
 834      */
 835     function insertionPoint(node)
 836     {
 837         var insertionPoints =  node.getDestinationInsertionPoints  ? node.getDestinationInsertionPoints() : [];
 838         return insertionPoints.length > 0 ? insertionPoints[insertionPoints.length - 1] : null;
 839     }
 840
 841     return null;
 842 }
 843
 844 /**
 845  * @param {!Node=} stayWithin
 846  * @return {?Node}
 847  */
 848 Node.prototype.traversePreviousNode = function(stayWithin)
 849 {
 850     if (stayWithin && this === stayWithin)
 851         return null;
 852     var node = this.previousSibling;
 853     while (node && node.lastChild)
 854         node = node.lastChild;
 855     if (node)
 856         return node;
 857     return this.parentNodeOrShadowHost();
 858 }
 859
 860 /**
 861  * @param {*} text
 862  * @param {string=} placeholder
 863  * @return {boolean} true if was truncated
 864  */
 865 Node.prototype.setTextContentTruncatedIfNeeded = function(text, placeholder)
 866 {
 867     // Huge texts in the UI reduce rendering performance drastically.
 868     // Moreover, Blink/WebKit uses <unsigned short> internally for storing text content
 869     // length, so texts longer than 65535 are inherently displayed incorrectly.
 870     const maxTextContentLength = 10000;
 871
 872     if (typeof text === "string" && text.length > maxTextContentLength) {
 873         this.textContent = typeof placeholder === "string" ? placeholder : text.trimMiddle(maxTextContentLength);
 874         return true;
 875     }
 876
 877     this.textContent = text;
 878     return false;
 879 }
 880
 881 /**
 882  * @return {?Node}
 883  */
 884 Event.prototype.deepElementFromPoint = function()
 885 {
 886     // 1. climb to the component root.
 887     var node = this.target;
 888     while (node && node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE && node.nodeType !== Node.DOCUMENT_NODE)
 889         node = node.parentNode;
 890
 891     if (!node)
 892         return null;
 893
 894     // 2. Find deepest node by coordinates.
 895     node = node.elementFromPoint(this.pageX, this.pageY);
 896     while (node && node.shadowRoot)
 897         node = node.shadowRoot.elementFromPoint(this.pageX, this.pageY);
 898     return node;
 899 }
 900
 901 /**
 902  * @return {?Element}
 903  */
 904 Event.prototype.deepActiveElement = function()
 905 {
 906     var activeElement = this.target && this.target.ownerDocument ? this.target.ownerDocument.activeElement : null;
 907     while (activeElement && activeElement.shadowRoot)
 908         activeElement = activeElement.shadowRoot.activeElement;
 909     return activeElement;
 910 }
 911
 912 /**
 913  * @param {number} x
 914  * @param {number} y
 915  * @return {?Node}
 916  */
 917 Document.prototype.deepElementFromPoint = function(x, y)
 918 {
 919     var node = this.elementFromPoint(x, y);
 920     while (node && node.shadowRoot)
 921         node = node.shadowRoot.elementFromPoint(x, y);
 922     return node;
 923 }
 924
 925 /**
 926  * @param {!Event} event
 927  * @return {boolean}
 928  */
 929 function isEnterKey(event)
 930 {
 931     // Check if in IME.
 932     return event.keyCode !== 229 && event.keyIdentifier === "Enter";
 933 }
 934
 935 /**
 936  * @param {!Event} event
 937  * @return {boolean}
 938  */
 939 function isEscKey(event)
 940 {
 941     return event.keyCode === 27;
 942 }
 943
 944 function consumeEvent(e)
 945 {
 946     e.consume();
 947 }
 948
 949 /**
 950  * @param {function()} callback
 951  * @suppressGlobalPropertiesCheck
 952  */
 953 function runOnWindowLoad(callback)
 954 {
 955     /**
 956      * @suppressGlobalPropertiesCheck
 957      */
 958     function windowLoaded()
 959     {
 960         window.removeEventListener("DOMContentLoaded", windowLoaded, false);
 961         callback();
 962     }
 963
 964     if (document.readyState === "complete" || document.readyState === "interactive")
 965         callback();
 966     else
 967         window.addEventListener("DOMContentLoaded", windowLoaded, false);
 968 }