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.application.js

Zuletzt modifiziert: 02.04.2025, 15:04 - Dateigröße: 5.37 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   * @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