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. |
|
(Beispiel Datei-Icons)
|
Auf das Icon klicken um den Quellcode anzuzeigen |
externs.service.js
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