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.application.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 * @constructor
034 */
035 function DOMParser() {}
036 /**
037 * @param {!TrustedHTML|string} src The UTF16 string to be parsed.
038 * @param {string} type The content type of the string.
039 * @return {Document}
040 */
041 DOMParser.prototype.parseFromString = function(src, type) {};
042 /**
043 * @constructor
044 * @extends {Node}
045 */
046 function Document() {}
047 /**
048 * @return {!DocumentFragment}
049 * @nosideeffects
050 */
051 Document.prototype.createDocumentFragment = function() {};
052 /**
053 * @param {string} tagName
054 * @param {({is: string}|string)=} opt_typeExtension
055 * @return {!Element}
056 * @nosideeffects
057 */
058 Document.prototype.createElement = function(tagName, opt_typeExtension) {};
059 /**
060 * @constructor
061 * @extends {Node}
062 */
063 function DocumentFragment() {}
064 /**
065 * @param {string} name
066 * @param {?number=} flags
067 * @return {string}
068 * @nosideeffects
069 */
070 Element.prototype.getAttribute = function(name, flags) {};
071 /**
072 * @constructor
073 * @implements {IObject<(string|number), T>}
074 * @implements {IArrayLike<T>}
075 * @implements {Iterable<T>}
076 * @template T
077 */
078 function NamedNodeMap() {}
079 /**
080 * @param {number} index
081 * @return {Node}
082 * @nosideeffects
083 */
084 NamedNodeMap.prototype.item = function(index) {};
085 /**
086 * @type {number}
087 */
088 NamedNodeMap.prototype.length;
089 /**
090 * @constructor
091 */
092 function Node() {}
093 /**
094 * @param {Node} newChild
095 * @return {!Node}
096 */
097 Node.prototype.appendChild = function(newChild) {};
098 /**
099 * @type {!NodeList<!Node>}
100 */
101 Node.prototype.childNodes;
102 /**
103 * @param {boolean} deep
104 * @return {THIS}
105 * @this {THIS}
106 * @template THIS
107 * @nosideeffects
108 */
109 Node.prototype.cloneNode = function(deep) {};
110 /**
111 * @type {Node}
112 */
113 Node.prototype.firstChild;
114 /**
115 * @param {Node} newChild
116 * @param {Node} refChild
117 * @return {!Node}
118 */
119 Node.prototype.insertBefore = function(newChild, refChild) {};
120 /**
121 * @type {string}
122 */
123 Node.prototype.nodeName;
124 /**
125 * @type {number}
126 */
127 Node.prototype.nodeType;
128 /**
129 * @type {string}
130 */
131 Node.prototype.nodeValue;
132 /**
133 * @type {Document}
134 */
135 Node.prototype.ownerDocument;
136 /**
137 * @type {Node}
138 */
139 Node.prototype.parentNode;
140 /**
141 * @param {Node} oldChild
142 * @return {!Node}
143 */
144 Node.prototype.removeChild = function(oldChild) {};
145 /**
146 * @param {Node} newChild
147 * @param {Node} oldChild
148 * @return {!Node}
149 */
150 Node.prototype.replaceChild = function(newChild, oldChild) {};
151 /**
152 * @constructor
153 * @implements {IArrayLike<T>}
154 * @implements {Iterable<T>}
155 * @template T
156 */
157 function NodeList() {}
158 /**
159 * @param {?function(this:S, T, number, !NodeList<T>): ?} callback
160 * @param {S=} opt_thisobj
161 * @template S
162 * @return {undefined}
163 */
164 NodeList.prototype.forEach = function(callback, opt_thisobj) {};
165 /**
166 * @type {number}
167 */
168 NodeList.prototype.length;
169 /**
170 * @constructor
171 * @extends {Node}
172 */
173 function Element() {}
174 /**
175 * @constructor
176 */
177 function Window() {}
178 /**
179 * @param {!Node} externalNode
180 * @param {boolean=} deep
181 * @return {!Node}
182 */
183 Document.prototype.importNode = function(externalNode, deep) {};
184 /**
185 * @type {string}
186 * @implicitCast
187 */
188 Element.prototype.innerHTML;
189 /**
190 * @type {string}
191 * @implicitCast
192 */
193 Element.prototype.outerHTML;
194 /**
195 * @constructor
196 * @extends {Document}
197 */
198 function HTMLDocument() {}
199 /**
200 * @constructor
201 * @extends {Element}
202 */
203 function HTMLElement() {}
204 /**
205 * @param {?string} namespaceURI
206 * @param {string} localName
207 * @return {string}
208 * @nosideeffects
209 */
210 Element.prototype.getAttributeNS = function(namespaceURI, localName) {};
211 /**
212 * @param {?string} namespaceURI
213 * @param {string} localName
214 * @return {boolean}
215 * @nosideeffects
216 */
217 Element.prototype.hasAttributeNS = function(namespaceURI, localName) {};
218 /**
219 * @param {?string} namespaceURI
220 * @param {string} localName
221 * @return {undefined}
222 */
223 Element.prototype.removeAttributeNS = function(namespaceURI, localName) {};
224 /**
225 * @param {?string} namespaceURI
226 * @param {string} qualifiedName
227 * @param {string|number|boolean} value Values are converted to strings with
228 * @return {undefined}
229 */
230 Element.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {};
231 /**
232 * @param {Node} arg
233 * @return {boolean}
234 * @nosideeffects
235 */
236 Node.prototype.isEqualNode = function(arg) {};
237 /**
238 * @param {string} query
239 * @return {!NodeList<!Element>}
240 * @nosideeffects
241 */
242 Node.prototype.querySelectorAll = function(query) {};
243 /**
244 * @type {string}
245 */
246 Node.prototype.namespaceURI;
247 /**
248 * @type {string}
249 * @implicitCast
250 */
251 Node.prototype.textContent;
252 /** @constructor */
253 function TrustedHTML() {}
254 /**
255 * @const {!HTMLDocument}
256 */
257 var document;
258 /**
259 * @type {!Window}
260 */
261 var window;
262