Advertisement
Guest User

Untitled

a guest
Jul 31st, 2015
256
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.32 KB | None | 0 0
  1. /**
  2. @type {Number}
  3. @const
  4. */
  5. NaN = 0;
  6. /**
  7. @type {Number}
  8. */
  9. Infinity = 0;
  10. undefined = 0;
  11. /**
  12. @param {*} x
  13. @return {Object}
  14. */
  15. eval = function(x) {};
  16. /**
  17. @param {*} s
  18. @param {Number} [radix]
  19. @return {Number}
  20. */
  21. parseInt = function(s,radix) {};
  22. /**
  23. @param {*} x
  24. @return {Number}
  25. */
  26. parseFloat = function(x) {};
  27. /**
  28. @param {Number} x
  29. @return {boolean}
  30. */
  31. isNaN = function(x) {};
  32. /**
  33. @param {Number} x
  34. @return {boolean}
  35. */
  36. isFinite = function(x) {};
  37. /**
  38. @param {string} encodedURI
  39. @return {string}
  40. */
  41. decodeURI = function(encodedURI) {};
  42. /**
  43. @param {string} encodedURIComponent
  44. @return {string}
  45. */
  46. decodeURIComponent = function(encodedURIComponent) {};
  47. /**
  48. @param {string} uri
  49. @return {string}
  50. */
  51. encodeURI = function(uri) {};
  52. /**
  53. @param {string} uriComponent
  54. @return {string}
  55. */
  56. encodeURIComponent = function(uriComponent) {};
  57.  
  58. /**
  59. @type {function}
  60. */
  61. Object.constructor = 0;
  62. /**
  63. @type {Number}
  64. */
  65. Object.prototype.length = 0;
  66. /**
  67. @type {Object}
  68. */
  69. Object.prototype.prototype = 0;
  70. /**
  71. @param {*} [value]
  72. @constructor
  73. */
  74. function Object(value) {}
  75. /**
  76. @return {string}
  77. */
  78. Object.prototype.toLocaleString = function() {};
  79. /**
  80. @param {string} propertyName
  81. @return {boolean}
  82. */
  83. Object.prototype.hasOwnProperty = function(propertyName) {};
  84. /**
  85. @param {Object} o
  86. @return {boolean}
  87. */
  88. Object.prototype.isPrototypeOf = function(o) {};
  89. /**
  90. @param {string} propertyName
  91. @return {boolean}
  92. */
  93. Object.prototype.propertyIsEnumerable = function(propertyName) {};
  94. /**
  95. @return {string}
  96. */
  97. Object.prototype.toString = function() {};
  98. /**
  99. @return {*}
  100. */
  101. Object.prototype.valueOf = function() {};
  102.  
  103. /**
  104. @param {...*} [args]
  105. @constructor
  106. */
  107. function Array(args) {}
  108. /**
  109. @param {...*} [items]
  110. @return {Array}
  111. */
  112. Array.prototype.concat = function(items) {};
  113. /**
  114. @param {string} [separator]
  115. @return {string}
  116. */
  117. Array.prototype.join = function(separator) {};
  118. /**
  119. @return {*}
  120. */
  121. Array.prototype.pop = function() {};
  122. /**
  123. @param {...*} [items]
  124. @return {Number}
  125. */
  126. Array.prototype.push = function(items) {};
  127. /**
  128. @return {Array}
  129. */
  130. Array.prototype.reverse = function() {};
  131. /**
  132. @return {*}
  133. */
  134. Array.prototype.shift = function() {};
  135. /**
  136. @param {Number} [start]
  137. @param {Number} [end]
  138. @return {Array}
  139. */
  140. Array.prototype.slice = function(start,end) {};
  141. /**
  142. @param {function} [compareFn]
  143. @return {Array}
  144. */
  145. Array.prototype.sort = function(compareFn) {};
  146. /**
  147. @param {Number} [start]
  148. @param {Number} [deleteCount]
  149. @param {...*} [items]
  150. @return {Array}
  151. */
  152. Array.prototype.splice = function(start,deleteCount,items) {};
  153. /**
  154. @param {...*} [items]
  155. @return {Number}
  156. */
  157. Array.prototype.unshift = function(items) {};
  158. /**
  159. @return {Array}
  160. */
  161. Array.prototype.valueOf = function() {};
  162.  
  163. /**
  164. @param [value]
  165. @constructor
  166. @return {boolean}
  167. */
  168. function Boolean(value) {}
  169. /**
  170. @return {boolean}
  171. */
  172. Boolean.prototype.valueOf = function() {};
  173.  
  174. /**
  175. @param {number} year
  176. @param {number} month
  177. @param {number} [date]
  178. @param {number} [hours]
  179. @param {number} [minutes]
  180. @param {number} [seconds]
  181. @param {number} [milliseconds]
  182. @static
  183. @return {number}
  184. */
  185. Date.UTC = function(year,month,date,hours,minutes,seconds,milliseconds) {};
  186. /**
  187. @param {string} dateString
  188. @static
  189. @return {number}
  190. */
  191. Date.parse = function(dateString) {};
  192. /**
  193. @param {...*} args
  194. @constructor
  195. */
  196. function Date(args) {}
  197. /**
  198. @return {number}
  199. */
  200. Date.prototype.getDate = function() {};
  201. /**
  202. @return {number}
  203. */
  204. Date.prototype.getDay = function() {};
  205. /**
  206. @return {number}
  207. */
  208. Date.prototype.getMonth = function() {};
  209. /**
  210. @return {number}
  211. */
  212. Date.prototype.getFullYear = function() {};
  213. /**
  214. @return {number}
  215. */
  216. Date.prototype.getHours = function() {};
  217. /**
  218. @return {number}
  219. */
  220. Date.prototype.getMilliseconds = function() {};
  221. /**
  222. @return {number}
  223. */
  224. Date.prototype.getMinutes = function() {};
  225. /**
  226. @return {number}
  227. */
  228. Date.prototype.getSeconds = function() {};
  229. /**
  230. @return {number}
  231. */
  232. Date.prototype.getTime = function() {};
  233. /**
  234. @return {number}
  235. */
  236. Date.prototype.getTimezoneOffset = function() {};
  237. /**
  238. @return {number}
  239. */
  240. Date.prototype.getUTCDate = function() {};
  241. /**
  242. @return {number}
  243. */
  244. Date.prototype.getUTCDay = function() {};
  245. /**
  246. @return {number}
  247. */
  248. Date.prototype.getUTCFullYear = function() {};
  249. /**
  250. @return {number}
  251. */
  252. Date.prototype.getUTCHours = function() {};
  253. /**
  254. @return {number}
  255. */
  256. Date.prototype.getUTCMilliseconds = function() {};
  257. /**
  258. @return {number}
  259. */
  260. Date.prototype.getUTCMinutes = function() {};
  261. /**
  262. @return {number}
  263. */
  264. Date.prototype.getUTCMonth = function() {};
  265. /**
  266. @return {number}
  267. */
  268. Date.prototype.getUTCSeconds = function() {};
  269. /**
  270. @return {number}
  271. */
  272. Date.prototype.getYear = function() {};
  273. /**
  274. @param {number} date
  275. */
  276. Date.prototype.setDate = function(date) {};
  277. /**
  278. @param {number} year
  279. @param {number} [month]
  280. @param {number} [day]
  281. */
  282. Date.prototype.setFullYear = function(year,month,day) {};
  283. /**
  284. @param {number} hour
  285. @param {number} [min]
  286. @param {number} [sec]
  287. @param {number} [ms]
  288. */
  289. Date.prototype.setHours = function(hour,min,sec,ms) {};
  290. /**
  291. @param {number} ms
  292. */
  293. Date.prototype.setMilliseconds = function(ms) {};
  294. /**
  295. @param {number} min
  296. @param {number} [sec]
  297. @param {number} [ms]
  298. */
  299. Date.prototype.setMinutes = function(min,sec,ms) {};
  300. /**
  301. @param {number} month
  302. @param {number} [day]
  303. */
  304. Date.prototype.setMonth = function(month,day) {};
  305. /**
  306. @param {number} sec
  307. @param {number} [ms]
  308. */
  309. Date.prototype.setSeconds = function(sec,ms) {};
  310. /**
  311. @param {number} time
  312. */
  313. Date.prototype.setTime = function(time) {};
  314. /**
  315. @param {number} date
  316. */
  317. Date.prototype.setUTCDate = function(date) {};
  318. /**
  319. @param {number} year
  320. @param {number} [month]
  321. @param {number} [day]
  322. */
  323. Date.prototype.setUTCFullYear = function(year,month,day) {};
  324. /**
  325. @param {number} hour
  326. @param {number} [min]
  327. @param {number} [sec]
  328. @param {number} [ms]
  329. */
  330. Date.prototype.setUTCHours = function(hour,min,sec,ms) {};
  331. /**
  332. @param {number} ms
  333. */
  334. Date.prototype.setUTCMilliseconds = function(ms) {};
  335. /**
  336. @param {number} min
  337. @param {number} [sec]
  338. @param {number} [ms]
  339. */
  340. Date.prototype.setUTCMinutes = function(min,sec,ms) {};
  341. /**
  342. @param {number} month
  343. @param {number} [day]
  344. */
  345. Date.prototype.setUTCMonth = function(month,day) {};
  346. /**
  347. @param {number} sec
  348. @param {number} [ms]
  349. */
  350. Date.prototype.setUTCSeconds = function(sec,ms) {};
  351. /**
  352. @param {number} value
  353. */
  354. Date.prototype.setYear = function(value) {};
  355. /**
  356. @return {string}
  357. */
  358. Date.prototype.toDateString = function() {};
  359. /**
  360. @return {string}
  361. */
  362. Date.prototype.toISOString = function() {};
  363. /**
  364. @return {string}
  365. */
  366. Date.prototype.toLocaleDateString = function() {};
  367. /**
  368. @return {string}
  369. */
  370. Date.prototype.toLocaleString = function() {};
  371. /**
  372. @return {string}
  373. */
  374. Date.prototype.toLocaleTimeString = function() {};
  375. /**
  376. @return {string}
  377. */
  378. Date.prototype.toTimeString = function() {};
  379. /**
  380. @return {string}
  381. */
  382. Date.prototype.toUTCString = function() {};
  383.  
  384. /**
  385. @type {function}
  386. */
  387. Arguments.prototype.callee = 0;
  388. /**
  389. @type {function}
  390. @const
  391. @deprecated
  392. */
  393. Arguments.prototype.caller = 0;
  394. Arguments.prototype = new Array();
  395. Arguments = {};
  396.  
  397. /**
  398. @type {Arguments}
  399. @const
  400. */
  401. Function.prototype.arguments = 0;
  402. /**
  403. @type {Number}
  404. @const
  405. */
  406. Function.prototype.arity = 0;
  407. /**
  408. @param {Object} [thisArg]
  409. @param {Array} [argArray]
  410. @return {*}
  411. */
  412. Function.prototype.apply = function(thisArg,argArray) {};
  413. /**
  414. @param {Object} [thisArg]
  415. @param {...*} [args]
  416. @return {*}
  417. */
  418. Function.prototype.call = function(thisArg,args) {};
  419. Function = {};
  420.  
  421. /**
  422. @static
  423. @type {number}
  424. @const
  425. */
  426. Math.E = 0;
  427. /**
  428. @static
  429. @type {number}
  430. @const
  431. */
  432. Math.LN10 = 0;
  433. /**
  434. @static
  435. @type {number}
  436. @const
  437. */
  438. Math.LN2 = 0;
  439. /**
  440. @static
  441. @type {number}
  442. @const
  443. */
  444. Math.LOG10E = 0;
  445. /**
  446. @static
  447. @type {number}
  448. @const
  449. */
  450. Math.LOG2E = 0;
  451. /**
  452. @static
  453. @type {number}
  454. @const
  455. */
  456. Math.PI = 0;
  457. /**
  458. @static
  459. @type {number}
  460. @const
  461. */
  462. Math.SQRT1_2 = 0;
  463. /**
  464. @static
  465. @type {number}
  466. @const
  467. */
  468. Math.SQRT2 = 0;
  469. /**
  470. @param {number} x
  471. @static
  472. @return {number}
  473. */
  474. Math.abs = function(x) {};
  475. /**
  476. @param {number} x
  477. @static
  478. @return {number}
  479. */
  480. Math.acos = function(x) {};
  481. /**
  482. @param {number} x
  483. @static
  484. @return {number}
  485. */
  486. Math.asin = function(x) {};
  487. /**
  488. @param {number} x
  489. @static
  490. @return {number}
  491. */
  492. Math.atan = function(x) {};
  493. /**
  494. @param {number} x
  495. @param {number} y
  496. @static
  497. @return {number}
  498. */
  499. Math.atan2 = function(x,y) {};
  500. /**
  501. @param {number} x
  502. @static
  503. @return {number}
  504. */
  505. Math.ceil = function(x) {};
  506. /**
  507. @param {number} x
  508. @static
  509. @return {number}
  510. */
  511. Math.cos = function(x) {};
  512. /**
  513. @param {number} x
  514. @static
  515. @return {number}
  516. */
  517. Math.exp = function(x) {};
  518. /**
  519. @param {number} x
  520. @static
  521. @return {number}
  522. */
  523. Math.floor = function(x) {};
  524. /**
  525. @param {number} x
  526. @static
  527. @return {number}
  528. */
  529. Math.log = function(x) {};
  530. /**
  531. @param {...number} x
  532. @static
  533. @return {number}
  534. */
  535. Math.max = function(x) {};
  536. /**
  537. @param {...number} x
  538. @static
  539. @return {number}
  540. */
  541. Math.min = function(x) {};
  542. /**
  543. @param {number} x
  544. @param {number} y
  545. @static
  546. @return {number}
  547. */
  548. Math.pow = function(x,y) {};
  549. /**
  550. @static
  551. @return {number}
  552. */
  553. Math.random = function() {};
  554. /**
  555. @param {number} x
  556. @static
  557. @return {number}
  558. */
  559. Math.round = function(x) {};
  560. /**
  561. @param {number} x
  562. @static
  563. @return {number}
  564. */
  565. Math.sin = function(x) {};
  566. /**
  567. @param {number} x
  568. @static
  569. @return {number}
  570. */
  571. Math.sqrt = function(x) {};
  572. /**
  573. @param {number} x
  574. @static
  575. @return {number}
  576. */
  577. Math.tan = function(x) {};
  578. Math = {};
  579.  
  580. /**
  581. @static
  582. @type {Number}
  583. @const
  584. */
  585. Number.MAX_VALUE = 0;
  586. /**
  587. @static
  588. @type {Number}
  589. @const
  590. */
  591. Number.MIN_VALUE = 0;
  592. /**
  593. @static
  594. @type {Number}
  595. @const
  596. */
  597. Number.NaN = 0;
  598. /**
  599. @static
  600. @type {Number}
  601. @const
  602. */
  603. Number.NEGATIVE_INFINITY = 0;
  604. /**
  605. @static
  606. @type {Number}
  607. @const
  608. */
  609. Number.POSITIVE_INFINITY = 0;
  610. /**
  611. @param [value]
  612. @constructor
  613. @return {number}
  614. */
  615. function Number(value) {}
  616. /**
  617. @param {Number} [fractionalDigits]
  618. @return {string}
  619. */
  620. Number.prototype.toExponential = function(fractionalDigits) {};
  621. /**
  622. @param {Number} [fractionalDigits]
  623. @return {string}
  624. */
  625. Number.prototype.toFixed = function(fractionalDigits) {};
  626. /**
  627. @param {Number} [precision]
  628. @return {string}
  629. */
  630. Number.prototype.toPrecision = function(precision) {};
  631. /**
  632. @param {Number} [radix]
  633. @return {string}
  634. */
  635. Number.prototype.toString = function(radix) {};
  636. /**
  637. @return {Number}
  638. */
  639. Number.prototype.valueOf = function() {};
  640.  
  641. /**
  642. @static
  643. @type {string}
  644. @const
  645. */
  646. RegExp.leftContext = 0;
  647. /**
  648. @static
  649. @type {string}
  650. @const
  651. */
  652. RegExp.input = 0;
  653. /**
  654. @static
  655. @type {string}
  656. @const
  657. */
  658. RegExp.lastParen = 0;
  659. /**
  660. @static
  661. @type {string}
  662. @const
  663. */
  664. RegExp.lastMatch = 0;
  665. /**
  666. @static
  667. @type {string}
  668. @const
  669. */
  670. RegExp.rightContext = 0;
  671. /**
  672. @static
  673. @type {string}
  674. @const
  675. */
  676. RegExp.$1 = 0;
  677. /**
  678. @static
  679. @type {string}
  680. @const
  681. */
  682. RegExp.$2 = 0;
  683. /**
  684. @static
  685. @type {string}
  686. @const
  687. */
  688. RegExp.$3 = 0;
  689. /**
  690. @static
  691. @type {string}
  692. @const
  693. */
  694. RegExp.$4 = 0;
  695. /**
  696. @static
  697. @type {string}
  698. @const
  699. */
  700. RegExp.$5 = 0;
  701. /**
  702. @type {boolean}
  703. @const
  704. */
  705. RegExp.prototype.global = 0;
  706. /**
  707. @type {boolean}
  708. @const
  709. */
  710. RegExp.prototype.ignoreCase = 0;
  711. /**
  712. @type {Number}
  713. */
  714. RegExp.prototype.lastIndex = 0;
  715. /**
  716. @type {boolean}
  717. */
  718. RegExp.prototype.multiline = 0;
  719. /**
  720. @type {string}
  721. */
  722. RegExp.prototype.source = 0;
  723. /**
  724. @param {string} [pattern]
  725. @param {string} [options]
  726. @constructor
  727. */
  728. function RegExp(pattern,options) {}
  729. /**
  730. @param {string} [String]
  731. @return {Array|{index:number, input:string}}
  732. */
  733. RegExp.prototype.exec = function(String) {};
  734. /**
  735. @param {string} [String]
  736. @return {boolean}
  737. */
  738. RegExp.prototype.test = function(String) {};
  739.  
  740. /**
  741. @param {...Number} [chars]
  742. @static
  743. @return {string}
  744. */
  745. String.fromCharCode = function(chars) {};
  746. /**
  747. @param [value]
  748. @constructor
  749. @return {string}
  750. */
  751. function String(value) {}
  752. /**
  753. @param {string} [nameAttribute]
  754. @return {string}
  755. */
  756. String.prototype.anchor = function(nameAttribute) {};
  757. /**
  758. @return {string}
  759. */
  760. String.prototype.big = function() {};
  761. /**
  762. @return {string}
  763. */
  764. String.prototype.blink = function() {};
  765. /**
  766. @return {string}
  767. */
  768. String.prototype.bold = function() {};
  769. /**
  770. @param {Number} pos
  771. @return {string}
  772. */
  773. String.prototype.charAt = function(pos) {};
  774. /**
  775. @return {Number}
  776. */
  777. String.prototype.charCodeAt = function(index) {};
  778. /**
  779. @param {...string} [strings]
  780. @return {string}
  781. */
  782. String.prototype.concat = function(strings) {};
  783. /**
  784. @return {string}
  785. */
  786. String.prototype.fixed = function() {};
  787. /**
  788. @param {string} color
  789. @return {string}
  790. */
  791. String.prototype.fontcolor = function(color) {};
  792. /**
  793. @param {Number} size
  794. @return {string}
  795. */
  796. String.prototype.fontsize = function(size) {};
  797. /**
  798. @param {string} searchString
  799. @param {Number} [position]
  800. @return {Number}
  801. */
  802. String.prototype.indexOf = function(searchString,position) {};
  803. /**
  804. @return {string}
  805. */
  806. String.prototype.italics = function() {};
  807. /**
  808. @param {string} searchString
  809. @param {Number} [position]
  810. @return {Number}
  811. */
  812. String.prototype.lastIndexOf = function(searchString,position) {};
  813. /**
  814. @param {string} href
  815. @return {string}
  816. */
  817. String.prototype.link = function(href) {};
  818. /**
  819. @param {string} that
  820. @return {boolean}
  821. */
  822. String.prototype.localeCompare = function(that) {};
  823. /**
  824. @param {RegExp} regexp
  825. @return {Array|{index:number, input:string}}
  826. */
  827. String.prototype.match = function(regexp) {};
  828. /**
  829. @param {RegExp|string} searchValue
  830. @param {string|function} replaceValue
  831. @return {string}
  832. */
  833. String.prototype.replace = function(searchValue,replaceValue) {};
  834. /**
  835. @param {*} regexp
  836. @return {Number}
  837. */
  838. String.prototype.search = function(regexp) {};
  839. /**
  840. @param {Number} start
  841. @param {Number} [end]
  842. @return {string}
  843. */
  844. String.prototype.slice = function(start,end) {};
  845. /**
  846. @return {string}
  847. */
  848. String.prototype.small = function() {};
  849. /**
  850. @param {*} separator
  851. @param {Number} [limit]
  852. @return {Array}
  853. */
  854. String.prototype.split = function(separator,limit) {};
  855. /**
  856. @return {string}
  857. */
  858. String.prototype.strike = function() {};
  859. /**
  860. @return {string}
  861. */
  862. String.prototype.sub = function() {};
  863. /**
  864. @param {Number} start
  865. @param {Number} [length]
  866. @return {string}
  867. */
  868. String.prototype.substr = function(start,length) {};
  869. /**
  870. @param {Number} start
  871. @param {Number} [end]
  872. @return {string}
  873. */
  874. String.prototype.substring = function(start,end) {};
  875. /**
  876. @return {string}
  877. */
  878. String.prototype.sup = function() {};
  879. /**
  880. @return {string}
  881. */
  882. String.prototype.toLowerCase = function() {};
  883. /**
  884. @return {string}
  885. */
  886. String.prototype.toLocaleLowerCase = function() {};
  887. /**
  888. @return {string}
  889. */
  890. String.prototype.toLocaleUpperCase = function() {};
  891. /**
  892. @return {string}
  893. */
  894. String.prototype.toUpperCase = function() {};
  895. /**
  896. @return {string}
  897. */
  898. String.prototype.valueOf = function() {};
  899.  
  900. /**
  901. @type {string}
  902. */
  903. Error.prototype.name = 0;
  904. /**
  905. @type {string}
  906. */
  907. Error.prototype.message = 0;
  908. /**
  909. @param {*} [msg]
  910. @param {*} [id]
  911. @constructor
  912. */
  913. function Error(msg,id) {}
  914.  
  915. EvalError.prototype = new Error();
  916. EvalError = {};
  917.  
  918. RangeError.prototype = new Error();
  919. RangeError = {};
  920.  
  921. ReferenceError.prototype = new Error();
  922. ReferenceError = {};
  923.  
  924. SyntaxError.prototype = new Error();
  925. SyntaxError = {};
  926.  
  927. TypeError.prototype = new Error();
  928. TypeError = {};
  929.  
  930. URIError.prototype = new Error();
  931. URIError = {};
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement