Verzeichnisstruktur phpBB-3.3.15


Veröffentlicht
28.08.2024

So funktioniert es


Auf das letzte Element klicken. Dies geht jeweils ein Schritt zurück

Auf das Icon klicken, dies öffnet das Verzeichnis. Nochmal klicken schließt das Verzeichnis.
Auf den Verzeichnisnamen klicken, dies zeigt nur das Verzeichnis mit Inhalt an

(Beispiel Datei-Icons)

Auf das Icon klicken um den Quellcode anzuzeigen

externs.service.js

Zuletzt modifiziert: 02.04.2025, 15:04 - Dateigröße: 12.39 KiB


001  /*
002   * Copyright 2008 The Closure Compiler Authors
003   *
004   * Licensed under the Apache License, Version 2.0 (the "License");
005   * you may not use this file except in compliance with the License.
006   * You may obtain a copy of the License at
007   *
008   *     http://www.apache.org/licenses/LICENSE-2.0
009   *
010   * Unless required by applicable law or agreed to in writing, software
011   * distributed under the License is distributed on an "AS IS" BASIS,
012   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013   * See the License for the specific language governing permissions and
014   * limitations under the License.
015   */
016   
017  // This file was auto-generated.
018  // See https://github.com/google/closure-compiler for the original source.
019  // See https://github.com/s9e/TextFormatter/blob/master/scripts/generateExterns.php for details.
020   
021  /**
022   * @const
023   */
024  var punycode = {};
025  /**
026   * @param {string} domain
027   * @return {string}
028   */
029  punycode.toASCII;
030  /** @constructor */
031  function XSLTProcessor() {}
032  /**
033   * @type {number}
034   * @const
035   */
036  var Infinity;
037  /**
038   * @type {undefined}
039   * @const
040   */
041  var undefined;
042  /**
043   * @constructor
044   * @param {*=} opt_description
045   * @return {symbol}
046   * @nosideeffects
047   */
048  function Symbol(opt_description) {}
049  /**
050   * @param {string} uri
051   * @return {string}
052   * @throws {URIError} when used wrongly.
053   */
054  function decodeURIComponent(uri) {}
055  /**
056   * @param {string} uri
057   * @return {string}
058   * @throws {URIError} if one attempts to encode a surrogate which is not part of
059   */
060  function encodeURIComponent(uri) {}
061  /**
062   * @param {string} str
063   * @return {string}
064   * @nosideeffects
065   */
066  function escape(str) {}
067  /**
068   * @param {*} num
069   * @return {boolean}
070   * @nosideeffects
071   */
072  function isNaN(num) {}
073  /**
074   * @param {*} num
075   * @param {number|undefined} base
076   * @return {number}
077   * @nosideeffects
078   */
079  function parseInt(num, base) {}
080  /**
081   * @constructor
082   * @implements {IArrayLike<T>}
083   * @implements {Iterable<T>}
084   * @param {...*} var_args
085   * @return {!Array}
086   * @nosideeffects
087   * @template T
088   */
089  function Array(var_args) {}
090  /**
091   * @param {?function(this:S, T, number, !Array<T>): ?} callback
092   * @param {S=} opt_thisobj
093   * @this {IArrayLike<T>|string}
094   * @template T,S
095   * @return {undefined}
096   */
097  Array.prototype.forEach = function(callback, opt_thisobj) {};
098  /**
099   * @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;
595