[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  /**
  43   * @constructor
  44   * @param {*=} opt_description
  45   * @return {symbol}
  46   * @nosideeffects
  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|undefined)} 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 {?number=} begin Zero-based index at which to begin extraction.
 149   * @param {?number=} 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(begin, 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 {?number=} index Index at which to start changing the array. If
 166   * @param {?number=} howMany An integer indicating the number of old array
 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(index, 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 {?RegExpResult}
 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   * @extends {Array<string>}
 286   */
 287  var RegExpResult = function() {};
 288  /** @type {number} */
 289  RegExpResult.prototype.index;
 290  /**
 291   * @constructor
 292   * @implements {Iterable<string>}
 293   * @param {*=} opt_str
 294   * @return {string}
 295   * @nosideeffects
 296   */
 297  function String(opt_str) {}
 298  /**
 299   * @param {...number} var_args
 300   * @return {string}
 301   * @nosideeffects
 302   */
 303  String.fromCharCode = function(var_args) {};
 304  /**
 305   * @this {String|string}
 306   * @param {number} index
 307   * @return {string}
 308   * @nosideeffects
 309   */
 310  String.prototype.charAt = function(index) {};
 311  /**
 312   * @this {String|string}
 313   * @param {number=} opt_index
 314   * @return {number}
 315   * @nosideeffects
 316   */
 317  String.prototype.charCodeAt = function(opt_index) {};
 318  /**
 319   * @this {String|string}
 320   * @param {string|null} searchValue
 321   * @param {(number|null)=} opt_fromIndex
 322   * @return {number}
 323   * @nosideeffects
 324   */
 325  String.prototype.indexOf = function(searchValue, opt_fromIndex) {};
 326  /**
 327   * @type {number}
 328   */
 329  String.prototype.length;
 330  /**
 331   * @this {String|string}
 332   * @param {RegExp|string} pattern
 333   * @param {?string|function(string, ...?):*} replacement
 334   * @return {string}
 335   */
 336  String.prototype.replace = function(pattern, replacement) {};
 337  /**
 338   * @this {String|string}
 339   * @param {*=} opt_separator
 340   * @param {number=} opt_limit
 341   * @return {!Array<string>}
 342   * @nosideeffects
 343   */
 344  String.prototype.split = function(opt_separator, opt_limit) {};
 345  /**
 346   * @this {String|string}
 347   * @param {number} start
 348   * @param {number=} opt_length
 349   * @return {string} The specified substring.
 350   * @nosideeffects
 351   */
 352  String.prototype.substr = function(start, opt_length) {};
 353  /**
 354   * @this {String|string}
 355   * @return {string}
 356   * @nosideeffects
 357   */
 358  String.prototype.toLowerCase = function() {};
 359  /**
 360   * @this {String|string}
 361   * @return {string}
 362   * @nosideeffects
 363   */
 364  String.prototype.toUpperCase = function() {};
 365  /**
 366   * @constructor
 367   */
 368  function DOMParser() {}
 369  /**
 370   * @param {!TrustedHTML|string} src The UTF16 string to be parsed.
 371   * @param {string} type The content type of the string.
 372   * @return {Document}
 373   */
 374  DOMParser.prototype.parseFromString = function(src, type) {};
 375  /**
 376   * @constructor
 377   * @extends {Node}
 378   */
 379  function Document() {}
 380  /**
 381   * @return {!DocumentFragment}
 382   * @nosideeffects
 383   */
 384  Document.prototype.createDocumentFragment = function() {};
 385  /**
 386   * @param {string} tagName
 387   * @param {({is: string}|string)=} opt_typeExtension
 388   * @return {!Element}
 389   * @nosideeffects
 390   */
 391  Document.prototype.createElement = function(tagName, opt_typeExtension) {};
 392  /**
 393   * @constructor
 394   * @extends {Node}
 395   */
 396  function DocumentFragment() {}
 397  /**
 398   * @param {string} name
 399   * @param {?number=} flags
 400   * @return {string}
 401   * @nosideeffects
 402   */
 403  Element.prototype.getAttribute = function(name, flags) {};
 404  /**
 405   * @constructor
 406   * @implements {IObject<(string|number), T>}
 407   * @implements {IArrayLike<T>}
 408   * @implements {Iterable<T>}
 409   * @template T
 410   */
 411  function NamedNodeMap() {}
 412  /**
 413   * @param {number} index
 414   * @return {Node}
 415   * @nosideeffects
 416   */
 417  NamedNodeMap.prototype.item = function(index) {};
 418  /**
 419   * @type {number}
 420   */
 421  NamedNodeMap.prototype.length;
 422  /**
 423   * @constructor
 424   */
 425  function Node() {}
 426  /**
 427   * @param {Node} newChild
 428   * @return {!Node}
 429   */
 430  Node.prototype.appendChild = function(newChild) {};
 431  /**
 432   * @type {!NodeList<!Node>}
 433   */
 434  Node.prototype.childNodes;
 435  /**
 436   * @param {boolean} deep
 437   * @return {THIS}
 438   * @this {THIS}
 439   * @template THIS
 440   * @nosideeffects
 441   */
 442  Node.prototype.cloneNode = function(deep) {};
 443  /**
 444   * @type {Node}
 445   */
 446  Node.prototype.firstChild;
 447  /**
 448   * @param {Node} newChild
 449   * @param {Node} refChild
 450   * @return {!Node}
 451   */
 452  Node.prototype.insertBefore = function(newChild, refChild) {};
 453  /**
 454   * @type {string}
 455   */
 456  Node.prototype.nodeName;
 457  /**
 458   * @type {number}
 459   */
 460  Node.prototype.nodeType;
 461  /**
 462   * @type {string}
 463   */
 464  Node.prototype.nodeValue;
 465  /**
 466   * @type {Document}
 467   */
 468  Node.prototype.ownerDocument;
 469  /**
 470   * @type {Node}
 471   */
 472  Node.prototype.parentNode;
 473  /**
 474   * @param {Node} oldChild
 475   * @return {!Node}
 476   */
 477  Node.prototype.removeChild = function(oldChild) {};
 478  /**
 479   * @param {Node} newChild
 480   * @param {Node} oldChild
 481   * @return {!Node}
 482   */
 483  Node.prototype.replaceChild = function(newChild, oldChild) {};
 484  /**
 485   * @constructor
 486   * @implements {IArrayLike<T>}
 487   * @implements {Iterable<T>}
 488   * @template T
 489   */
 490  function NodeList() {}
 491  /**
 492   * @param {?function(this:S, T, number, !NodeList<T>): ?} callback
 493   * @param {S=} opt_thisobj
 494   * @template S
 495   * @return {undefined}
 496   */
 497  NodeList.prototype.forEach = function(callback, opt_thisobj) {};
 498  /**
 499   * @type {number}
 500   */
 501  NodeList.prototype.length;
 502  /**
 503   * @constructor
 504   * @extends {Node}
 505   */
 506  function Element() {}
 507  /**
 508   * @constructor
 509   */
 510  function Window() {}
 511  /**
 512   * @param {!Node} externalNode
 513   * @param {boolean=} deep
 514   * @return {!Node}
 515   */
 516  Document.prototype.importNode = function(externalNode, deep) {};
 517  /**
 518   * @type {string}
 519   * @implicitCast
 520   */
 521  Element.prototype.innerHTML;
 522  /**
 523   * @type {string}
 524   * @implicitCast
 525   */
 526  Element.prototype.outerHTML;
 527  /**
 528   * @constructor
 529   * @extends {Document}
 530   */
 531  function HTMLDocument() {}
 532  /**
 533   * @constructor
 534   * @extends {Element}
 535   */
 536  function HTMLElement() {}
 537  /**
 538   * @param {?string} namespaceURI
 539   * @param {string} localName
 540   * @return {string}
 541   * @nosideeffects
 542   */
 543  Element.prototype.getAttributeNS = function(namespaceURI, localName) {};
 544  /**
 545   * @param {?string} namespaceURI
 546   * @param {string} localName
 547   * @return {boolean}
 548   * @nosideeffects
 549   */
 550  Element.prototype.hasAttributeNS = function(namespaceURI, localName) {};
 551  /**
 552   * @param {?string} namespaceURI
 553   * @param {string} localName
 554   * @return {undefined}
 555   */
 556  Element.prototype.removeAttributeNS = function(namespaceURI, localName) {};
 557  /**
 558   * @param {?string} namespaceURI
 559   * @param {string} qualifiedName
 560   * @param {string|number|boolean} value Values are converted to strings with
 561   * @return {undefined}
 562   */
 563  Element.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {};
 564  /**
 565   * @param {Node} arg
 566   * @return {boolean}
 567   * @nosideeffects
 568   */
 569  Node.prototype.isEqualNode = function(arg) {};
 570  /**
 571   * @param {string} query
 572   * @return {!NodeList<!Element>}
 573   * @nosideeffects
 574   */
 575  Node.prototype.querySelectorAll = function(query) {};
 576  /**
 577   * @type {string}
 578   */
 579  Node.prototype.namespaceURI;
 580  /**
 581   * @type {string}
 582   * @implicitCast
 583   */
 584  Node.prototype.textContent;
 585  /** @constructor */
 586  function TrustedHTML() {}
 587  /**
 588   * @const {!HTMLDocument}
 589   */
 590  var document;
 591  /**
 592   * @type {!Window}
 593   */
 594  var window;