[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   * @type {string}
  34   * @implicitCast
  35   */
  36  Element.prototype.innerHTML;
  37  /**
  38   * @constructor
  39   */
  40  function DOMParser() {}
  41  /**
  42   * @param {string} src The UTF16 string to be parsed.
  43   * @param {string} type The content type of the string.
  44   * @return {Document}
  45   */
  46  DOMParser.prototype.parseFromString = function(src, type) {};
  47  /**
  48   * @type {!Window}
  49   */
  50  var window;
  51  /**
  52   * @constructor
  53   * @extends {Node}
  54   */
  55  function Document() {}
  56  /**
  57   * @return {!DocumentFragment}
  58   * @nosideeffects
  59   */
  60  Document.prototype.createDocumentFragment = function() {};
  61  /**
  62   * @param {string} tagName
  63   * @param {string=} opt_typeExtension
  64   * @return {!Element}
  65   * @nosideeffects
  66   */
  67  Document.prototype.createElement = function(tagName, opt_typeExtension) {};
  68  /**
  69   * @constructor
  70   * @extends {Node}
  71   */
  72  function DocumentFragment() {}
  73  /**
  74   * @constructor
  75   * @implements {IObject<(string|number), T>}
  76   * @implements {IArrayLike<T>}
  77   * @implements {Iterable<T>}
  78   * @template T
  79   */
  80  function NamedNodeMap() {}
  81  /**
  82   * @param {number} index
  83   * @return {Node}
  84   * @nosideeffects
  85   */
  86  NamedNodeMap.prototype.item = function(index) {};
  87  /**
  88   * @type {number}
  89   */
  90  NamedNodeMap.prototype.length;
  91  /**
  92   * @constructor
  93   */
  94  function Node() {}
  95  /**
  96   * @param {Node} newChild
  97   * @return {!Node}
  98   */
  99  Node.prototype.appendChild = function(newChild) {};
 100  /**
 101   * @type {!NodeList<!Node>}
 102   */
 103  Node.prototype.childNodes;
 104  /**
 105   * @param {boolean} deep
 106   * @return {!Node}
 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   * @constructor
 147   * @implements {IArrayLike<T>}
 148   * @implements {Iterable<T>}
 149   * @template T
 150   */
 151  function NodeList() {}
 152  /**
 153   * @type {number}
 154   */
 155  NodeList.prototype.length;
 156  /**
 157   * @constructor
 158   * @extends {Node}
 159   */
 160  function Element() {}
 161  /**
 162   * @constructor
 163   */
 164  function Window() {}
 165  /**
 166   * @param {Node} externalNode
 167   * @param {boolean} deep
 168   * @return {Node}
 169   */
 170  Document.prototype.importNode = function(externalNode, deep) {};
 171  /**
 172   * @constructor
 173   * @extends {Document}
 174   */
 175  function HTMLDocument() {}
 176  /**
 177   * @constructor
 178   * @extends {Element}
 179   */
 180  function HTMLElement() {}
 181  /**
 182   * @param {?string} namespaceURI
 183   * @param {string} localName
 184   * @return {string}
 185   * @nosideeffects
 186   */
 187  Element.prototype.getAttributeNS = function(namespaceURI, localName) {};
 188  /**
 189   * @param {?string} namespaceURI
 190   * @param {string} localName
 191   * @return {boolean}
 192   * @nosideeffects
 193   */
 194  Element.prototype.hasAttributeNS = function(namespaceURI, localName) {};
 195  /**
 196   * @param {?string} namespaceURI
 197   * @param {string} localName
 198   * @return {undefined}
 199   */
 200  Element.prototype.removeAttributeNS = function(namespaceURI, localName) {};
 201  /**
 202   * @param {?string} namespaceURI
 203   * @param {string} qualifiedName
 204   * @param {string|number|boolean} value Values are converted to strings with
 205   * @return {undefined}
 206   */
 207  Element.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {};
 208  /**
 209   * @param {Node} arg
 210   * @return {boolean}
 211   * @nosideeffects
 212   */
 213  Node.prototype.isEqualNode = function(arg) {};
 214  /**
 215   * @type {string}
 216   */
 217  Node.prototype.namespaceURI;
 218  /**
 219   * @type {string}
 220   * @implicitCast
 221   */
 222  Node.prototype.textContent;
 223  /**
 224   * @type {!HTMLDocument}
 225   * @const
 226   */
 227  var document;