[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 {number}
  34   * @const
  35   */
  36  var Infinity;
  37  /**
  38   * @type {undefined}
  39   * @const
  40   */
  41  var undefined;
  42  /** @typedef {?} */
  43  var symbol;
  44  /**
  45   * @param {string=} opt_description
  46   * @return {symbol}
  47   */
  48  function Symbol(opt_description) {}
  49  /**
  50   * @param {string} uri
  51   * @return {string}
  52   * @throws {URIError} when used wrongly.
  53   */
  54  function decodeURIComponent(uri) {}
  55  /**
  56   * @param {string} uri
  57   * @return {string}
  58   * @throws {URIError} if one attempts to encode a surrogate which is not part of
  59   */
  60  function encodeURIComponent(uri) {}
  61  /**
  62   * @param {string} str
  63   * @return {string}
  64   * @nosideeffects
  65   */
  66  function escape(str) {}
  67  /**
  68   * @param {*} num
  69   * @return {boolean}
  70   * @nosideeffects
  71   */
  72  function isNaN(num) {}
  73  /**
  74   * @param {*} num
  75   * @param {number|undefined} base
  76   * @return {number}
  77   * @nosideeffects
  78   */
  79  function parseInt(num, base) {}
  80  /**
  81   * @constructor
  82   * @implements {IArrayLike<T>}
  83   * @implements {Iterable<T>}
  84   * @param {...*} var_args
  85   * @return {!Array<?>}
  86   * @nosideeffects
  87   * @template T
  88   */
  89  function Array(var_args) {}
  90  /**
  91   * @param {?function(this:S, T, number, !Array<T>): ?} callback
  92   * @param {S=} opt_thisobj
  93   * @this {IArrayLike<T>|string}
  94   * @template T,S
  95   * @return {undefined}
  96   */
  97  Array.prototype.forEach = function(callback, opt_thisobj) {};
  98  /**
  99   * @param {T} obj
 100   * @param {number=} opt_fromIndex
 101   * @return {number}
 102   * @this {IArrayLike<T>|string}
 103   * @nosideeffects
 104   * @template T
 105   */
 106  Array.prototype.indexOf = function(obj, opt_fromIndex) {};
 107  /**
 108   * @param {*=} opt_separator Specifies a string to separate each element of the
 109   * @return {string}
 110   * @this {IArrayLike<?>|string}
 111   * @nosideeffects
 112   */
 113  Array.prototype.join = function(opt_separator) {};
 114  /**
 115   * @type {number}
 116   */
 117  Array.prototype.length;
 118  /**
 119   * @return {T}
 120   * @this {IArrayLike<T>}
 121   * @modifies {this}
 122   * @template T
 123   */
 124  Array.prototype.pop = function() {};
 125  /**
 126   * @param {...T} var_args
 127   * @return {number} The new length of the array.
 128   * @this {IArrayLike<T>}
 129   * @template T
 130   * @modifies {this}
 131   */
 132  Array.prototype.push = function(var_args) {};
 133  /**
 134   * @return {THIS} A reference to the original modified array.
 135   * @this {THIS}
 136   * @template THIS
 137   * @modifies {this}
 138   */
 139  Array.prototype.reverse = function() {};
 140  /**
 141   * @this {IArrayLike<T>}
 142   * @modifies {this}
 143   * @return {T}
 144   * @template T
 145   */
 146  Array.prototype.shift = function() {};
 147  /**
 148   * @param {*=} opt_begin Zero-based index at which to begin extraction.  A
 149   * @param {*=} opt_end Zero-based index at which to end extraction.  slice
 150   * @return {!Array<T>}
 151   * @this {IArrayLike<T>|string}
 152   * @template T
 153   * @nosideeffects
 154   */
 155  Array.prototype.slice = function(opt_begin, opt_end) {};
 156  /**
 157   * @param {function(T,T):number=} opt_compareFn Specifies a function that
 158   * @this {IArrayLike<T>}
 159   * @template T
 160   * @modifies {this}
 161   * @return {!Array<T>}
 162   */
 163  Array.prototype.sort = function(opt_compareFn) {};
 164  /**
 165   * @param {*=} opt_index Index at which to start changing the array. If negative,  *     will begin that many elements from the end.  A non-number type will be
 166   * @param {*=} opt_howMany An integer indicating the number of old array elements
 167   * @param {...T} var_args
 168   * @return {!Array<T>}
 169   * @this {IArrayLike<T>}
 170   * @modifies {this}
 171   * @template T
 172   */
 173  Array.prototype.splice = function(opt_index, opt_howMany, var_args) {};
 174  /**
 175   * @param {...*} var_args
 176   * @return {number} The new length of the array
 177   * @this {IArrayLike<?>}
 178   * @modifies {this}
 179   */
 180  Array.prototype.unshift = function(var_args) {};
 181  /**
 182   * @param {?=} opt_yr_num
 183   * @param {?=} opt_mo_num
 184   * @param {?=} opt_day_num
 185   * @param {?=} opt_hr_num
 186   * @param {?=} opt_min_num
 187   * @param {?=} opt_sec_num
 188   * @param {?=} opt_ms_num
 189   * @constructor
 190   * @return {string}
 191   * @nosideeffects
 192   */
 193  function Date(opt_yr_num, opt_mo_num, opt_day_num, opt_hr_num, opt_min_num,     opt_sec_num, opt_ms_num) {}
 194  /**
 195   * @param {*} date
 196   * @return {number}
 197   * @nosideeffects
 198   */
 199  Date.parse = function(date) {};
 200  /**
 201   * @constructor
 202   * @param {...*} var_args
 203   * @throws {Error}
 204   */
 205  function Function(var_args) {}
 206  /**
 207   * @const
 208   */
 209  var Math = {};
 210  /**
 211   * @param {?} x
 212   * @return {number}
 213   * @nosideeffects
 214   */
 215  Math.floor = function(x) {};
 216  /**
 217   * @param {...?} var_args
 218   * @return {number}
 219   * @nosideeffects
 220   */
 221  Math.max = function(var_args) {};
 222  /**
 223   * @param {...?} var_args
 224   * @return {number}
 225   * @nosideeffects
 226   */
 227  Math.min = function(var_args) {};
 228  /**
 229   * @return {number}
 230   * @nosideeffects
 231   */
 232  Math.random = function() {};
 233  /**
 234   * @constructor
 235   * @param {*=} opt_value
 236   * @return {number}
 237   * @nosideeffects
 238   */
 239  function Number(opt_value) {}
 240  /**
 241   * @this {Number|number}
 242   * @param {(number|Number)=} opt_radix An optional radix.
 243   * @return {string}
 244   * @nosideeffects
 245   * @override
 246   */
 247  Number.prototype.toString = function(opt_radix) {};
 248  /**
 249   * @constructor
 250   * @param {*=} opt_value
 251   * @return {!Object}
 252   * @nosideeffects
 253   */
 254  function Object(opt_value) {}
 255  /**
 256   * @this {*}
 257   * @return {string}
 258   * @nosideeffects
 259   */
 260  Object.prototype.toString = function() {};
 261  /**
 262   * @constructor
 263   * @param {*=} opt_pattern
 264   * @param {*=} opt_flags
 265   * @return {!RegExp}
 266   * @throws {SyntaxError} if opt_pattern is an invalid pattern.
 267   */
 268  function RegExp(opt_pattern, opt_flags) {}
 269  /**
 270   * @param {*} str The string to search.
 271   * @return {Array<string>} This should really return an Array with a few
 272   */
 273  RegExp.prototype.exec = function(str) {};
 274  /**
 275   * @type {number}
 276   */
 277  RegExp.prototype.lastIndex;
 278  /**
 279   * @param {*} str The string to search.
 280   * @return {boolean} Whether the string was matched.
 281   */
 282  RegExp.prototype.test = function(str) {};
 283  /**
 284   * @constructor
 285   * @implements {Iterable<string>}
 286   * @param {*=} opt_str
 287   * @return {string}
 288   * @nosideeffects
 289   */
 290  function String(opt_str) {}
 291  /**
 292   * @param {...number} var_args
 293   * @return {string}
 294   * @nosideeffects
 295   */
 296  String.fromCharCode = function(var_args) {};
 297  /**
 298   * @this {String|string}
 299   * @param {number} index
 300   * @return {string}
 301   * @nosideeffects
 302   */
 303  String.prototype.charAt = function(index) {};
 304  /**
 305   * @this {String|string}
 306   * @param {number=} opt_index
 307   * @return {number}
 308   * @nosideeffects
 309   */
 310  String.prototype.charCodeAt = function(opt_index) {};
 311  /**
 312   * @this {String|string}
 313   * @param {string|null} searchValue
 314   * @param {(number|null)=} opt_fromIndex
 315   * @return {number}
 316   * @nosideeffects
 317   */
 318  String.prototype.indexOf = function(searchValue, opt_fromIndex) {};
 319  /**
 320   * @type {number}
 321   */
 322  String.prototype.length;
 323  /**
 324   * @this {String|string}
 325   * @param {RegExp|string} pattern
 326   * @param {string|Function} replacement
 327   * @return {string}
 328   */
 329  String.prototype.replace = function(pattern, replacement) {};
 330  /**
 331   * @this {String|string}
 332   * @param {*=} opt_separator
 333   * @param {number=} opt_limit
 334   * @return {!Array<string>}
 335   * @nosideeffects
 336   */
 337  String.prototype.split = function(opt_separator, opt_limit) {};
 338  /**
 339   * @this {String|string}
 340   * @param {number} start
 341   * @param {number=} opt_length
 342   * @return {string} The specified substring.
 343   * @nosideeffects
 344   */
 345  String.prototype.substr = function(start, opt_length) {};
 346  /**
 347   * @this {String|string}
 348   * @return {string}
 349   * @nosideeffects
 350   */
 351  String.prototype.toLowerCase = function() {};
 352  /**
 353   * @this {String|string}
 354   * @return {string}
 355   * @nosideeffects
 356   */
 357  String.prototype.toUpperCase = function() {};
 358  /**
 359   * @type {string}
 360   * @implicitCast
 361   */
 362  Element.prototype.innerHTML;
 363  /**
 364   * @constructor
 365   */
 366  function DOMParser() {}
 367  /**
 368   * @param {string} src The UTF16 string to be parsed.
 369   * @param {string} type The content type of the string.
 370   * @return {Document}
 371   */
 372  DOMParser.prototype.parseFromString = function(src, type) {};
 373  /**
 374   * @type {!Window}
 375   */
 376  var window;
 377  /**
 378   * @constructor
 379   * @extends {Node}
 380   */
 381  function Document() {}
 382  /**
 383   * @return {!DocumentFragment}
 384   * @nosideeffects
 385   */
 386  Document.prototype.createDocumentFragment = function() {};
 387  /**
 388   * @param {string} tagName
 389   * @param {string=} opt_typeExtension
 390   * @return {!Element}
 391   * @nosideeffects
 392   */
 393  Document.prototype.createElement = function(tagName, opt_typeExtension) {};
 394  /**
 395   * @constructor
 396   * @extends {Node}
 397   */
 398  function DocumentFragment() {}
 399  /**
 400   * @constructor
 401   * @implements {IObject<(string|number), T>}
 402   * @implements {IArrayLike<T>}
 403   * @implements {Iterable<T>}
 404   * @template T
 405   */
 406  function NamedNodeMap() {}
 407  /**
 408   * @param {number} index
 409   * @return {Node}
 410   * @nosideeffects
 411   */
 412  NamedNodeMap.prototype.item = function(index) {};
 413  /**
 414   * @type {number}
 415   */
 416  NamedNodeMap.prototype.length;
 417  /**
 418   * @constructor
 419   */
 420  function Node() {}
 421  /**
 422   * @param {Node} newChild
 423   * @return {!Node}
 424   */
 425  Node.prototype.appendChild = function(newChild) {};
 426  /**
 427   * @type {!NodeList<!Node>}
 428   */
 429  Node.prototype.childNodes;
 430  /**
 431   * @param {boolean} deep
 432   * @return {!Node}
 433   * @nosideeffects
 434   */
 435  Node.prototype.cloneNode = function(deep) {};
 436  /**
 437   * @type {Node}
 438   */
 439  Node.prototype.firstChild;
 440  /**
 441   * @param {Node} newChild
 442   * @param {Node} refChild
 443   * @return {!Node}
 444   */
 445  Node.prototype.insertBefore = function(newChild, refChild) {};
 446  /**
 447   * @type {string}
 448   */
 449  Node.prototype.nodeName;
 450  /**
 451   * @type {number}
 452   */
 453  Node.prototype.nodeType;
 454  /**
 455   * @type {string}
 456   */
 457  Node.prototype.nodeValue;
 458  /**
 459   * @type {Document}
 460   */
 461  Node.prototype.ownerDocument;
 462  /**
 463   * @type {Node}
 464   */
 465  Node.prototype.parentNode;
 466  /**
 467   * @param {Node} oldChild
 468   * @return {!Node}
 469   */
 470  Node.prototype.removeChild = function(oldChild) {};
 471  /**
 472   * @constructor
 473   * @implements {IArrayLike<T>}
 474   * @implements {Iterable<T>}
 475   * @template T
 476   */
 477  function NodeList() {}
 478  /**
 479   * @type {number}
 480   */
 481  NodeList.prototype.length;
 482  /**
 483   * @constructor
 484   * @extends {Node}
 485   */
 486  function Element() {}
 487  /**
 488   * @constructor
 489   */
 490  function Window() {}
 491  /**
 492   * @param {Node} externalNode
 493   * @param {boolean} deep
 494   * @return {Node}
 495   */
 496  Document.prototype.importNode = function(externalNode, deep) {};
 497  /**
 498   * @constructor
 499   * @extends {Document}
 500   */
 501  function HTMLDocument() {}
 502  /**
 503   * @constructor
 504   * @extends {Element}
 505   */
 506  function HTMLElement() {}
 507  /**
 508   * @param {?string} namespaceURI
 509   * @param {string} localName
 510   * @return {string}
 511   * @nosideeffects
 512   */
 513  Element.prototype.getAttributeNS = function(namespaceURI, localName) {};
 514  /**
 515   * @param {?string} namespaceURI
 516   * @param {string} localName
 517   * @return {boolean}
 518   * @nosideeffects
 519   */
 520  Element.prototype.hasAttributeNS = function(namespaceURI, localName) {};
 521  /**
 522   * @param {?string} namespaceURI
 523   * @param {string} localName
 524   * @return {undefined}
 525   */
 526  Element.prototype.removeAttributeNS = function(namespaceURI, localName) {};
 527  /**
 528   * @param {?string} namespaceURI
 529   * @param {string} qualifiedName
 530   * @param {string|number|boolean} value Values are converted to strings with
 531   * @return {undefined}
 532   */
 533  Element.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {};
 534  /**
 535   * @param {Node} arg
 536   * @return {boolean}
 537   * @nosideeffects
 538   */
 539  Node.prototype.isEqualNode = function(arg) {};
 540  /**
 541   * @type {string}
 542   */
 543  Node.prototype.namespaceURI;
 544  /**
 545   * @type {string}
 546   * @implicitCast
 547   */
 548  Node.prototype.textContent;
 549  /**
 550   * @type {!HTMLDocument}
 551   * @const
 552   */
 553  var document;