[Summary view] [Print] [Text view]

   1  /*
   2   * Copyright 2008 The Closure Compiler Authors
   3   *
   4   * Licensed under the Apache License, Version 2.0 (the "License");
   5   * you may not use this file except in compliance with the License.
   6   * You may obtain a copy of the License at
   7   *
   8   *     http://www.apache.org/licenses/LICENSE-2.0
   9   *
  10   * Unless required by applicable law or agreed to in writing, software
  11   * distributed under the License is distributed on an "AS IS" BASIS,
  12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   * See the License for the specific language governing permissions and
  14   * limitations under the License.
  15   */
  16  
  17  // This file was auto-generated.
  18  // See https://github.com/google/closure-compiler for the original source.
  19  // See https://github.com/s9e/TextFormatter/blob/master/scripts/generateExterns.php for details.
  20  
  21  /**
  22   * @const
  23   */
  24  var punycode = {};
  25  /**
  26   * @param {string} domain
  27   * @return {string}
  28   */
  29  punycode.toASCII;
  30  /** @constructor */
  31  function XSLTProcessor() {}
  32  /**
  33   * @constructor
  34   */
  35  function DOMParser() {}
  36  /**
  37   * @param {!TrustedHTML|string} src The UTF16 string to be parsed.
  38   * @param {string} type The content type of the string.
  39   * @return {Document}
  40   */
  41  DOMParser.prototype.parseFromString = function(src, type) {};
  42  /**
  43   * @constructor
  44   * @extends {Node}
  45   */
  46  function Document() {}
  47  /**
  48   * @return {!DocumentFragment}
  49   * @nosideeffects
  50   */
  51  Document.prototype.createDocumentFragment = function() {};
  52  /**
  53   * @param {string} tagName
  54   * @param {({is: string}|string)=} opt_typeExtension
  55   * @return {!Element}
  56   * @nosideeffects
  57   */
  58  Document.prototype.createElement = function(tagName, opt_typeExtension) {};
  59  /**
  60   * @constructor
  61   * @extends {Node}
  62   */
  63  function DocumentFragment() {}
  64  /**
  65   * @param {string} name
  66   * @param {?number=} flags
  67   * @return {string}
  68   * @nosideeffects
  69   */
  70  Element.prototype.getAttribute = function(name, flags) {};
  71  /**
  72   * @constructor
  73   * @implements {IObject<(string|number), T>}
  74   * @implements {IArrayLike<T>}
  75   * @implements {Iterable<T>}
  76   * @template T
  77   */
  78  function NamedNodeMap() {}
  79  /**
  80   * @param {number} index
  81   * @return {Node}
  82   * @nosideeffects
  83   */
  84  NamedNodeMap.prototype.item = function(index) {};
  85  /**
  86   * @type {number}
  87   */
  88  NamedNodeMap.prototype.length;
  89  /**
  90   * @constructor
  91   */
  92  function Node() {}
  93  /**
  94   * @param {Node} newChild
  95   * @return {!Node}
  96   */
  97  Node.prototype.appendChild = function(newChild) {};
  98  /**
  99   * @type {!NodeList<!Node>}
 100   */
 101  Node.prototype.childNodes;
 102  /**
 103   * @param {boolean} deep
 104   * @return {THIS}
 105   * @this {THIS}
 106   * @template THIS
 107   * @nosideeffects
 108   */
 109  Node.prototype.cloneNode = function(deep) {};
 110  /**
 111   * @type {Node}
 112   */
 113  Node.prototype.firstChild;
 114  /**
 115   * @param {Node} newChild
 116   * @param {Node} refChild
 117   * @return {!Node}
 118   */
 119  Node.prototype.insertBefore = function(newChild, refChild) {};
 120  /**
 121   * @type {string}
 122   */
 123  Node.prototype.nodeName;
 124  /**
 125   * @type {number}
 126   */
 127  Node.prototype.nodeType;
 128  /**
 129   * @type {string}
 130   */
 131  Node.prototype.nodeValue;
 132  /**
 133   * @type {Document}
 134   */
 135  Node.prototype.ownerDocument;
 136  /**
 137   * @type {Node}
 138   */
 139  Node.prototype.parentNode;
 140  /**
 141   * @param {Node} oldChild
 142   * @return {!Node}
 143   */
 144  Node.prototype.removeChild = function(oldChild) {};
 145  /**
 146   * @param {Node} newChild
 147   * @param {Node} oldChild
 148   * @return {!Node}
 149   */
 150  Node.prototype.replaceChild = function(newChild, oldChild) {};
 151  /**
 152   * @constructor
 153   * @implements {IArrayLike<T>}
 154   * @implements {Iterable<T>}
 155   * @template T
 156   */
 157  function NodeList() {}
 158  /**
 159   * @param {?function(this:S, T, number, !NodeList<T>): ?} callback
 160   * @param {S=} opt_thisobj
 161   * @template S
 162   * @return {undefined}
 163   */
 164  NodeList.prototype.forEach = function(callback, opt_thisobj) {};
 165  /**
 166   * @type {number}
 167   */
 168  NodeList.prototype.length;
 169  /**
 170   * @constructor
 171   * @extends {Node}
 172   */
 173  function Element() {}
 174  /**
 175   * @constructor
 176   */
 177  function Window() {}
 178  /**
 179   * @param {!Node} externalNode
 180   * @param {boolean=} deep
 181   * @return {!Node}
 182   */
 183  Document.prototype.importNode = function(externalNode, deep) {};
 184  /**
 185   * @type {string}
 186   * @implicitCast
 187   */
 188  Element.prototype.innerHTML;
 189  /**
 190   * @type {string}
 191   * @implicitCast
 192   */
 193  Element.prototype.outerHTML;
 194  /**
 195   * @constructor
 196   * @extends {Document}
 197   */
 198  function HTMLDocument() {}
 199  /**
 200   * @constructor
 201   * @extends {Element}
 202   */
 203  function HTMLElement() {}
 204  /**
 205   * @param {?string} namespaceURI
 206   * @param {string} localName
 207   * @return {string}
 208   * @nosideeffects
 209   */
 210  Element.prototype.getAttributeNS = function(namespaceURI, localName) {};
 211  /**
 212   * @param {?string} namespaceURI
 213   * @param {string} localName
 214   * @return {boolean}
 215   * @nosideeffects
 216   */
 217  Element.prototype.hasAttributeNS = function(namespaceURI, localName) {};
 218  /**
 219   * @param {?string} namespaceURI
 220   * @param {string} localName
 221   * @return {undefined}
 222   */
 223  Element.prototype.removeAttributeNS = function(namespaceURI, localName) {};
 224  /**
 225   * @param {?string} namespaceURI
 226   * @param {string} qualifiedName
 227   * @param {string|number|boolean} value Values are converted to strings with
 228   * @return {undefined}
 229   */
 230  Element.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {};
 231  /**
 232   * @param {Node} arg
 233   * @return {boolean}
 234   * @nosideeffects
 235   */
 236  Node.prototype.isEqualNode = function(arg) {};
 237  /**
 238   * @param {string} query
 239   * @return {!NodeList<!Element>}
 240   * @nosideeffects
 241   */
 242  Node.prototype.querySelectorAll = function(query) {};
 243  /**
 244   * @type {string}
 245   */
 246  Node.prototype.namespaceURI;
 247  /**
 248   * @type {string}
 249   * @implicitCast
 250   */
 251  Node.prototype.textContent;
 252  /** @constructor */
 253  function TrustedHTML() {}
 254  /**
 255   * @const {!HTMLDocument}
 256   */
 257  var document;
 258  /**
 259   * @type {!Window}
 260   */
 261  var window;