google-closure-compiler 20250412.0.0-nightly → 20250413.0.0

package/externs/browser/whatwg_console.js

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2019 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for console debugging facilities.
+ *     https://console.spec.whatwg.org/
+ * @externs
+ */
+
+/**
+ * @constructor
+ * @see https://console.spec.whatwg.org/
+ */
+function Console() {};
+
+/**
+ * If condition is false, perform Logger("error", data).
+ * @param {*} condition
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.assert = function(condition, var_data) {};
+
+/**
+ * @return {undefined}
+ */
+Console.prototype.clear = function() {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.debug = function(var_data) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.error = function(var_data) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.info = function(var_data) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.log = function(var_data) {};
+
+/**
+ * @param {!Object} tabularData
+ * @param {*=} properties
+ * @return {undefined}
+ */
+Console.prototype.table = function(tabularData, properties) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.trace = function(var_data) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.warn = function(var_data) {};
+
+/**
+ * @param {*} item
+ * @return {undefined}
+ */
+Console.prototype.dir = function(item) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.dirxml = function(var_data) {};
+
+/**
+ * @param {string=} label
+ * @return {undefined}
+ */
+Console.prototype.count = function(label) {};
+
+/**
+ * @param {string=} label
+ * @return {undefined}
+ */
+Console.prototype.countReset = function(label) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.group = function(var_data) {};
+
+/**
+ * @param {...*} var_data
+ * @return {undefined}
+ */
+Console.prototype.groupCollapsed = function(var_data) {};
+
+/**
+ * @return {undefined}
+ */
+Console.prototype.groupEnd = function() {};
+
+/**
+ * @param {string} label
+ * @return {undefined}
+ */
+Console.prototype.time = function(label) {};
+
+/**
+ * @param {string} label
+ * @param {...*} data
+ * @return {undefined}
+ */
+Console.prototype.timeLog = function(label, data) {};
+
+/**
+ * @param {string} label
+ * @return {undefined}
+ */
+Console.prototype.timeEnd = function(label) {};
+
+/** @type {!Console} */
+Window.prototype.console;
+
+/**
+ * @type {!Console}
+ * @suppress {duplicate}
+ */
+var console;

package/externs/browser/whatwg_encoding.js

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2015 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Definitions for WHATWG's Encoding specification
+ *     https://encoding.spec.whatwg.org
+ * @externs
+ */
+
+/**
+ * @constructor
+ * @param {string=} encoding
+ * @param {Object=} options
+ */
+function TextDecoder(encoding, options) {}
+
+/** @type {string} **/ TextDecoder.prototype.encoding;
+/** @type {boolean} **/ TextDecoder.prototype.fatal;
+/** @type {boolean} **/ TextDecoder.prototype.ignoreBOM;
+
+/**
+ * @param {!BufferSource=} input
+ * @param {?Object=} options
+ * @return {string}
+ * @see https://encoding.spec.whatwg.org/#textdecoder
+ */
+TextDecoder.prototype.decode = function decode(input, options) {};
+
+/**
+ * @constructor
+ * @param {string=} utfLabel
+ */
+function TextEncoder(utfLabel) {}
+
+/** @type {string} **/ TextEncoder.prototype.encoding;
+
+/**
+ * @param {string=} input
+ * @return {!Uint8Array}
+ */
+TextEncoder.prototype.encode = function(input) {};
+
+/**
+ * @param {string} input
+ * @param {!Uint8Array} uint8Array
+ * @return {{read: number, written: number}}
+ */
+TextEncoder.prototype.encodeInto = function(input, uint8Array) {};
+
+/**
+ * @constructor
+ * @param {string=} encoding
+ * @param {Object=} options
+ */
+function TextDecoderStream(encoding, options) {}
+
+/** @type {string} **/ TextDecoderStream.prototype.encoding;
+/** @type {boolean} **/ TextDecoderStream.prototype.fatal;
+/** @type {boolean} **/ TextDecoderStream.prototype.ignoreBOM;
+
+/**
+ * @type {ReadableStream<string>}
+ */
+TextDecoderStream.prototype.readable;
+
+/**
+ * @type {WritableStream<BufferSource>}
+ */
+TextDecoderStream.prototype.writable;
+
+/**
+ * @constructor
+ */
+function TextEncoderStream() {}
+
+/** @type {string} **/ TextEncoderStream.prototype.encoding;
+
+/**
+ * @type {ReadableStream<Uint8Array>}
+ */
+TextEncoderStream.prototype.readable;
+
+/**
+ * @type {WritableStream<string>}
+ */
+TextEncoderStream.prototype.writable;

package/externs/browser/whatwg_file_system.js

@@ -0,0 +1,296 @@
+/*
+ * Copyright 2020 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * File System
+ * Living Standard — Last Updated 24 January 2023
+ * @see https://fs.spec.whatwg.org/
+ * @externs
+ */
+
+
+
+/**
+ * @typedef {string}
+ * @see https://fs.spec.whatwg.org/#enumdef-filesystemhandlekind
+ */
+var FileSystemHandleKind;
+
+
+/**
+ * @interface
+ * @see https://fs.spec.whatwg.org/#api-filesystemhandle
+ */
+var FileSystemHandle = function() {};
+
+/** @const {!FileSystemHandleKind} */
+FileSystemHandle.prototype.kind;
+
+/** @const {string} */
+FileSystemHandle.prototype.name;
+
+/**
+ * @param {!FileSystemHandle} other
+ * @return {!Promise<boolean>}
+ */
+FileSystemHandle.prototype.isSameEntry = function(other) {};
+
+
+/**
+ * @record
+ * @struct
+ * @see https://fs.spec.whatwg.org/#dictdef-filesystemcreatewritableoptions
+ */
+var FileSystemCreateWritableOptions = function() {};
+
+/** @type {undefined|boolean} */
+FileSystemCreateWritableOptions.prototype.keepExistingData;
+
+
+/**
+ * @interface
+ * @extends {FileSystemHandle}
+ * @see https://fs.spec.whatwg.org/#filesystemfilehandle
+ */
+var FileSystemFileHandle = function() {};
+
+/**
+ * @return {!Promise<!File>}
+ */
+FileSystemFileHandle.prototype.getFile = function() {};
+
+/**
+ * @param {!FileSystemCreateWritableOptions=} opt_options
+ * @return {!Promise<!FileSystemWritableFileStream>}
+ */
+FileSystemFileHandle.prototype.createWritable = function(opt_options) {};
+
+/**
+ * @return {!Promise<!FileSystemSyncAccessHandle>}
+ */
+FileSystemFileHandle.prototype.createSyncAccessHandle = function() {};
+
+/**
+ * @return {!Promise<string>}
+ */
+FileSystemFileHandle.prototype.getUniqueId = function() {};
+
+
+/**
+ * @record
+ * @struct
+ * @see https://fs.spec.whatwg.org/#dictdef-filesystemgetfileoptions
+ */
+var FileSystemGetFileOptions = function() {};
+
+/** @type {undefined|boolean} */
+FileSystemGetFileOptions.prototype.create;
+
+
+/**
+ * @record
+ * @struct
+ * @see https://fs.spec.whatwg.org/#dictdef-filesystemgetdirectoryoptions
+ */
+var FileSystemGetDirectoryOptions = function() {};
+
+/** @type {undefined|boolean} */
+FileSystemGetDirectoryOptions.prototype.create;
+
+
+/**
+ * @record
+ * @struct
+ * @see https://fs.spec.whatwg.org/#dictdef-filesystemremoveoptions
+ */
+var FileSystemRemoveOptions = function() {};
+
+/** @type {undefined|boolean} */
+FileSystemRemoveOptions.prototype.recursive;
+
+
+/**
+ * @interface
+ * @extends {FileSystemHandle}
+ * @extends {AsyncIterable<!Array<string|!FileSystemHandle>>}
+ * @see https://fs.spec.whatwg.org/#filesystemdirectoryhandle
+ */
+var FileSystemDirectoryHandle = function() {};
+
+/**
+ * @param {string} name
+ * @param {!FileSystemGetFileOptions=} opt_options
+ * @return {!Promise<!FileSystemFileHandle>}
+ */
+FileSystemDirectoryHandle.prototype.getFileHandle = function(name, opt_options) {};
+
+/**
+ * @param {string} name
+ * @param {!FileSystemGetDirectoryOptions=} opt_options
+ * @return {!Promise<!FileSystemDirectoryHandle>}
+ */
+FileSystemDirectoryHandle.prototype.getDirectoryHandle = function(name, opt_options) {};
+
+/**
+ * @param {string} name
+ * @param {!FileSystemRemoveOptions=} opt_options
+ * @return {!Promise<void>}
+ */
+FileSystemDirectoryHandle.prototype.removeEntry = function(name, opt_options) {};
+
+/**
+ * @param {!FileSystemHandle} possibleDescendant
+ * @return {!Promise<?Array<string>>}
+ */
+FileSystemDirectoryHandle.prototype.resolve = function(possibleDescendant) {};
+
+/**
+ * @return {!AsyncIterable<!Array<string|!FileSystemHandle>>}
+ * @see https://fs.spec.whatwg.org/#api-filesystemdirectoryhandle-asynciterable
+ */
+FileSystemDirectoryHandle.prototype.entries = function() {};
+
+/**
+ * @return {!AsyncIterable<!FileSystemHandle>}
+ * @see https://fs.spec.whatwg.org/#api-filesystemdirectoryhandle-asynciterable
+ */
+FileSystemDirectoryHandle.prototype.values = function() {};
+
+/**
+ * @return {!AsyncIterable<string>}
+ * @see https://fs.spec.whatwg.org/#api-filesystemdirectoryhandle-asynciterable
+ */
+FileSystemDirectoryHandle.prototype.keys = function() {};
+
+
+/**
+ * @typedef {string}
+ * @see https://fs.spec.whatwg.org/#enumdef-writecommandtype
+ */
+var WriteCommandType;
+
+
+/**
+ * @record
+ * @struct
+ * @see https://fs.spec.whatwg.org/#dictdef-writeparams
+ */
+var WriteParams = function() {};
+
+/** @type {!WriteCommandType} */
+WriteParams.prototype.type;
+
+/** @type {undefined|?number} */
+WriteParams.prototype.size;
+
+/** @type {undefined|?number} */
+WriteParams.prototype.position;
+
+/** @type {undefined|!BufferSource|!Blob|?string} */
+WriteParams.prototype.data;
+
+
+/**
+ * @typedef {!BufferSource|!Blob|string|!WriteParams}
+ * @see https://fs.spec.whatwg.org/#typedefdef-filesystemwritechunktype
+ */
+var FileSystemWriteChunkType;
+
+
+/**
+ * @constructor
+ * @extends {WritableStream}
+ * @see https://fs.spec.whatwg.org/#filesystemwritablefilestream
+ */
+var FileSystemWritableFileStream = function() {};
+
+/**
+ * @param {!FileSystemWriteChunkType} data
+ * @return {!Promise<void>}
+ */
+FileSystemWritableFileStream.prototype.write = function(data) {};
+
+/**
+ * @param {number} position
+ * @return {!Promise<void>}
+ */
+FileSystemWritableFileStream.prototype.seek = function(position) {};
+
+/**
+ * @param {number} size
+ * @return {!Promise<void>}
+ */
+FileSystemWritableFileStream.prototype.truncate = function(size) {};
+
+
+/**
+ * @record
+ * @struct
+ * @see https://fs.spec.whatwg.org/#filesystemwritablefilestream
+ */
+var FileSystemReadWriteOptions = function() {};
+
+/** @type {undefined|number} */
+FileSystemReadWriteOptions.prototype.at;
+
+
+/**
+ * @interface
+ * @see https://fs.spec.whatwg.org/#filesystemsyncaccesshandle
+ */
+var FileSystemSyncAccessHandle = function() {};
+
+/**
+ * @param {!BufferSource} buffer
+ * @param {!FileSystemReadWriteOptions=} opt_options
+ * @return {number}
+ */
+FileSystemSyncAccessHandle.prototype.read = function(buffer, opt_options) {};
+
+/**
+ * @param {!BufferSource} buffer
+ * @param {!FileSystemReadWriteOptions=} opt_options
+ * @return {number}
+ */
+FileSystemSyncAccessHandle.prototype.write = function(buffer, opt_options) {};
+
+/**
+ * @param {number} newSize
+ * @return {void}
+ */
+FileSystemSyncAccessHandle.prototype.truncate = function(newSize) {};
+
+/**
+ * @return {number}
+ */
+FileSystemSyncAccessHandle.prototype.getSize = function() {};
+
+/**
+ * @return {void}
+ */
+FileSystemSyncAccessHandle.prototype.flush = function() {};
+
+/**
+ * @return {void}
+ */
+FileSystemSyncAccessHandle.prototype.close = function() {};
+
+
+/**
+ * @return {!Promise<!FileSystemDirectoryHandle>}
+ * @see https://fs.spec.whatwg.org/#sandboxed-filesystem
+ */
+StorageManager.prototype.getDirectory = function() {};

package/externs/browser/wicg_attribution_reporting.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2023 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview The spec of the Attribution Reporting API.
+ * @see https://github.com/WICG/attribution-reporting-api
+ * @externs
+ */
+
+/**
+ * @see https://wicg.github.io/attribution-reporting-api/#dictdef-attributionreportingrequestoptions
+ * @record
+ * @struct
+ */
+function AttributionReportingRequestOptions() {}
+
+/** @type {boolean} */
+AttributionReportingRequestOptions.prototype.eventSourceEligible;
+
+/** @type {boolean} */
+AttributionReportingRequestOptions.prototype.triggerEligible;
+
+/**
+ * @param {!AttributionReportingRequestOptions=} options The request options to
+ *     pass eligibility signal for source or trigger registration via XHR.
+ * @return {void}
+ * @see https://wicg.github.io/attribution-reporting-api/#dom-xmlhttprequest-setattributionreporting
+ */
+XMLHttpRequest.prototype.setAttributionReporting = function(options) {};

package/externs/browser/wicg_compression_stream.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2021 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview APIs used to compress and decompress streams of data.
+ * @see https://wicg.github.io/compression
+ * @see https://github.com/WICG/compression/blob/master/explainer.md
+ * @externs
+ */
+
+/**
+ * @constructor
+ * @see https://wicg.github.io/compression/#compressionstream
+ * @param {string} format
+ * @see https://wicg.github.io/compression/#supported-formats
+ * @template IN_VALUE, OUT_VALUE
+ */
+function CompressionStream(format) {}
+
+/**
+ * @type {!ReadableStream<IN_VALUE>}
+ */
+CompressionStream.prototype.readable;
+
+/**
+ * @type {!WritableStream<OUT_VALUE>}
+ */
+CompressionStream.prototype.writable;
+
+/**
+ * @constructor
+ * @see https://wicg.github.io/compression/#decompression-stream
+ * @param {string} format
+ * @see https://wicg.github.io/compression/#supported-formats
+ * @template IN_VALUE, OUT_VALUE
+ */
+function DecompressionStream(format) {}
+
+/**
+ * @type {!ReadableStream<IN_VALUE>}
+ */
+DecompressionStream.prototype.readable;
+
+/**
+ * @type {!WritableStream<OUT_VALUE>}
+ */
+DecompressionStream.prototype.writable;

package/externs/browser/wicg_constructable_stylesheets.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2021 The Closure Compiler Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @fileoverview The current draft spec of constructable stylesheets.
+ * @see https://wicg.github.io/construct-stylesheets/
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/CSSStyleSheet
+ * @externs
+ */
+
+// https://wicg.github.io/construct-stylesheets/#dictdef-cssstylesheetinit
+/** @type {(undefined|MediaList|string)} */
+CSSStyleSheetInit.prototype.media;
+
+/** @type {(undefined|string)} */
+CSSStyleSheetInit.prototype.title;
+
+/** @type {(undefined|boolean)} */
+CSSStyleSheetInit.prototype.alternate;
+
+/** @type {(undefined|boolean)} */
+CSSStyleSheetInit.prototype.disabled;
+
+/**
+ * @param {string} text
+ * @return {!Promise<!CSSStyleSheet>}
+ * @see https://wicg.github.io/construct-stylesheets/#dom-cssstylesheet-replace
+ */
+CSSStyleSheet.prototype.replace = function(text) {};
+
+/**
+ * @param {string} text
+ * @return {void}
+ * @see https://wicg.github.io/construct-stylesheets/#dom-cssstylesheet-replacesync
+ */
+CSSStyleSheet.prototype.replaceSync = function(text) {};
+
+/**
+ * @type {!Array<!CSSStyleSheet>}
+ * @see https://wicg.github.io/construct-stylesheets/#dom-documentorshadowroot-adoptedstylesheets
+ */
+Document.prototype.adoptedStyleSheets;
+
+/**
+ * @type {!Array<!CSSStyleSheet>}
+ * @see https://wicg.github.io/construct-stylesheets/#dom-documentorshadowroot-adoptedstylesheets
+ */
+ShadowRoot.prototype.adoptedStyleSheets;