Verzeichnisstruktur phpBB-3.2.0
- Veröffentlicht
- 06.01.2017
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 /** @typedef {?} */
043 var symbol;
044 /**
045 * @param {string=} opt_description
046 * @return {symbol}
047 */
048 function Symbol(opt_description) {}
049 /**
050 * @param {string} uri
051 * @return {string}
052 * @nosideeffects
053 */
054 function decodeURIComponent(uri) {}
055 /**
056 * @param {string} uri
057 * @return {string}
058 * @nosideeffects
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} 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_compareFunction 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_compareFunction) {};
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 * @nosideeffects
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 * @param {*=} opt_str
286 * @return {string}
287 * @nosideeffects
288 */
289 function String(opt_str) {}
290 /**
291 * @param {...number} var_args
292 * @return {string}
293 * @nosideeffects
294 */
295 String.fromCharCode = function(var_args) {};
296 /**
297 * @this {String|string}
298 * @param {number} index
299 * @return {string}
300 * @nosideeffects
301 */
302 String.prototype.charAt = function(index) {};
303 /**
304 * @this {String|string}
305 * @param {number=} opt_index
306 * @return {number}
307 * @nosideeffects
308 */
309 String.prototype.charCodeAt = function(opt_index) {};
310 /**
311 * @this {String|string}
312 * @param {string|null} searchValue
313 * @param {(number|null)=} opt_fromIndex
314 * @return {number}
315 * @nosideeffects
316 */
317 String.prototype.indexOf = function(searchValue, opt_fromIndex) {};
318 /**
319 * @type {number}
320 */
321 String.prototype.length;
322 /**
323 * @this {String|string}
324 * @param {RegExp|string} regex
325 * @param {string|Function} str
326 * @param {string=} opt_flags
327 * @return {string}
328 */
329 String.prototype.replace = function(regex, str, opt_flags) {};
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;
554