- #tabbrowser-arrowscrollbox > &[pinned] {
@@ -20,16 +20,16 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
+
}
- #tabbrowser-tabs[movingtab] &:is([selected], [multiselected]) {
-@@ -254,7 +253,6 @@
+ #tabbrowser-tabs[movingtab] &:is(:active, [multiselected]) {
+@@ -257,7 +256,6 @@
}
- :root:not([uidensity=compact]) &[pinned] {
+ :root:not([uidensity=compact], [sidebar-expand-on-hover]) &[pinned] {
- padding: 0 10px;
}
&:is([selected], [multiselected]) {
-@@ -268,6 +266,7 @@
+@@ -271,6 +269,7 @@
border-radius: inherit;
position: relative;
overflow: hidden;
@@ -37,7 +37,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
&::before {
position: absolute;
-@@ -442,6 +441,7 @@
+@@ -458,6 +457,7 @@
.tab-icon-image {
-moz-context-properties: fill, stroke;
fill: currentColor;
@@ -45,7 +45,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
/* Apply crisp rendering for favicons at exactly 2dppx resolution */
@media (resolution: 2dppx) {
-@@ -523,7 +523,7 @@
+@@ -557,7 +557,7 @@
z-index: 1; /* Overlay tab title */
#tabbrowser-tabs[orient=vertical] & {
@@ -54,7 +54,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
}
&[crashed] {
-@@ -531,7 +531,7 @@
+@@ -565,7 +565,7 @@
}
#tabbrowser-tabs[orient="vertical"]:not([expanded]) &:not([crashed]),
@@ -63,7 +63,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
&[soundplaying] {
list-style-image: url("chrome://browser/skin/tabbrowser/tab-audio-playing-small.svg");
}
-@@ -561,7 +561,7 @@
+@@ -595,7 +595,7 @@
background-image: linear-gradient(var(--audio-overlay-extra-background)),
linear-gradient(var(--toolbox-bgcolor));
-moz-context-properties: fill;
@@ -72,44 +72,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
color-scheme: var(--tab-selected-color-scheme);
border-radius: var(--border-radius-circle);
-@@ -593,7 +593,7 @@
- }
-
- #tabbrowser-tabs[orient="vertical"]:not([expanded]) &:is([soundplaying], [muted], [activemedia-blocked]),
-- &[pinned]:is([soundplaying], [muted], [activemedia-blocked]),
-+ &:is([soundplaying], [muted], [activemedia-blocked]),
- &[crashed] {
- display: revert;
- }
-@@ -607,7 +607,7 @@
- --button-min-height-small: 24px;
- --button-border-radius: var(--border-radius-small);
-
-- #tabbrowser-tabs:is([orient="vertical"][expanded], [orient="horizontal"]) &:not([pinned]):not([crashed]) {
-+ #tabbrowser-tabs:is([orient="horizontal"]) &:not([pinned]):not([crashed]) {
- &:is([soundplaying], [muted], [activemedia-blocked]) {
- display: block;
- }
-@@ -638,14 +638,14 @@
- }
-
- &[textoverflow] {
-- &[labeldirection=ltr]:not([pinned]),
-- &:not([labeldirection], [pinned]):-moz-locale-dir(ltr) {
-+ &[labeldirection=ltr],
-+ &:not([labeldirection]):-moz-locale-dir(ltr) {
- direction: ltr;
- mask-image: linear-gradient(to left, transparent, black var(--tab-label-mask-size));
- }
-
-- &[labeldirection=rtl]:not([pinned]),
-- &:not([labeldirection], [pinned]):-moz-locale-dir(rtl) {
-+ &[labeldirection=rtl],
-+ &:not([labeldirection]):-moz-locale-dir(rtl) {
- direction: rtl;
- mask-image: linear-gradient(to right, transparent, black var(--tab-label-mask-size));
- }
-@@ -1201,7 +1201,7 @@
+@@ -1362,7 +1362,7 @@ tab-group {
}
}
@@ -118,7 +81,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
#vertical-tabs-newtab-button {
appearance: none;
min-height: var(--tab-min-height);
-@@ -1212,7 +1212,7 @@
+@@ -1373,7 +1373,7 @@ tab-group {
margin-inline: var(--tab-inner-inline-margin);
#tabbrowser-tabs[orient="vertical"]:not([expanded]) & > .toolbarbutton-text {
@@ -127,7 +90,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
}
&:hover {
-@@ -1236,7 +1236,7 @@
+@@ -1397,7 +1397,7 @@ tab-group {
* flex container. #tabs-newtab-button is a child of the arrowscrollbox where
* we don't want a gap (between tabs), so we have to add some margin.
*/
@@ -136,15 +99,16 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
margin-block: var(--tab-block-margin);
}
-@@ -1260,7 +1260,6 @@
- }
+@@ -1471,8 +1471,6 @@ tab-group {
+ }
- #vertical-pinned-tabs-container {
-- --tab-inline-padding: calc((calc(var(--tab-collapsed-background-width) + 2 * var(--tab-pinned-margin-inline-expanded) - var(--icon-size-default)) / 2));
- display: none;
- grid-template-columns: repeat(auto-fit, minmax(var(--tab-pinned-min-width-expanded), auto));
- overflow-y: auto;
-@@ -1480,7 +1479,7 @@
+ :root:not([sidebar-expand-on-hover]) & {
+- --tab-inline-padding: calc((var(--tab-collapsed-background-width) + 2 *
+- var(--tab-pinned-margin-inline-expanded) - var(--icon-size-default)) / 2);
+ /* stylelint-disable-next-line media-query-no-invalid */
+ @media not -moz-pref("sidebar.visibility", "expand-on-hover") {
+ /* We need these rules to apply at all times when the sidebar.visibility
+@@ -1717,7 +1715,7 @@ tab-group {
toolbarbutton:not(#firefox-view-button),
toolbarpaletteitem:not(#wrapper-firefox-view-button)
) ~ #tabbrowser-tabs {
@@ -153,7 +117,7 @@ index bafbb39aac37843e3b6dceb0e81304af51e186cc..92b4fd725118150634ab2ae0a24efb52
padding-inline-start: calc(var(--tab-overflow-pinned-tabs-width) + 2px);
margin-inline-start: 2px;
}
-@@ -1514,7 +1513,6 @@ toolbar:not(#TabsToolbar) #firefox-view-button {
+@@ -1751,7 +1749,6 @@ toolbar:not(#TabsToolbar) #firefox-view-button {
list-style-image: url(chrome://global/skin/icons/plus.svg);
}
diff --git a/src/browser/themes/windows/browser-css.patch b/src/browser/themes/windows/browser-css.patch
index 0c84456fa..e75b753be 100644
--- a/src/browser/themes/windows/browser-css.patch
+++ b/src/browser/themes/windows/browser-css.patch
@@ -1,14 +1,8 @@
diff --git a/browser/themes/windows/browser.css b/browser/themes/windows/browser.css
-index 9af78803f0005a2b89e1c73f52153ed4d9e3154a..f5b21a09347f5890da3eef0efa38a66195c8e418 100644
+index 3e75a5f366e76acf4b9457a510b58b0cb8af580f..4962151f34ff52e8d009b82a9a12da99c4745a7a 100644
--- a/browser/themes/windows/browser.css
+++ b/browser/themes/windows/browser.css
-@@ -40,13 +40,12 @@
- * override these on the tabs toolbar because the accent color is
- * arbitrary, so the hardcoded colors from browser-custom-colors might
- * not provide sufficient contrast. */
-- --toolbarbutton-icon-fill: currentColor;
- --toolbarbutton-hover-background: color-mix(in srgb, currentColor 17%, transparent);
- --toolbarbutton-active-background: color-mix(in srgb, currentColor 30%, transparent);
+@@ -57,7 +57,7 @@
}
}
diff --git a/src/modules/libpref/init/zen-static-prefs.inc b/src/modules/libpref/init/zen-static-prefs.inc
index b53d20ae2..2761dbb22 100644
--- a/src/modules/libpref/init/zen-static-prefs.inc
+++ b/src/modules/libpref/init/zen-static-prefs.inc
@@ -11,10 +11,3 @@
value: 1
mirror: always
#endif
-
-#ifdef XP_WIN
-- name: zen.widget.windows.acrylic
- type: bool
- value: true
- mirror: always
-#endif
diff --git a/src/toolkit/content/aboutSupport-xhtml.patch b/src/toolkit/content/aboutSupport-xhtml.patch
index 61b7b7b0b..b2bd09de8 100644
--- a/src/toolkit/content/aboutSupport-xhtml.patch
+++ b/src/toolkit/content/aboutSupport-xhtml.patch
@@ -1,12 +1,12 @@
diff --git a/toolkit/content/aboutSupport.xhtml b/toolkit/content/aboutSupport.xhtml
-index 05e3d72a6e67900e9b3d9bfd35c89b056c7ca747..55408e77830492765c976dd967ca14a7b74cba97 100644
+index 296259cd0360a403e8659e22d0c08e968529a38a..bde1ee8d0a05e6ce2eb3ff8ff8a19ba28c20af98 100644
--- a/toolkit/content/aboutSupport.xhtml
+++ b/toolkit/content/aboutSupport.xhtml
-@@ -31,6 +31,7 @@
- #ifndef ANDROID
-
- #endif
-+
-
+@@ -10,6 +10,7 @@
-
+
+
++
+
+
+
diff --git a/src/toolkit/mozapps/extensions/internal/XPIProvider-sys-mjs.patch b/src/toolkit/mozapps/extensions/internal/XPIProvider-sys-mjs.patch
index 8bb6cf4ce..f916df9de 100644
--- a/src/toolkit/mozapps/extensions/internal/XPIProvider-sys-mjs.patch
+++ b/src/toolkit/mozapps/extensions/internal/XPIProvider-sys-mjs.patch
@@ -1,15 +1,15 @@
diff --git a/toolkit/mozapps/extensions/internal/XPIProvider.sys.mjs b/toolkit/mozapps/extensions/internal/XPIProvider.sys.mjs
-index 3af9a7779dd43a6ded906ceaf6768c56d53c8605..c0b597fa3f8073b9bfb4118d5352246a5b54c2d7 100644
+index 2cafde2156680a557081c5b82923f14618749358..0f4f5160f649165df80f35fbe72e02786a5b867e 100644
--- a/toolkit/mozapps/extensions/internal/XPIProvider.sys.mjs
+++ b/toolkit/mozapps/extensions/internal/XPIProvider.sys.mjs
-@@ -2556,8 +2556,8 @@ export var XPIProvider = {
+@@ -2674,8 +2674,8 @@ export var XPIProvider = {
+ if (AppConstants.platform != "android") {
+ // Keep version in sync with toolkit/mozapps/extensions/default-theme/manifest.json
+ this.maybeInstallBuiltinAddon(
+- "default-theme@mozilla.org",
+- "1.4.1",
++ "firefox-compact-dark@mozilla.org",
++ "1.3",
+ "resource://default-theme/"
+ );
}
- // Keep version in sync with toolkit/mozapps/extensions/default-theme/manifest.json
- this.maybeInstallBuiltinAddon(
-- "default-theme@mozilla.org",
-- "1.4.1",
-+ "firefox-compact-dark@mozilla.org",
-+ "1.3",
- "resource://default-theme/"
- );
-
diff --git a/src/toolkit/themes/shared/popup-css.patch b/src/toolkit/themes/shared/popup-css.patch
index f5e674f12..b5db33881 100644
--- a/src/toolkit/themes/shared/popup-css.patch
+++ b/src/toolkit/themes/shared/popup-css.patch
@@ -1,32 +1,15 @@
diff --git a/toolkit/themes/shared/popup.css b/toolkit/themes/shared/popup.css
-index ed0caa97db5726a7d1bc1cd0aa7af3fdf99690dc..ce49d7f6900a1184c9aed00c26bd7b42916482aa 100644
+index 5701d305fdfc0407ead51aa52eefee38e7429de8..642325e981e9597eaaefefa725852a49b49ee6dc 100644
--- a/toolkit/themes/shared/popup.css
+++ b/toolkit/themes/shared/popup.css
-@@ -21,8 +21,8 @@ panel {
+@@ -22,8 +22,8 @@ panel {
--panel-border-color: ThreeDShadow;
--panel-width: initial;
-- --panel-shadow-margin: 0px;
+- --panel-shadow-margin: 4px;
- --panel-shadow: 0 0 var(--panel-shadow-margin) hsla(0,0%,0%,.2);
+ --panel-shadow-margin: 10px;
+ --panel-shadow: var(--zen-big-shadow);
-moz-window-input-region-margin: var(--panel-shadow-margin);
margin: calc(-1 * var(--panel-shadow-margin));
-@@ -30,8 +30,6 @@ panel {
- --background-color-canvas: var(--panel-background);
-
- @media (-moz-platform: linux) {
-- --panel-border-radius: 8px;
-- --panel-padding-block: 3px;
-
- @media (prefers-contrast) {
- --panel-border-color: color-mix(in srgb, currentColor 60%, transparent);
-@@ -208,7 +206,6 @@ panel:where([type="arrow"]) {
- }
-
- &[animating] {
-- pointer-events: none;
- }
- }
- }
diff --git a/src/widget/windows/WinUtils-cpp.patch b/src/widget/windows/WinUtils-cpp.patch
deleted file mode 100644
index 2d3854274..000000000
--- a/src/widget/windows/WinUtils-cpp.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/widget/windows/WinUtils.cpp b/widget/windows/WinUtils.cpp
-index 598c96cbb5cd06a986a5793ebe9c5438d419d4a9..de1317749e6a6dd7df644818970d7706a51e6c14 100644
---- a/widget/windows/WinUtils.cpp
-+++ b/widget/windows/WinUtils.cpp
-@@ -2007,6 +2007,7 @@ bool WinUtils::GetTimezoneName(wchar_t* aBuffer) {
- static constexpr nsLiteralCString kMicaPrefs[] = {
- "widget.windows.mica"_ns,
- "widget.windows.mica.popups"_ns,
-+ "zen.widget.windows.acrylic"_ns,
- };
-
- static BOOL CALLBACK UpdateMicaInHwnd(HWND aHwnd, LPARAM aLParam) {
diff --git a/src/widget/windows/nsWindow-cpp.patch b/src/widget/windows/nsWindow-cpp.patch
deleted file mode 100644
index 0de755b0a..000000000
--- a/src/widget/windows/nsWindow-cpp.patch
+++ /dev/null
@@ -1,21 +0,0 @@
-diff --git a/widget/windows/nsWindow.cpp b/widget/windows/nsWindow.cpp
-index d2863d5fd9ce5cedc88253a07cb061a660d42e61..5c1097ad16cd6e27e76cc6dfbed85218d36cc36f 100644
---- a/widget/windows/nsWindow.cpp
-+++ b/widget/windows/nsWindow.cpp
-@@ -165,6 +165,7 @@
- #include "mozilla/StaticPrefs_layout.h"
- #include "mozilla/StaticPrefs_ui.h"
- #include "mozilla/StaticPrefs_widget.h"
-+#include "mozilla/StaticPrefs_zen.h"
- #include "nsNativeAppSupportWin.h"
-
- #include "nsIGfxInfo.h"
-@@ -2546,7 +2547,7 @@ void nsWindow::UpdateMicaBackdrop(bool aForce) {
- if (!useBackdrop) {
- return DWMSBT_AUTO;
- }
-- return IsPopup() ? DWMSBT_TRANSIENTWINDOW : DWMSBT_TABBEDWINDOW;
-+ return IsPopup() ? DWMSBT_TRANSIENTWINDOW : (StaticPrefs::zen_widget_windows_acrylic() ? DWMSBT_TRANSIENTWINDOW : DWMSBT_TABBEDWINDOW);
- }();
- ::DwmSetWindowAttribute(mWnd, DWMWA_SYSTEMBACKDROP_TYPE, &backdrop,
- sizeof backdrop);
diff --git a/src/zen/@types/index.d.ts b/src/zen/@types/index.d.ts
new file mode 100644
index 000000000..0510ef7be
--- /dev/null
+++ b/src/zen/@types/index.d.ts
@@ -0,0 +1,36 @@
+/**
+ * NOTE: Do not modify this file by hand.
+ * If you're updating some of the sources, see README for instructions.
+ */
+
+///
+///
+///
+///
+///
+///
+
+/// Platform specific XPCOM modules.
+///
+///
+///
+
+/// Order of references matters here, for overriding type signatures.
+///
+
+declare global {
+ const Cc: nsXPCComponents_Classes;
+ const Ci: nsIXPCComponents_Interfaces;
+ const Components: nsIXPCComponents;
+ const Cr: nsIXPCComponents_Results;
+
+ // Resolve typed generic overloads before the generated ones.
+ const Cu: nsXPCComponents_Utils & nsIXPCComponents_Utils;
+
+ const Services: JSServices;
+ const uneval: (any) => string;
+}
+
+export {};
+
+///
diff --git a/src/zen/@types/lib.gecko.darwin.d.ts b/src/zen/@types/lib.gecko.darwin.d.ts
new file mode 100644
index 000000000..e23e2d318
--- /dev/null
+++ b/src/zen/@types/lib.gecko.darwin.d.ts
@@ -0,0 +1,225 @@
+/**
+ * NOTE: Do not modify this file by hand.
+ * Content was generated from source XPCOM .idl files.
+ * If you're updating some of the sources, see README for instructions.
+ */
+
+declare global {
+ // https://searchfox.org/mozilla-central/source/accessible/interfaces/nsIAccessibleMacInterface.idl
+
+ interface nsIAccessibleMacNSObjectWrapper extends nsISupports {}
+
+ interface nsIAccessibleMacInterface extends nsISupports {
+ readonly attributeNames: string[];
+ readonly parameterizedAttributeNames: string[];
+ readonly actionNames: string[];
+ getAttributeValue(attributeName: string): any;
+ getParameterizedAttributeValue(attributeName: string, parameter: any): any;
+ performAction(actionName: string): void;
+ isAttributeSettable(attributeName: string): boolean;
+ setAttributeValue(attributeName: string, attributeValue: any): void;
+ }
+
+ interface nsIAccessibleMacEvent extends nsISupports {
+ readonly macIface: nsIAccessibleMacInterface;
+ readonly data: any;
+ }
+
+ // https://searchfox.org/mozilla-central/source/browser/components/migration/nsIKeychainMigrationUtils.idl
+
+ interface nsIKeychainMigrationUtils extends nsISupports {
+ getGenericPassword(aServiceName: string, aAccountName: string): string;
+ }
+
+ // https://searchfox.org/mozilla-central/source/browser/components/shell/nsIMacShellService.idl
+
+ interface nsIMacShellService extends nsIShellService {
+ showDesktopPreferences(): void;
+ showSecurityPreferences(aPaneID: string): void;
+ getAvailableApplicationsForProtocol(protocol: string): string[][];
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsIMacDockSupport.idl
+
+ interface nsIAppBundleLaunchOptions extends nsISupports {
+ readonly addsToRecentItems: boolean;
+ }
+
+ interface nsIMacDockSupport extends nsISupports {
+ dockMenu: nsIStandaloneNativeMenu;
+ activateApplication(aIgnoreOtherApplications: boolean): void;
+ badgeText: string;
+ setBadgeImage(aBadgeImage: imgIContainer, aPaintContext?: nsISVGPaintContext): void;
+ readonly isAppInDock: boolean;
+ ensureAppIsPinnedToDock(aAppPath?: string, aAppToReplacePath?: string): boolean;
+ launchAppBundle(aAppBundle: nsIFile, aArgs: string[], aLaunchOptions?: nsIAppBundleLaunchOptions): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsIMacFinderProgress.idl
+
+ type nsIMacFinderProgressCanceledCallback = Callable<{
+ canceled(): void;
+ }>;
+
+ interface nsIMacFinderProgress extends nsISupports {
+ init(path: string, canceledCallback: nsIMacFinderProgressCanceledCallback): void;
+ updateProgress(currentProgress: u64, totalProgress: u64): void;
+ end(): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsIMacSharingService.idl
+
+ interface nsIMacSharingService extends nsISupports {
+ getSharingProviders(pageUrl: string): any;
+ shareUrl(serviceName: string, pageUrl: string, pageTitle: string): void;
+ openSharingPreferences(): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsIMacUserActivityUpdater.idl
+
+ interface nsIMacUserActivityUpdater extends nsISupports {
+ updateLocation(pageUrl: string, pageTitle: string, window: nsIBaseWindow): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsIMacWebAppUtils.idl
+
+ type nsITrashAppCallback = Callable<{
+ trashAppFinished(rv: nsresult): void;
+ }>;
+
+ interface nsIMacWebAppUtils extends nsISupports {
+ pathForAppWithIdentifier(bundleIdentifier: string): string;
+ launchAppWithIdentifier(bundleIdentifier: string): void;
+ trashApp(path: string, callback: nsITrashAppCallback): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsIStandaloneNativeMenu.idl
+
+ interface nsIStandaloneNativeMenu extends nsISupports {
+ init(aElement: Element): void;
+ menuWillOpen(): boolean;
+ activateNativeMenuItemAt(anIndexString: string): void;
+ forceUpdateNativeMenuAt(anIndexString: string): void;
+ dump(): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsITaskbarProgress.idl
+
+ interface nsITaskbarProgress extends nsISupports {
+ readonly STATE_NO_PROGRESS?: 0;
+ readonly STATE_INDETERMINATE?: 1;
+ readonly STATE_NORMAL?: 2;
+ readonly STATE_ERROR?: 3;
+ readonly STATE_PAUSED?: 4;
+
+ setProgressState(state: nsTaskbarProgressState, currentValue?: u64, maxValue?: u64): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsITouchBarHelper.idl
+
+ interface nsITouchBarHelper extends nsISupports {
+ readonly activeUrl: string;
+ readonly activeTitle: string;
+ readonly isUrlbarFocused: boolean;
+ toggleFocusUrlbar(): void;
+ unfocusUrlbar(): void;
+ allItems: nsIArray;
+ readonly document: Document;
+ getTouchBarInput(aInputName: string): nsITouchBarInput;
+ insertRestrictionInUrlbar(aToken: string): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsITouchBarInput.idl
+
+ type nsITouchBarInputCallback = Callable<{
+ onCommand(): void;
+ }>;
+
+ interface nsITouchBarInput extends nsISupports {
+ readonly key: string;
+ title: string;
+ image: nsIURI;
+ type: string;
+ callback: nsITouchBarInputCallback;
+ color: u32;
+ disabled: boolean;
+ children: nsIArray;
+ }
+
+ // https://searchfox.org/mozilla-central/source/widget/nsITouchBarUpdater.idl
+
+ interface nsITouchBarUpdater extends nsISupports {
+ updateTouchBarInputs(aWindow: nsIBaseWindow, aInputs: nsITouchBarInput[]): void;
+ enterCustomizeMode(): void;
+ isTouchBarInitialized(): boolean;
+ setTouchBarInitialized(aIsInitialized: boolean): void;
+ showPopover(aWindow: nsIBaseWindow, aPopover: nsITouchBarInput, aShowing: boolean): void;
+ }
+
+ // https://searchfox.org/mozilla-central/source/xpcom/base/nsIMacPreferencesReader.idl
+
+ interface nsIMacPreferencesReader extends nsISupports {
+ policiesEnabled(): boolean;
+ readPreferences(): any;
+ }
+
+ // https://searchfox.org/mozilla-central/source/xpcom/io/nsILocalFileMac.idl
+
+ interface nsILocalFileMac extends nsIFile {
+ readonly fileSizeWithResFork: i64;
+ launchWithDoc(aDocToLoad: nsIFile, aLaunchInBackground: boolean): void;
+ openDocWithApp(aAppToOpenWith: nsIFile, aLaunchInBackground: boolean): void;
+ isPackage(): boolean;
+ readonly bundleDisplayName: string;
+ readonly bundleIdentifier: string;
+ readonly bundleContentsLastModifiedTime: i64;
+ hasXAttr(aAttrName: string): boolean;
+ getXAttr(aAttrName: string): u8[];
+ setXAttr(aAttrName: string, aAttrValue: u8[]): void;
+ delXAttr(aAttrName: string): void;
+ }
+
+ interface nsIXPCComponents_Interfaces {
+ nsIAccessibleMacNSObjectWrapper: nsJSIID
;
+ nsIAccessibleMacInterface: nsJSIID;
+ nsIAccessibleMacEvent: nsJSIID;
+ nsIKeychainMigrationUtils: nsJSIID;
+ nsIMacShellService: nsJSIID;
+ nsIAppBundleLaunchOptions: nsJSIID;
+ nsIMacDockSupport: nsJSIID;
+ nsIMacFinderProgressCanceledCallback: nsJSIID;
+ nsIMacFinderProgress: nsJSIID;
+ nsIMacSharingService: nsJSIID;
+ nsIMacUserActivityUpdater: nsJSIID;
+ nsITrashAppCallback: nsJSIID;
+ nsIMacWebAppUtils: nsJSIID;
+ nsIStandaloneNativeMenu: nsJSIID;
+ nsITaskbarProgress: nsJSIID;
+ nsITouchBarHelper: nsJSIID;
+ nsITouchBarInputCallback: nsJSIID;
+ nsITouchBarInput: nsJSIID;
+ nsITouchBarUpdater: nsJSIID;
+ nsIMacPreferencesReader: nsJSIID;
+ nsILocalFileMac: nsJSIID;
+ }
+} // global
+
+// Typedefs from xpidl.
+type PRTime = i64;
+type nsTaskbarProgressState = i32;
+
+// XPCOM internal utility types.
+
+/** XPCOM inout param is passed in as a js object with a value property. */
+type InOutParam = { value: T };
+
+/** XPCOM out param is written to the passed in object's value property. */
+type OutParam = { value?: T };
+
+/** Enable interfaces to inherit from enums: pick variants as optional. */
+type Enums = Partial>;
+
+/** Callable accepts either form of a [function] interface. */
+type Callable = iface | Extract;
+
+export {};
diff --git a/src/zen/@types/lib.gecko.dom.d.ts b/src/zen/@types/lib.gecko.dom.d.ts
new file mode 100644
index 000000000..58614b00a
--- /dev/null
+++ b/src/zen/@types/lib.gecko.dom.d.ts
@@ -0,0 +1,32649 @@
+/**
+ * NOTE: Do not modify this file by hand.
+ * Content was generated from source .webidl files.
+ * If you're updating some of the sources, see README for instructions.
+ */
+
+///
+///
+
+type HTMLCollectionOf = any;
+type IsInstance = (obj: any) => obj is T;
+type NodeListOf = any;
+interface WindowProxy extends Window {}
+
+/////////////////////////////
+/// Window APIs
+/////////////////////////////
+
+interface ActivateMenuItemOptions {
+ altKey?: boolean;
+ button?: number;
+ ctrlKey?: boolean;
+ metaKey?: boolean;
+ shiftKey?: boolean;
+}
+
+interface AddEventListenerOptions extends EventListenerOptions {
+ once?: boolean;
+ passive?: boolean;
+ signal?: AbortSignal;
+ wantUntrusted?: boolean;
+}
+
+interface AddonEventInit extends EventInit {
+ id: string;
+}
+
+interface AddressErrors {
+ addressLine?: string;
+ city?: string;
+ country?: string;
+ dependentLocality?: string;
+ organization?: string;
+ phone?: string;
+ postalCode?: string;
+ recipient?: string;
+ region?: string;
+ regionCode?: string;
+ sortingCode?: string;
+}
+
+interface AnalyserOptions extends AudioNodeOptions {
+ fftSize?: number;
+ maxDecibels?: number;
+ minDecibels?: number;
+ smoothingTimeConstant?: number;
+}
+
+interface AnimationEventInit extends EventInit {
+ animationName?: string;
+ elapsedTime?: number;
+ pseudoElement?: string;
+}
+
+interface AnimationPlaybackEventInit extends EventInit {
+ currentTime?: number | null;
+ timelineTime?: number | null;
+}
+
+interface AnimationPropertyDetails {
+ property: string;
+ runningOnCompositor: boolean;
+ values: AnimationPropertyValueDetails[];
+ warning?: string;
+}
+
+interface AnimationPropertyValueDetails {
+ composite: CompositeOperation;
+ easing?: string;
+ offset: number;
+ value?: string;
+}
+
+interface AssignedNodesOptions {
+ flatten?: boolean;
+}
+
+interface AttributeNameValue {
+ name: string;
+ value: string;
+}
+
+interface AudioBufferOptions {
+ length: number;
+ numberOfChannels?: number;
+ sampleRate: number;
+}
+
+interface AudioBufferSourceOptions {
+ buffer?: AudioBuffer | null;
+ detune?: number;
+ loop?: boolean;
+ loopEnd?: number;
+ loopStart?: number;
+ playbackRate?: number;
+}
+
+interface AudioConfiguration {
+ bitrate?: number;
+ channels?: string;
+ contentType: string;
+ samplerate?: number;
+}
+
+interface AudioContextOptions {
+ sampleRate?: number;
+}
+
+interface AudioDataCopyToOptions {
+ format?: AudioSampleFormat;
+ frameCount?: number;
+ frameOffset?: number;
+ planeIndex: number;
+}
+
+interface AudioDataInit {
+ data: ArrayBufferView | ArrayBuffer;
+ format: AudioSampleFormat;
+ numberOfChannels: number;
+ numberOfFrames: number;
+ sampleRate: number;
+ timestamp: number;
+ transfer?: ArrayBuffer[];
+}
+
+interface AudioDecoderConfig {
+ codec: string;
+ description?: ArrayBufferView | ArrayBuffer;
+ numberOfChannels: number;
+ sampleRate: number;
+}
+
+interface AudioDecoderInit {
+ error: WebCodecsErrorCallback;
+ output: AudioDataOutputCallback;
+}
+
+interface AudioDecoderSupport {
+ config?: AudioDecoderConfig;
+ supported?: boolean;
+}
+
+interface AudioEncoderConfig {
+ bitrate?: number;
+ bitrateMode?: BitrateMode;
+ codec: string;
+ numberOfChannels?: number;
+ opus?: OpusEncoderConfig;
+ sampleRate?: number;
+}
+
+interface AudioEncoderInit {
+ error: WebCodecsErrorCallback;
+ output: EncodedAudioChunkOutputCallback;
+}
+
+interface AudioEncoderSupport {
+ config?: AudioEncoderConfig;
+ supported?: boolean;
+}
+
+interface AudioNodeOptions {
+ channelCount?: number;
+ channelCountMode?: ChannelCountMode;
+ channelInterpretation?: ChannelInterpretation;
+}
+
+interface AudioOutputOptions {
+ deviceId?: string;
+}
+
+interface AudioSinkDebugInfo {
+ audioEnded?: boolean;
+ hasErrored?: boolean;
+ isPlaying?: boolean;
+ isStarted?: boolean;
+ lastGoodPosition?: number;
+ outputRate?: number;
+ playbackComplete?: boolean;
+ startTime?: number;
+ written?: number;
+}
+
+interface AudioSinkWrapperDebugInfo {
+ audioEnded?: boolean;
+ audioSink?: AudioSinkDebugInfo;
+ isPlaying?: boolean;
+ isStarted?: boolean;
+}
+
+interface AudioTimestamp {
+ contextTime?: number;
+ performanceTime?: DOMHighResTimeStamp;
+}
+
+interface AudioWorkletNodeOptions extends AudioNodeOptions {
+ numberOfInputs?: number;
+ numberOfOutputs?: number;
+ outputChannelCount?: number[];
+ parameterData?: Record;
+ processorOptions?: any;
+}
+
+interface AuthenticationExtensionsClientInputs {
+ appid?: string;
+ credProps?: boolean;
+ hmacCreateSecret?: boolean;
+ minPinLength?: boolean;
+ prf?: AuthenticationExtensionsPRFInputs;
+}
+
+interface AuthenticationExtensionsClientInputsJSON {
+ appid?: string;
+ credProps?: boolean;
+ hmacCreateSecret?: boolean;
+ minPinLength?: boolean;
+ prf?: AuthenticationExtensionsPRFInputsJSON;
+}
+
+interface AuthenticationExtensionsClientOutputs {
+ appid?: boolean;
+ credProps?: CredentialPropertiesOutput;
+ hmacCreateSecret?: boolean;
+ prf?: AuthenticationExtensionsPRFOutputs;
+}
+
+interface AuthenticationExtensionsPRFInputs {
+ eval?: AuthenticationExtensionsPRFValues;
+ evalByCredential?: Record;
+}
+
+interface AuthenticationExtensionsPRFInputsJSON {
+ eval?: AuthenticationExtensionsPRFValuesJSON;
+ evalByCredential?: Record;
+}
+
+interface AuthenticationExtensionsPRFOutputs {
+ enabled?: boolean;
+ results?: AuthenticationExtensionsPRFValues;
+}
+
+interface AuthenticationExtensionsPRFValues {
+ first: BufferSource;
+ second?: BufferSource;
+}
+
+interface AuthenticationExtensionsPRFValuesJSON {
+ first: Base64URLString;
+ second?: Base64URLString;
+}
+
+interface AuthenticatorSelectionCriteria {
+ authenticatorAttachment?: string;
+ requireResidentKey?: boolean;
+ residentKey?: string;
+ userVerification?: string;
+}
+
+interface AutocompleteInfo {
+ addressType?: string;
+ canAutomaticallyPersist?: boolean;
+ contactType?: string;
+ credentialType?: string;
+ fieldName?: string;
+ section?: string;
+}
+
+interface AvcEncoderConfig {
+ format?: AvcBitstreamFormat;
+}
+
+interface Base64URLDecodeOptions {
+ padding: Base64URLDecodePadding;
+}
+
+interface Base64URLEncodeOptions {
+ pad: boolean;
+}
+
+interface BiquadFilterOptions extends AudioNodeOptions {
+ Q?: number;
+ detune?: number;
+ frequency?: number;
+ gain?: number;
+ type?: BiquadFilterType;
+}
+
+interface BlobEventInit extends EventInit {
+ data: Blob;
+}
+
+interface BlobPropertyBag {
+ endings?: EndingType;
+ type?: string;
+}
+
+interface BlockParsingOptions {
+ blockScriptCreated?: boolean;
+}
+
+interface BoxQuadOptions extends GeometryUtilsOptions {
+ box?: CSSBoxType;
+ ignoreTransforms?: boolean;
+ relativeTo?: GeometryNode;
+}
+
+interface BufferRange {
+ end?: number;
+ start?: number;
+}
+
+interface CDMInformation {
+ capabilities: string;
+ clearlead: boolean;
+ isHDCP22Compatible: boolean;
+ isHardwareDecryption: boolean;
+ keySystemName: string;
+}
+
+interface CSSCustomPropertyRegisteredEventInit extends EventInit {
+ propertyDefinition: InspectorCSSPropertyDefinition;
+}
+
+interface CSSStyleSheetInit {
+ baseURL?: string;
+ disabled?: boolean;
+ media?: MediaList | string;
+}
+
+interface CacheQueryOptions {
+ ignoreMethod?: boolean;
+ ignoreSearch?: boolean;
+ ignoreVary?: boolean;
+}
+
+interface CanvasRenderingContext2DDebugInfo {
+ backendType: number;
+ drawTargetType: number;
+ isAccelerated: boolean;
+ isShared: boolean;
+}
+
+interface CanvasRenderingContext2DSettings {
+ alpha?: boolean;
+ colorSpace?: PredefinedColorSpace;
+ desynchronized?: boolean;
+ forceSoftwareRendering?: boolean;
+ willReadFrequently?: boolean;
+}
+
+interface CaretPositionFromPointOptions {
+ shadowRoots?: ShadowRoot[];
+}
+
+interface CaretStateChangedEventInit extends EventInit {
+ boundingClientRect?: DOMRectReadOnly | null;
+ caretVisible?: boolean;
+ caretVisuallyVisible?: boolean;
+ clientX?: number;
+ clientY?: number;
+ collapsed?: boolean;
+ reason?: CaretChangedReason;
+ selectedTextContent?: string;
+ selectionEditable?: boolean;
+ selectionVisible?: boolean;
+}
+
+interface ChannelMergerOptions extends AudioNodeOptions {
+ numberOfInputs?: number;
+}
+
+interface ChannelSplitterOptions extends AudioNodeOptions {
+ numberOfOutputs?: number;
+}
+
+interface CheckVisibilityOptions {
+ checkOpacity?: boolean;
+ checkVisibilityCSS?: boolean;
+ contentVisibilityAuto?: boolean;
+ flush?: boolean;
+ opacityProperty?: boolean;
+ visibilityProperty?: boolean;
+}
+
+interface CheckerboardReport {
+ log?: string;
+ reason?: CheckerboardReason;
+ severity?: number;
+ timestamp?: DOMTimeStamp;
+}
+
+interface ChildProcInfoDictionary {
+ childID?: number;
+ cpuCycleCount?: number;
+ cpuTime?: number;
+ memory?: number;
+ origin?: string;
+ pid?: number;
+ threads?: ThreadInfoDictionary[];
+ type?: WebIDLProcType;
+ utilityActors?: UtilityActorsDictionary[];
+ windows?: WindowInfoDictionary[];
+}
+
+interface ChromeFilePropertyBag extends FilePropertyBag {
+ existenceCheck?: boolean;
+ name?: string;
+}
+
+interface ClearResourceCacheOptions {
+ pattern?: OriginAttributesPatternDictionary;
+ principal?: Principal;
+ schemelessSite?: string;
+ target?: ResourceCacheTarget;
+ types?: ResourceCacheType[];
+ url?: string;
+}
+
+interface ClientRectsAndTexts {
+ rectList: DOMRectList;
+ textList: string[];
+}
+
+interface ClipboardEventInit extends EventInit {
+ data?: string;
+ dataType?: string;
+}
+
+interface ClipboardItemOptions {
+ presentationStyle?: PresentationStyle;
+}
+
+interface CloseEventInit extends EventInit {
+ code?: number;
+ reason?: string;
+ wasClean?: boolean;
+}
+
+interface CloseWatcherOptions {
+ signal?: AbortSignal;
+}
+
+interface CollectedData {
+ children?: any[];
+ id?: Record;
+ innerHTML?: string;
+ scroll?: string;
+ url?: string;
+ xpath?: Record;
+}
+
+interface CompileScriptOptionsDictionary {
+ charset?: string;
+ filename?: string;
+ hasReturnValue?: boolean;
+ lazilyParse?: boolean;
+}
+
+interface CompositionEventInit extends UIEventInit {
+ data?: string;
+}
+
+interface ComputedEffectTiming extends EffectTiming {
+ activeDuration?: number;
+ currentIteration?: number | null;
+ endTime?: number;
+ localTime?: number | null;
+ progress?: number | null;
+}
+
+interface ConsoleInstanceOptions {
+ consoleID?: string;
+ dump?: ConsoleInstanceDumpCallback;
+ innerID?: string;
+ maxLogLevel?: ConsoleLogLevel;
+ maxLogLevelPref?: string;
+ prefix?: string;
+}
+
+interface ConstantSourceOptions {
+ offset?: number;
+}
+
+interface ConstrainBooleanParameters {
+ exact?: boolean;
+ ideal?: boolean;
+}
+
+interface ConstrainDOMStringParameters {
+ exact?: string | string[];
+ ideal?: string | string[];
+}
+
+interface ConstrainDoubleRange {
+ exact?: number;
+ ideal?: number;
+ max?: number;
+ min?: number;
+}
+
+interface ConstrainLongRange {
+ exact?: number;
+ ideal?: number;
+ max?: number;
+ min?: number;
+}
+
+interface ContentVisibilityAutoStateChangeEventInit extends EventInit {
+ skipped?: boolean;
+}
+
+interface ConvertCoordinateOptions extends GeometryUtilsOptions {
+ fromBox?: CSSBoxType;
+ toBox?: CSSBoxType;
+}
+
+interface ConvolverOptions extends AudioNodeOptions {
+ buffer?: AudioBuffer | null;
+ disableNormalization?: boolean;
+}
+
+interface CookieChangeEventInit extends EventInit {
+ changed?: CookieList;
+ deleted?: CookieList;
+}
+
+interface CookieInit {
+ domain?: string | null;
+ expires?: DOMHighResTimeStamp | null;
+ name: string;
+ partitioned?: boolean;
+ path?: string;
+ sameSite?: CookieSameSite;
+ value: string;
+}
+
+interface CookieListItem {
+ name?: string;
+ value?: string;
+}
+
+interface CookieStoreDeleteOptions {
+ domain?: string | null;
+ name: string;
+ partitioned?: boolean;
+ path?: string;
+}
+
+interface CookieStoreGetOptions {
+ name?: string;
+ url?: string;
+}
+
+interface CopyOptions {
+ noOverwrite?: boolean;
+ recursive?: boolean;
+}
+
+interface CredentialCreationOptions {
+ identity?: IdentityCredentialInit;
+ publicKey?: PublicKeyCredentialCreationOptions;
+ signal?: AbortSignal;
+}
+
+interface CredentialPropertiesOutput {
+ rk?: boolean;
+}
+
+interface CredentialRequestOptions {
+ identity?: IdentityCredentialRequestOptions;
+ mediation?: CredentialMediationRequirement;
+ publicKey?: PublicKeyCredentialRequestOptions;
+ signal?: AbortSignal;
+}
+
+interface CustomEventInit extends EventInit {
+ detail?: any;
+}
+
+interface DOMMatrix2DInit {
+ a?: number;
+ b?: number;
+ c?: number;
+ d?: number;
+ e?: number;
+ f?: number;
+ m11?: number;
+ m12?: number;
+ m21?: number;
+ m22?: number;
+ m41?: number;
+ m42?: number;
+}
+
+interface DOMMatrixInit extends DOMMatrix2DInit {
+ is2D?: boolean;
+ m13?: number;
+ m14?: number;
+ m23?: number;
+ m24?: number;
+ m31?: number;
+ m32?: number;
+ m33?: number;
+ m34?: number;
+ m43?: number;
+ m44?: number;
+}
+
+interface DOMPointInit {
+ w?: number;
+ x?: number;
+ y?: number;
+ z?: number;
+}
+
+interface DOMQuadInit {
+ p1?: DOMPointInit;
+ p2?: DOMPointInit;
+ p3?: DOMPointInit;
+ p4?: DOMPointInit;
+}
+
+interface DOMRectInit {
+ height?: number;
+ width?: number;
+ x?: number;
+ y?: number;
+}
+
+interface DateTimeValue {
+ day?: number;
+ hour?: number;
+ minute?: number;
+ month?: number;
+ year?: number;
+}
+
+interface DecodedStreamDataDebugInfo {
+ audioFramesWritten?: number;
+ haveSentFinishAudio?: boolean;
+ haveSentFinishVideo?: boolean;
+ instance?: string;
+ lastVideoEndTime?: number;
+ lastVideoStartTime?: number;
+ nextAudioTime?: number;
+ streamAudioWritten?: number;
+ streamVideoWritten?: number;
+}
+
+interface DecodedStreamDebugInfo {
+ audioQueueFinished?: boolean;
+ audioQueueSize?: number;
+ data?: DecodedStreamDataDebugInfo;
+ instance?: string;
+ lastAudio?: number;
+ lastOutputTime?: number;
+ playing?: number;
+ startTime?: number;
+}
+
+interface DelayOptions extends AudioNodeOptions {
+ delayTime?: number;
+ maxDelayTime?: number;
+}
+
+interface DeviceAccelerationInit {
+ x?: number | null;
+ y?: number | null;
+ z?: number | null;
+}
+
+interface DeviceLightEventInit extends EventInit {
+ value?: number;
+}
+
+interface DeviceMotionEventInit extends EventInit {
+ acceleration?: DeviceAccelerationInit;
+ accelerationIncludingGravity?: DeviceAccelerationInit;
+ interval?: number | null;
+ rotationRate?: DeviceRotationRateInit;
+}
+
+interface DeviceOrientationEventInit extends EventInit {
+ absolute?: boolean;
+ alpha?: number | null;
+ beta?: number | null;
+ gamma?: number | null;
+}
+
+interface DeviceRotationRateInit {
+ alpha?: number | null;
+ beta?: number | null;
+ gamma?: number | null;
+}
+
+interface DictWithAllowSharedBufferSource {
+ allowSharedArrayBuffer?: ArrayBuffer;
+ allowSharedArrayBufferView?: ArrayBufferView;
+ arrayBuffer?: ArrayBuffer;
+ arrayBufferView?: ArrayBufferView;
+}
+
+interface DisplayMediaStreamConstraints {
+ audio?: boolean | MediaTrackConstraints;
+ video?: boolean | MediaTrackConstraints;
+}
+
+interface DisplayNameOptions {
+ calendar?: string;
+ keys?: string[];
+ style?: string;
+ type?: string;
+}
+
+interface DisplayNameResult {
+ calendar?: string;
+ locale?: string;
+ style?: string;
+ type?: string;
+ values?: string[];
+}
+
+interface DocumentTimelineOptions {
+ originTime?: DOMHighResTimeStamp;
+}
+
+interface DoubleRange {
+ max?: number;
+ min?: number;
+}
+
+interface DragEventInit extends MouseEventInit {
+ dataTransfer?: DataTransfer | null;
+}
+
+interface DynamicsCompressorOptions extends AudioNodeOptions {
+ attack?: number;
+ knee?: number;
+ ratio?: number;
+ release?: number;
+ threshold?: number;
+}
+
+interface EMEDebugInfo {
+ keySystem?: string;
+ sessionsInfo?: string;
+}
+
+interface EffectTiming {
+ delay?: number;
+ direction?: PlaybackDirection;
+ duration?: number | string;
+ easing?: string;
+ endDelay?: number;
+ fill?: FillMode;
+ iterationStart?: number;
+ iterations?: number;
+}
+
+interface ElementCreationOptions {
+ is?: string;
+ pseudo?: string;
+}
+
+interface ElementDefinitionOptions {
+ extends?: string;
+}
+
+interface EncodedAudioChunkInit {
+ data: ArrayBufferView | ArrayBuffer;
+ duration?: number;
+ timestamp: number;
+ transfer?: ArrayBuffer[];
+ type: EncodedAudioChunkType;
+}
+
+interface EncodedAudioChunkMetadata {
+ decoderConfig?: AudioDecoderConfig;
+}
+
+interface EncodedVideoChunkInit {
+ data: ArrayBufferView | ArrayBuffer;
+ duration?: number;
+ timestamp: number;
+ type: EncodedVideoChunkType;
+}
+
+interface EncodedVideoChunkMetadata {
+ decoderConfig?: VideoDecoderConfig;
+ svc?: SvcOutputMetadata;
+}
+
+interface ErrorEventInit extends EventInit {
+ colno?: number;
+ error?: any;
+ filename?: string;
+ lineno?: number;
+ message?: string;
+}
+
+interface EventInit {
+ bubbles?: boolean;
+ cancelable?: boolean;
+ composed?: boolean;
+}
+
+interface EventListenerOptions {
+ capture?: boolean;
+ mozSystemGroup?: boolean;
+}
+
+interface EventModifierInit extends UIEventInit {
+ altKey?: boolean;
+ ctrlKey?: boolean;
+ metaKey?: boolean;
+ modifierAltGraph?: boolean;
+ modifierCapsLock?: boolean;
+ modifierFn?: boolean;
+ modifierFnLock?: boolean;
+ modifierNumLock?: boolean;
+ modifierOS?: boolean;
+ modifierScrollLock?: boolean;
+ modifierSymbol?: boolean;
+ modifierSymbolLock?: boolean;
+ shiftKey?: boolean;
+}
+
+interface EventSourceInit {
+ withCredentials?: boolean;
+}
+
+interface ExecuteInGlobalOptions {
+ reportExceptions?: boolean;
+}
+
+interface FailedCertSecurityInfo {
+ certChainStrings?: string[];
+ certValidityRangeNotAfter?: DOMTimeStamp;
+ certValidityRangeNotBefore?: DOMTimeStamp;
+ channelStatus?: number;
+ errorCodeString?: string;
+ errorIsOverridable?: boolean;
+ errorMessage?: string;
+ hasHPKP?: boolean;
+ hasHSTS?: boolean;
+ issuerCommonName?: string;
+ overridableErrorCategory?: OverridableErrorCategory;
+ validNotAfter?: DOMTimeStamp;
+ validNotBefore?: DOMTimeStamp;
+}
+
+interface FileInfo {
+ creationTime?: number;
+ lastAccessed?: number;
+ lastModified?: number;
+ path?: string;
+ permissions?: number;
+ size?: number;
+ type?: FileType;
+}
+
+interface FilePropertyBag extends BlobPropertyBag {
+ lastModified?: number;
+}
+
+interface FileSourceOptions {
+ addResourceOptions?: FluentBundleAddResourceOptions;
+}
+
+interface FileSystemCreateWritableOptions {
+ keepExistingData?: boolean;
+}
+
+interface FileSystemFlags {
+ create?: boolean;
+ exclusive?: boolean;
+}
+
+interface FileSystemGetDirectoryOptions {
+ create?: boolean;
+}
+
+interface FileSystemGetFileOptions {
+ create?: boolean;
+}
+
+interface FileSystemRemoveOptions {
+ recursive?: boolean;
+}
+
+interface FluentBundleAddResourceOptions {
+ allowOverrides?: boolean;
+}
+
+interface FluentBundleIteratorResult {
+ done: boolean;
+ value: FluentBundle | null;
+}
+
+interface FluentBundleOptions {
+ pseudoStrategy?: string;
+ useIsolating?: boolean;
+}
+
+interface FluentMessage {
+ attributes: Record;
+ value?: FluentPattern | null;
+}
+
+interface FluentTextElementItem {
+ attr?: string;
+ id?: string;
+ text?: string;
+}
+
+interface FocusEventInit extends UIEventInit {
+ relatedTarget?: EventTarget | null;
+}
+
+interface FocusOptions {
+ focusVisible?: boolean;
+ preventScroll?: boolean;
+}
+
+interface FontFaceDescriptors {
+ ascentOverride?: string;
+ descentOverride?: string;
+ display?: string;
+ featureSettings?: string;
+ lineGapOverride?: string;
+ sizeAdjust?: string;
+ stretch?: string;
+ style?: string;
+ unicodeRange?: string;
+ variant?: string;
+ variationSettings?: string;
+ weight?: string;
+}
+
+interface FontFaceSetIteratorResult {
+ done: boolean;
+ value: any;
+}
+
+interface FontFaceSetLoadEventInit extends EventInit {
+ fontfaces?: FontFace[];
+}
+
+interface FormAutofillConfidences {
+ ccName?: number;
+ ccNumber?: number;
+}
+
+interface FormDataEventInit extends EventInit {
+ formData: FormData;
+}
+
+interface FrameCrashedEventInit extends EventInit {
+ browsingContextId?: number;
+ childID?: number;
+ isTopFrame?: boolean;
+}
+
+interface GPUBindGroupDescriptor extends GPUObjectDescriptorBase {
+ entries: GPUBindGroupEntry[];
+ layout: GPUBindGroupLayout;
+}
+
+interface GPUBindGroupEntry {
+ binding: GPUIndex32;
+ resource: GPUBindingResource;
+}
+
+interface GPUBindGroupLayoutDescriptor extends GPUObjectDescriptorBase {
+ entries: GPUBindGroupLayoutEntry[];
+}
+
+interface GPUBindGroupLayoutEntry {
+ binding: GPUIndex32;
+ buffer?: GPUBufferBindingLayout;
+ sampler?: GPUSamplerBindingLayout;
+ storageTexture?: GPUStorageTextureBindingLayout;
+ texture?: GPUTextureBindingLayout;
+ visibility: GPUShaderStageFlags;
+}
+
+interface GPUBlendComponent {
+ dstFactor?: GPUBlendFactor;
+ operation?: GPUBlendOperation;
+ srcFactor?: GPUBlendFactor;
+}
+
+interface GPUBlendState {
+ alpha: GPUBlendComponent;
+ color: GPUBlendComponent;
+}
+
+interface GPUBufferBinding {
+ buffer: GPUBuffer;
+ offset?: GPUSize64;
+ size?: GPUSize64;
+}
+
+interface GPUBufferBindingLayout {
+ hasDynamicOffset?: boolean;
+ minBindingSize?: GPUSize64;
+ type?: GPUBufferBindingType;
+}
+
+interface GPUBufferDescriptor extends GPUObjectDescriptorBase {
+ mappedAtCreation?: boolean;
+ size: GPUSize64;
+ usage: GPUBufferUsageFlags;
+}
+
+interface GPUCanvasConfiguration {
+ alphaMode?: GPUCanvasAlphaMode;
+ device: GPUDevice;
+ format: GPUTextureFormat;
+ usage?: GPUTextureUsageFlags;
+ viewFormats?: GPUTextureFormat[];
+}
+
+interface GPUColorDict {
+ a: number;
+ b: number;
+ g: number;
+ r: number;
+}
+
+interface GPUColorTargetState {
+ blend?: GPUBlendState;
+ format: GPUTextureFormat;
+ writeMask?: GPUColorWriteFlags;
+}
+
+interface GPUCommandBufferDescriptor extends GPUObjectDescriptorBase {}
+
+interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase {}
+
+interface GPUComputePassDescriptor extends GPUObjectDescriptorBase {
+ timestampWrites?: GPUComputePassTimestampWrites;
+}
+
+interface GPUComputePassTimestampWrites {
+ beginningOfPassWriteIndex?: GPUSize32;
+ endOfPassWriteIndex?: GPUSize32;
+ querySet: GPUQuerySet;
+}
+
+interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase {
+ compute: GPUProgrammableStage;
+}
+
+interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo {
+ premultipliedAlpha?: boolean;
+}
+
+interface GPUCopyExternalImageSourceInfo {
+ flipY?: boolean;
+ origin?: GPUOrigin2D;
+ source: GPUCopyExternalImageSource;
+}
+
+interface GPUDepthStencilState {
+ depthBias?: GPUDepthBias;
+ depthBiasClamp?: number;
+ depthBiasSlopeScale?: number;
+ depthCompare?: GPUCompareFunction;
+ depthWriteEnabled?: boolean;
+ format: GPUTextureFormat;
+ stencilBack?: GPUStencilFaceState;
+ stencilFront?: GPUStencilFaceState;
+ stencilReadMask?: GPUStencilValue;
+ stencilWriteMask?: GPUStencilValue;
+}
+
+interface GPUDeviceDescriptor extends GPUObjectDescriptorBase {
+ defaultQueue?: GPUQueueDescriptor;
+ requiredFeatures?: GPUFeatureName[];
+ requiredLimits?: Record;
+}
+
+interface GPUExtent3DDict {
+ depthOrArrayLayers?: GPUIntegerCoordinate;
+ height?: GPUIntegerCoordinate;
+ width: GPUIntegerCoordinate;
+}
+
+interface GPUFragmentState extends GPUProgrammableStage {
+ targets: GPUColorTargetState[];
+}
+
+interface GPUMultisampleState {
+ alphaToCoverageEnabled?: boolean;
+ count?: GPUSize32;
+ mask?: GPUSampleMask;
+}
+
+interface GPUObjectDescriptorBase {
+ label?: string;
+}
+
+interface GPUOrigin2DDict {
+ x?: GPUIntegerCoordinate;
+ y?: GPUIntegerCoordinate;
+}
+
+interface GPUOrigin3DDict {
+ x?: GPUIntegerCoordinate;
+ y?: GPUIntegerCoordinate;
+ z?: GPUIntegerCoordinate;
+}
+
+interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase {
+ layout: GPUPipelineLayout | GPUAutoLayoutMode;
+}
+
+interface GPUPipelineLayoutDescriptor extends GPUObjectDescriptorBase {
+ bindGroupLayouts: GPUBindGroupLayout[];
+}
+
+interface GPUPrimitiveState {
+ cullMode?: GPUCullMode;
+ frontFace?: GPUFrontFace;
+ stripIndexFormat?: GPUIndexFormat;
+ topology?: GPUPrimitiveTopology;
+ unclippedDepth?: boolean;
+}
+
+interface GPUProgrammableStage {
+ constants?: Record;
+ entryPoint?: string;
+ module: GPUShaderModule;
+}
+
+interface GPUQuerySetDescriptor extends GPUObjectDescriptorBase {
+ count: GPUSize32;
+ type: GPUQueryType;
+}
+
+interface GPUQueueDescriptor extends GPUObjectDescriptorBase {}
+
+interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase {}
+
+interface GPURenderBundleEncoderDescriptor extends GPURenderPassLayout {
+ depthReadOnly?: boolean;
+ stencilReadOnly?: boolean;
+}
+
+interface GPURenderPassColorAttachment {
+ clearValue?: GPUColor;
+ loadOp: GPULoadOp;
+ resolveTarget?: GPUTextureView;
+ storeOp: GPUStoreOp;
+ view: GPUTextureView;
+}
+
+interface GPURenderPassDepthStencilAttachment {
+ depthClearValue?: number;
+ depthLoadOp?: GPULoadOp;
+ depthReadOnly?: boolean;
+ depthStoreOp?: GPUStoreOp;
+ stencilClearValue?: GPUStencilValue;
+ stencilLoadOp?: GPULoadOp;
+ stencilReadOnly?: boolean;
+ stencilStoreOp?: GPUStoreOp;
+ view: GPUTextureView;
+}
+
+interface GPURenderPassDescriptor extends GPUObjectDescriptorBase {
+ colorAttachments: GPURenderPassColorAttachment[];
+ depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
+ occlusionQuerySet?: GPUQuerySet;
+ timestampWrites?: GPURenderPassTimestampWrites;
+}
+
+interface GPURenderPassLayout extends GPUObjectDescriptorBase {
+ colorFormats: GPUTextureFormat[];
+ depthStencilFormat?: GPUTextureFormat;
+ sampleCount?: GPUSize32;
+}
+
+interface GPURenderPassTimestampWrites {
+ beginningOfPassWriteIndex?: GPUSize32;
+ endOfPassWriteIndex?: GPUSize32;
+ querySet: GPUQuerySet;
+}
+
+interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase {
+ depthStencil?: GPUDepthStencilState;
+ fragment?: GPUFragmentState;
+ multisample?: GPUMultisampleState;
+ primitive?: GPUPrimitiveState;
+ vertex: GPUVertexState;
+}
+
+interface GPURequestAdapterOptions {
+ forceFallbackAdapter?: boolean;
+ powerPreference?: GPUPowerPreference;
+}
+
+interface GPUSamplerBindingLayout {
+ type?: GPUSamplerBindingType;
+}
+
+interface GPUSamplerDescriptor extends GPUObjectDescriptorBase {
+ addressModeU?: GPUAddressMode;
+ addressModeV?: GPUAddressMode;
+ addressModeW?: GPUAddressMode;
+ compare?: GPUCompareFunction;
+ lodMaxClamp?: number;
+ lodMinClamp?: number;
+ magFilter?: GPUFilterMode;
+ maxAnisotropy?: number;
+ minFilter?: GPUFilterMode;
+ mipmapFilter?: GPUMipmapFilterMode;
+}
+
+interface GPUShaderModuleCompilationHint {
+ entryPoint: string;
+ layout?: GPUPipelineLayout | GPUAutoLayoutMode;
+}
+
+interface GPUShaderModuleDescriptor extends GPUObjectDescriptorBase {
+ code: string;
+ compilationHints?: GPUShaderModuleCompilationHint[];
+}
+
+interface GPUStencilFaceState {
+ compare?: GPUCompareFunction;
+ depthFailOp?: GPUStencilOperation;
+ failOp?: GPUStencilOperation;
+ passOp?: GPUStencilOperation;
+}
+
+interface GPUStorageTextureBindingLayout {
+ access?: GPUStorageTextureAccess;
+ format: GPUTextureFormat;
+ viewDimension?: GPUTextureViewDimension;
+}
+
+interface GPUTexelCopyBufferInfo extends GPUTexelCopyBufferLayout {
+ buffer: GPUBuffer;
+}
+
+interface GPUTexelCopyBufferLayout {
+ bytesPerRow?: GPUSize32;
+ offset?: GPUSize64;
+ rowsPerImage?: GPUSize32;
+}
+
+interface GPUTexelCopyTextureInfo {
+ aspect?: GPUTextureAspect;
+ mipLevel?: GPUIntegerCoordinate;
+ origin?: GPUOrigin3D;
+ texture: GPUTexture;
+}
+
+interface GPUTextureBindingLayout {
+ multisampled?: boolean;
+ sampleType?: GPUTextureSampleType;
+ viewDimension?: GPUTextureViewDimension;
+}
+
+interface GPUTextureDescriptor extends GPUObjectDescriptorBase {
+ dimension?: GPUTextureDimension;
+ format: GPUTextureFormat;
+ mipLevelCount?: GPUIntegerCoordinate;
+ sampleCount?: GPUSize32;
+ size: GPUExtent3D;
+ usage: GPUTextureUsageFlags;
+ viewFormats?: GPUTextureFormat[];
+}
+
+interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase {
+ arrayLayerCount?: GPUIntegerCoordinate;
+ aspect?: GPUTextureAspect;
+ baseArrayLayer?: GPUIntegerCoordinate;
+ baseMipLevel?: GPUIntegerCoordinate;
+ dimension?: GPUTextureViewDimension;
+ format?: GPUTextureFormat;
+ mipLevelCount?: GPUIntegerCoordinate;
+}
+
+interface GPUUncapturedErrorEventInit extends EventInit {
+ error: GPUError;
+}
+
+interface GPUVertexAttribute {
+ format: GPUVertexFormat;
+ offset: GPUSize64;
+ shaderLocation: GPUIndex32;
+}
+
+interface GPUVertexBufferLayout {
+ arrayStride: GPUSize64;
+ attributes: GPUVertexAttribute[];
+ stepMode?: GPUVertexStepMode;
+}
+
+interface GPUVertexState extends GPUProgrammableStage {
+ buffers?: (GPUVertexBufferLayout | null)[];
+}
+
+interface GainOptions extends AudioNodeOptions {
+ gain?: number;
+}
+
+interface GamepadAxisMoveEventInit extends GamepadEventInit {
+ axis?: number;
+ value?: number;
+}
+
+interface GamepadButtonEventInit extends GamepadEventInit {
+ button?: number;
+}
+
+interface GamepadEventInit extends EventInit {
+ gamepad?: Gamepad | null;
+}
+
+interface GamepadLightColor {
+ blue: number;
+ green: number;
+ red: number;
+}
+
+interface GeometryUtilsOptions {
+ createFramesForSuppressedWhitespace?: boolean;
+ flush?: boolean;
+}
+
+interface GetAnimationsOptions {
+ subtree?: boolean;
+}
+
+interface GetChildrenOptions {
+ ignoreAbsent?: boolean;
+}
+
+interface GetHTMLOptions {
+ serializableShadowRoots?: boolean;
+ shadowRoots?: ShadowRoot[];
+}
+
+interface GetNotificationOptions {
+ tag?: string;
+}
+
+interface GetRootNodeOptions {
+ composed?: boolean;
+}
+
+interface GleanDistributionData {
+ count: number;
+ sum: number;
+ values: Record;
+}
+
+interface GleanEventRecord {
+ category: string;
+ extra?: Record;
+ name: string;
+ timestamp: number;
+}
+
+interface GleanRateData {
+ denominator: number;
+ numerator: number;
+}
+
+interface HTMLMediaElementDebugInfo {
+ EMEInfo?: EMEDebugInfo;
+ compositorDroppedFrames?: number;
+ decoder?: MediaDecoderDebugInfo;
+}
+
+interface HasChildrenOptions {
+ ignoreAbsent?: boolean;
+}
+
+interface HashChangeEventInit extends EventInit {
+ newURL?: string;
+ oldURL?: string;
+}
+
+interface HeapSnapshotBoundaries {
+ debugger?: any;
+ globals?: any[];
+ runtime?: boolean;
+}
+
+interface IDBDatabaseInfo {
+ name?: string;
+ version?: number;
+}
+
+interface IDBIndexParameters {
+ locale?: string | null;
+ multiEntry?: boolean;
+ unique?: boolean;
+}
+
+interface IDBObjectStoreParameters {
+ autoIncrement?: boolean;
+ keyPath?: string | string[] | null;
+}
+
+interface IDBOpenDBOptions {
+ version?: number;
+}
+
+interface IDBTransactionOptions {
+ durability?: IDBTransactionDurability;
+}
+
+interface IDBVersionChangeEventInit extends EventInit {
+ newVersion?: number | null;
+ oldVersion?: number;
+}
+
+interface IIRFilterOptions extends AudioNodeOptions {
+ feedback: number[];
+ feedforward: number[];
+}
+
+interface IdentityCredentialDisconnectOptions extends IdentityProviderConfig {
+ accountHint: string;
+}
+
+interface IdentityCredentialInit {
+ effectiveOrigins?: string[];
+ effectiveQueryURL?: string;
+ effectiveType?: string;
+ id: string;
+ token?: string;
+ uiHint?: IdentityCredentialUserData;
+}
+
+interface IdentityCredentialRequestOptions {
+ providers?: IdentityProviderConfig[];
+}
+
+interface IdentityCredentialUserData {
+ expiresAfter?: number;
+ iconURL: string;
+ name: string;
+}
+
+interface IdentityProviderConfig {
+ clientId?: string;
+ configURL?: string;
+ effectiveQueryURL?: string;
+ effectiveType?: string;
+ loginTarget?: IdentityLoginTargetType;
+ loginURL?: string;
+ nonce?: string;
+ origin?: string;
+}
+
+interface IdleRequestOptions {
+ timeout?: number;
+}
+
+interface ImageBitmapOptions {
+ colorSpaceConversion?: ColorSpaceConversion;
+ imageOrientation?: ImageOrientation;
+ premultiplyAlpha?: PremultiplyAlpha;
+ resizeHeight?: number;
+ resizeWidth?: number;
+}
+
+interface ImageCaptureErrorEventInit extends EventInit {
+ imageCaptureError?: ImageCaptureError | null;
+}
+
+interface ImageDecodeOptions {
+ completeFramesOnly?: boolean;
+ frameIndex?: number;
+}
+
+interface ImageDecodeResult {
+ complete: boolean;
+ image: VideoFrame;
+}
+
+interface ImageDecoderInit {
+ colorSpaceConversion?: ColorSpaceConversion;
+ data: ImageBufferSource;
+ desiredHeight?: number;
+ desiredWidth?: number;
+ preferAnimation?: boolean;
+ transfer?: ArrayBuffer[];
+ type: string;
+}
+
+interface ImageEncodeOptions {
+ quality?: number;
+ type?: string;
+}
+
+interface ImageText {
+ confidence: number;
+ quad: DOMQuad;
+ string: string;
+}
+
+interface ImportESModuleOptionsDictionary {
+ global?: ImportESModuleTargetGlobal;
+}
+
+interface InputEventInit extends UIEventInit {
+ data?: string | null;
+ dataTransfer?: DataTransfer | null;
+ inputType?: string;
+ isComposing?: boolean;
+ targetRanges?: StaticRange[];
+}
+
+interface InspectorCSSPropertyDefinition {
+ fromJS: boolean;
+ inherits: boolean;
+ initialValue: string | null;
+ name: string;
+ syntax: string;
+}
+
+interface InspectorCSSToken {
+ number?: number | null;
+ text: string;
+ tokenType: string;
+ unit: string | null;
+ value: string | null;
+}
+
+interface InspectorColorToResult {
+ adjusted: boolean;
+ color: string;
+ components: number[] | Float32Array;
+}
+
+interface InspectorFontFeature {
+ languageSystem: string;
+ script: string;
+ tag: string;
+}
+
+interface InspectorRGBATuple {
+ a?: number;
+ b?: number;
+ g?: number;
+ r?: number;
+}
+
+interface InspectorStyleSheetRuleCountAndAtRulesResult {
+ atRules: CSSRule[];
+ ruleCount: number;
+}
+
+interface InspectorVariationAxis {
+ defaultValue: number;
+ maxValue: number;
+ minValue: number;
+ name: string;
+ tag: string;
+}
+
+interface InspectorVariationInstance {
+ name: string;
+ values: InspectorVariationValue[];
+}
+
+interface InspectorVariationValue {
+ axis: string;
+ value: number;
+}
+
+interface InstallTriggerData {
+ Hash?: string | null;
+ IconURL?: string | null;
+ URL?: string;
+}
+
+interface InteractionData {
+ interactionCount?: number;
+ interactionTimeInMilliseconds?: number;
+ scrollingDistanceInPixels?: number;
+}
+
+interface IntersectionObserverInit {
+ root?: Element | Document | null;
+ rootMargin?: string;
+ threshold?: number | number[];
+}
+
+interface InvokeEventInit extends EventInit {
+ action?: string;
+ invoker?: Element | null;
+}
+
+interface KeySystemTrackConfiguration {
+ encryptionScheme?: string | null;
+ robustness?: string;
+}
+
+interface KeyboardEventInit extends EventModifierInit {
+ charCode?: number;
+ code?: string;
+ isComposing?: boolean;
+ key?: string;
+ keyCode?: number;
+ location?: number;
+ repeat?: boolean;
+ which?: number;
+}
+
+interface KeyframeAnimationOptions extends KeyframeEffectOptions {
+ id?: string;
+}
+
+interface KeyframeEffectOptions extends EffectTiming {
+ composite?: CompositeOperation;
+ iterationComposite?: IterationCompositeOperation;
+ pseudoElement?: string | null;
+}
+
+interface L10nFileSourceMockFile {
+ path: string;
+ source: string;
+}
+
+interface L10nIdArgs {
+ args?: L10nArgs | null;
+ id?: string | null;
+}
+
+interface L10nMessage {
+ attributes?: AttributeNameValue[] | null;
+ value?: string | null;
+}
+
+interface L10nOverlaysError {
+ code?: number;
+ l10nName?: string;
+ sourceElementName?: string;
+ translatedElementName?: string;
+}
+
+interface L10nRegistryOptions {
+ bundleOptions?: FluentBundleOptions;
+}
+
+interface LibcConstants {
+ AT_EACCESS?: number;
+ EACCES?: number;
+ EAGAIN?: number;
+ EINTR?: number;
+ EINVAL?: number;
+ ENOSYS?: number;
+ EPERM?: number;
+ FD_CLOEXEC?: number;
+ F_SETFD?: number;
+ F_SETFL?: number;
+ O_CREAT?: number;
+ O_NONBLOCK?: number;
+ O_WRONLY?: number;
+ POLLERR?: number;
+ POLLHUP?: number;
+ POLLIN?: number;
+ POLLNVAL?: number;
+ POLLOUT?: number;
+ PR_CAPBSET_READ?: number;
+ WNOHANG?: number;
+}
+
+interface LoadURIOptions {
+ baseURI?: URI | null;
+ cancelContentJSEpoch?: number;
+ csp?: ContentSecurityPolicy | null;
+ hasValidUserGestureActivation?: boolean;
+ headers?: InputStream | null;
+ loadFlags?: number;
+ postData?: InputStream | null;
+ referrerInfo?: ReferrerInfo | null;
+ remoteTypeOverride?: string | null;
+ schemelessInput?: number;
+ textDirectiveUserActivation?: boolean;
+ triggeringPrincipal?: Principal | null;
+ triggeringRemoteType?: string | null;
+ triggeringSandboxFlags?: number;
+ triggeringStorageAccess?: boolean;
+ triggeringWindowId?: number;
+}
+
+interface LockInfo {
+ clientId?: string;
+ mode?: LockMode;
+ name?: string;
+}
+
+interface LockManagerSnapshot {
+ held?: LockInfo[];
+ pending?: LockInfo[];
+}
+
+interface LockOptions {
+ ifAvailable?: boolean;
+ mode?: LockMode;
+ signal?: AbortSignal;
+ steal?: boolean;
+}
+
+interface MIDIConnectionEventInit extends EventInit {
+ port?: MIDIPort | null;
+}
+
+interface MIDIMessageEventInit extends EventInit {
+ data?: Uint8Array;
+}
+
+interface MIDIOptions {
+ software?: boolean;
+ sysex?: boolean;
+}
+
+interface MLSBytes {
+ content: Uint8Array;
+ type: MLSObjectType;
+}
+
+interface MLSCommitOutput {
+ clientId?: Uint8Array;
+ commit: Uint8Array;
+ groupId: Uint8Array;
+ groupInfo?: Uint8Array;
+ ratchetTree?: Uint8Array;
+ type: MLSObjectType;
+ welcome?: Uint8Array;
+}
+
+interface MLSExporterOutput {
+ context: Uint8Array;
+ groupEpoch: Uint8Array;
+ groupId: Uint8Array;
+ label: Uint8Array;
+ secret: Uint8Array;
+ type: MLSObjectType;
+}
+
+interface MLSGroupDetails {
+ groupEpoch: Uint8Array;
+ groupId: Uint8Array;
+ members: MLSGroupMember[];
+ type: MLSObjectType;
+}
+
+interface MLSGroupMember {
+ clientId: Uint8Array;
+ credential: Uint8Array;
+}
+
+interface MLSReceived {
+ commitOutput?: MLSCommitOutput;
+ content?: Uint8Array;
+ groupEpoch?: Uint8Array;
+ groupId: Uint8Array;
+ type: MLSObjectType;
+}
+
+interface MakeDirectoryOptions {
+ createAncestors?: boolean;
+ ignoreExisting?: boolean;
+ permissions?: number;
+}
+
+interface MatchPatternOptions {
+ ignorePath?: boolean;
+ restrictSchemes?: boolean;
+}
+
+interface MediaCacheStreamDebugInfo {
+ cacheSuspended?: boolean;
+ channelEnded?: boolean;
+ channelOffset?: number;
+ loadID?: number;
+ streamLength?: number;
+}
+
+interface MediaCapabilitiesDecodingInfo extends MediaCapabilitiesInfo {
+ keySystemAccess: MediaKeySystemAccess | null;
+}
+
+interface MediaCapabilitiesInfo {
+ powerEfficient: boolean;
+ smooth: boolean;
+ supported: boolean;
+}
+
+interface MediaCapabilitiesKeySystemConfiguration {
+ audio?: KeySystemTrackConfiguration;
+ distinctiveIdentifier?: MediaKeysRequirement;
+ initDataType?: string;
+ keySystem: string;
+ persistentState?: MediaKeysRequirement;
+ sessionTypes?: string[];
+ video?: KeySystemTrackConfiguration;
+}
+
+interface MediaConfiguration {
+ audio?: AudioConfiguration;
+ video?: VideoConfiguration;
+}
+
+interface MediaControllerPositionState {
+ duration: number;
+ playbackRate: number;
+ position: number;
+}
+
+interface MediaDecoderDebugInfo {
+ PlayState?: string;
+ channels?: number;
+ containerType?: string;
+ hasAudio?: boolean;
+ hasVideo?: boolean;
+ instance?: string;
+ rate?: number;
+ reader?: MediaFormatReaderDebugInfo;
+ resource?: MediaResourceDebugInfo;
+ stateMachine?: MediaDecoderStateMachineDebugInfo;
+}
+
+interface MediaDecoderStateMachineDebugInfo {
+ audioCompleted?: boolean;
+ audioRequestStatus?: string;
+ clock?: number;
+ decodedAudioEndTime?: number;
+ decodedVideoEndTime?: number;
+ duration?: number;
+ isPlaying?: boolean;
+ mediaSink?: MediaSinkDebugInfo;
+ mediaTime?: number;
+ playState?: number;
+ sentFirstFrameLoadedEvent?: boolean;
+ state?: string;
+ stateObj?: MediaDecoderStateMachineDecodingStateDebugInfo;
+ totalBufferingTimeMs?: number;
+ videoCompleted?: boolean;
+ videoRequestStatus?: string;
+}
+
+interface MediaDecoderStateMachineDecodingStateDebugInfo {
+ isPrerolling?: boolean;
+}
+
+interface MediaDecodingConfiguration extends MediaConfiguration {
+ keySystemConfiguration?: MediaCapabilitiesKeySystemConfiguration;
+ type: MediaDecodingType;
+}
+
+interface MediaElementAudioSourceOptions {
+ mediaElement: HTMLMediaElement;
+}
+
+interface MediaEncodingConfiguration extends MediaConfiguration {
+ type: MediaEncodingType;
+}
+
+interface MediaFormatReaderDebugInfo {
+ audioChannels?: number;
+ audioDecoderName?: string;
+ audioFramesDecoded?: number;
+ audioRate?: number;
+ audioState?: MediaStateDebugInfo;
+ audioType?: string;
+ frameStats?: MediaFrameStats;
+ totalReadMetadataTimeMs?: number;
+ totalWaitingForVideoDataTimeMs?: number;
+ videoDecoderName?: string;
+ videoHardwareAccelerated?: boolean;
+ videoHeight?: number;
+ videoNumSamplesOutputTotal?: number;
+ videoNumSamplesSkippedTotal?: number;
+ videoRate?: number;
+ videoState?: MediaStateDebugInfo;
+ videoType?: string;
+ videoWidth?: number;
+}
+
+interface MediaFrameStats {
+ droppedCompositorFrames?: number;
+ droppedDecodedFrames?: number;
+ droppedSinkFrames?: number;
+}
+
+interface MediaImage {
+ sizes?: string;
+ src: string;
+ type?: string;
+}
+
+interface MediaKeyMessageEventInit extends EventInit {
+ message: ArrayBuffer;
+ messageType: MediaKeyMessageType;
+}
+
+interface MediaKeyNeededEventInit extends EventInit {
+ initData?: ArrayBuffer | null;
+ initDataType?: string;
+}
+
+interface MediaKeySystemConfiguration {
+ audioCapabilities?: MediaKeySystemMediaCapability[];
+ distinctiveIdentifier?: MediaKeysRequirement;
+ initDataTypes?: string[];
+ label?: string;
+ persistentState?: MediaKeysRequirement;
+ sessionTypes?: string[];
+ videoCapabilities?: MediaKeySystemMediaCapability[];
+}
+
+interface MediaKeySystemMediaCapability {
+ contentType?: string;
+ encryptionScheme?: string | null;
+ robustness?: string;
+}
+
+interface MediaKeysPolicy {
+ minHdcpVersion?: HDCPVersion;
+}
+
+interface MediaMetadataInit {
+ album?: string;
+ artist?: string;
+ artwork?: MediaImage[];
+ title?: string;
+}
+
+interface MediaPositionState {
+ duration?: number;
+ playbackRate?: number;
+ position?: number;
+}
+
+interface MediaQueryListEventInit extends EventInit {
+ matches?: boolean;
+ media?: string;
+}
+
+interface MediaRecorderErrorEventInit extends EventInit {
+ error: DOMException;
+}
+
+interface MediaRecorderOptions {
+ audioBitsPerSecond?: number;
+ bitsPerSecond?: number;
+ mimeType?: string;
+ videoBitsPerSecond?: number;
+}
+
+interface MediaResourceDebugInfo {
+ cacheStream?: MediaCacheStreamDebugInfo;
+}
+
+interface MediaSessionActionDetails {
+ action: MediaSessionAction;
+ fastSeek?: boolean;
+ seekOffset?: number;
+ seekTime?: number;
+}
+
+interface MediaSinkDebugInfo {
+ audioSinkWrapper?: AudioSinkWrapperDebugInfo;
+ decodedStream?: DecodedStreamDebugInfo;
+ videoSink?: VideoSinkDebugInfo;
+}
+
+interface MediaSourceDecoderDebugInfo {
+ demuxer?: MediaSourceDemuxerDebugInfo;
+ reader?: MediaFormatReaderDebugInfo;
+}
+
+interface MediaSourceDemuxerDebugInfo {
+ audioTrack?: TrackBuffersManagerDebugInfo;
+ videoTrack?: TrackBuffersManagerDebugInfo;
+}
+
+interface MediaStateDebugInfo {
+ demuxEOS?: number;
+ demuxQueueSize?: number;
+ drainState?: number;
+ hasDecoder?: boolean;
+ hasDemuxRequest?: boolean;
+ hasPromise?: boolean;
+ lastStreamSourceID?: number;
+ needInput?: boolean;
+ numSamplesInput?: number;
+ numSamplesOutput?: number;
+ pending?: number;
+ queueSize?: number;
+ timeTreshold?: number;
+ timeTresholdHasSeeked?: boolean;
+ waitingForData?: boolean;
+ waitingForKey?: boolean;
+ waitingPromise?: boolean;
+}
+
+interface MediaStreamAudioSourceOptions {
+ mediaStream: MediaStream;
+}
+
+interface MediaStreamConstraints {
+ audio?: boolean | MediaTrackConstraints;
+ fake?: boolean;
+ peerIdentity?: string | null;
+ picture?: boolean;
+ video?: boolean | MediaTrackConstraints;
+}
+
+interface MediaStreamEventInit extends EventInit {
+ stream?: MediaStream | null;
+}
+
+interface MediaStreamTrackAudioSourceOptions {
+ mediaStreamTrack: MediaStreamTrack;
+}
+
+interface MediaStreamTrackEventInit extends EventInit {
+ track: MediaStreamTrack;
+}
+
+interface MediaTrackCapabilities {
+ autoGainControl?: boolean[];
+ channelCount?: ULongRange;
+ deviceId?: string;
+ echoCancellation?: boolean[];
+ facingMode?: string[];
+ frameRate?: DoubleRange;
+ groupId?: string;
+ height?: ULongRange;
+ noiseSuppression?: boolean[];
+ width?: ULongRange;
+}
+
+interface MediaTrackConstraintSet {
+ autoGainControl?: ConstrainBoolean;
+ browserWindow?: number;
+ channelCount?: ConstrainLong;
+ deviceId?: ConstrainDOMString;
+ echoCancellation?: ConstrainBoolean;
+ facingMode?: ConstrainDOMString;
+ frameRate?: ConstrainDouble;
+ groupId?: ConstrainDOMString;
+ height?: ConstrainLong;
+ mediaSource?: string;
+ noiseSuppression?: ConstrainBoolean;
+ scrollWithPage?: boolean;
+ viewportHeight?: ConstrainLong;
+ viewportOffsetX?: ConstrainLong;
+ viewportOffsetY?: ConstrainLong;
+ viewportWidth?: ConstrainLong;
+ width?: ConstrainLong;
+}
+
+interface MediaTrackConstraints extends MediaTrackConstraintSet {
+ advanced?: MediaTrackConstraintSet[];
+}
+
+interface MediaTrackSettings {
+ autoGainControl?: boolean;
+ browserWindow?: number;
+ channelCount?: number;
+ deviceId?: string;
+ echoCancellation?: boolean;
+ facingMode?: string;
+ frameRate?: number;
+ groupId?: string;
+ height?: number;
+ mediaSource?: string;
+ noiseSuppression?: boolean;
+ scrollWithPage?: boolean;
+ viewportHeight?: number;
+ viewportOffsetX?: number;
+ viewportOffsetY?: number;
+ viewportWidth?: number;
+ width?: number;
+}
+
+interface MediaTrackSupportedConstraints {
+ aspectRatio?: boolean;
+ autoGainControl?: boolean;
+ browserWindow?: boolean;
+ channelCount?: boolean;
+ deviceId?: boolean;
+ echoCancellation?: boolean;
+ facingMode?: boolean;
+ frameRate?: boolean;
+ groupId?: boolean;
+ height?: boolean;
+ latency?: boolean;
+ mediaSource?: boolean;
+ noiseSuppression?: boolean;
+ sampleRate?: boolean;
+ sampleSize?: boolean;
+ scrollWithPage?: boolean;
+ viewportHeight?: boolean;
+ viewportOffsetX?: boolean;
+ viewportOffsetY?: boolean;
+ viewportWidth?: boolean;
+ volume?: boolean;
+ width?: boolean;
+}
+
+interface MerchantValidationEventInit extends EventInit {
+ methodName?: string;
+ validationURL?: string;
+}
+
+interface MessageEventInit extends EventInit {
+ data?: any;
+ lastEventId?: string;
+ origin?: string;
+ ports?: MessagePort[];
+ source?: MessageEventSource | null;
+}
+
+interface MouseEventInit extends EventModifierInit {
+ button?: number;
+ buttons?: number;
+ clientX?: number;
+ clientY?: number;
+ movementX?: number;
+ movementY?: number;
+ relatedTarget?: EventTarget | null;
+ screenX?: number;
+ screenY?: number;
+}
+
+interface MoveOptions {
+ noOverwrite?: boolean;
+}
+
+interface MozDocumentMatcherInit {
+ allFrames?: boolean;
+ checkPermissions?: boolean;
+ excludeGlobs?: MatchGlobOrString[] | null;
+ excludeMatches?: MatchPatternSetOrStringSequence | null;
+ frameID?: number | null;
+ hasActiveTabPermission?: boolean;
+ includeGlobs?: MatchGlobOrString[] | null;
+ isUserScript?: boolean;
+ matchAboutBlank?: boolean;
+ matchOriginAsFallback?: boolean;
+ matches: MatchPatternSetOrStringSequence;
+ originAttributesPatterns?: OriginAttributesPatternDictionary[] | null;
+}
+
+interface MozFrameAncestorInfo {
+ frameId: number;
+ url: string;
+}
+
+interface MozHTTPHeader {
+ name: string;
+ value: string;
+}
+
+interface MozProxyInfo {
+ connectionIsolationKey?: string | null;
+ failoverTimeout?: number;
+ host: string;
+ port: number;
+ proxyAuthorizationHeader?: string | null;
+ proxyDNS: boolean;
+ type: string;
+ username?: string | null;
+}
+
+interface MozRequestFilter {
+ incognito?: boolean | null;
+ types?: MozContentPolicyType[] | null;
+ urls?: MatchPatternSet | null;
+}
+
+interface MozRequestMatchOptions {
+ isProxy?: boolean;
+}
+
+interface MozUrlClassification {
+ firstParty: MozUrlClassificationFlags[];
+ thirdParty: MozUrlClassificationFlags[];
+}
+
+interface MozXMLHttpRequestParameters {
+ mozAnon?: boolean;
+ mozSystem?: boolean;
+}
+
+interface MultiCacheQueryOptions extends CacheQueryOptions {
+ cacheName?: string;
+}
+
+interface MutationObserverInit {
+ animations?: boolean;
+ attributeFilter?: string[];
+ attributeOldValue?: boolean;
+ attributes?: boolean;
+ characterData?: boolean;
+ characterDataOldValue?: boolean;
+ childList?: boolean;
+ chromeOnlyNodes?: boolean;
+ subtree?: boolean;
+}
+
+interface MutationObservingInfo extends MutationObserverInit {
+ observedNode?: Node | null;
+}
+
+interface NavigateEventInit extends EventInit {
+ canIntercept?: boolean;
+ destination: NavigationDestination;
+ downloadRequest?: string | null;
+ formData?: FormData | null;
+ hasUAVisualTransition?: boolean;
+ hashChange?: boolean;
+ info?: any;
+ navigationType?: NavigationType;
+ signal: AbortSignal;
+ sourceElement?: Element | null;
+ userInitiated?: boolean;
+}
+
+interface NavigationCurrentEntryChangeEventInit extends EventInit {
+ from: NavigationHistoryEntry;
+ navigationType?: NavigationType | null;
+}
+
+interface NavigationInterceptOptions {
+ focusReset?: NavigationFocusReset;
+ handler?: NavigationInterceptHandler;
+ scroll?: NavigationScrollBehavior;
+}
+
+interface NavigationNavigateOptions extends NavigationOptions {
+ history?: NavigationHistoryBehavior;
+ state?: any;
+}
+
+interface NavigationOptions {
+ info?: any;
+}
+
+interface NavigationPreloadState {
+ enabled?: boolean;
+ headerValue?: string;
+}
+
+interface NavigationReloadOptions extends NavigationOptions {
+ state?: any;
+}
+
+interface NavigationResult {
+ committed?: Promise;
+ finished?: Promise;
+}
+
+interface NavigationUpdateCurrentEntryOptions {
+ state: any;
+}
+
+interface NetErrorInfo {
+ channelStatus?: number;
+ errorCodeString?: string;
+ responseStatus?: number;
+ responseStatusText?: string;
+}
+
+interface NotificationAction {
+ action: string;
+ title: string;
+}
+
+interface NotificationOptions {
+ actions?: NotificationAction[];
+ body?: string;
+ data?: any;
+ dir?: NotificationDirection;
+ icon?: string;
+ lang?: string;
+ requireInteraction?: boolean;
+ silent?: boolean;
+ tag?: string;
+ vibrate?: VibratePattern;
+}
+
+interface ObservableArrayCallbacks {
+ deleteBooleanCallback?: SetDeleteBooleanCallback;
+ deleteInterfaceCallback?: SetDeleteInterfaceCallback;
+ deleteObjectCallback?: SetDeleteObjectCallback;
+ setBooleanCallback?: SetDeleteBooleanCallback;
+ setInterfaceCallback?: SetDeleteInterfaceCallback;
+ setObjectCallback?: SetDeleteObjectCallback;
+}
+
+interface OfflineAudioCompletionEventInit extends EventInit {
+ renderedBuffer: AudioBuffer;
+}
+
+interface OfflineAudioContextOptions {
+ length: number;
+ numberOfChannels?: number;
+ sampleRate: number;
+}
+
+interface OpenPopupOptions {
+ attributesOverride?: boolean;
+ isContextMenu?: boolean;
+ position?: string;
+ triggerEvent?: Event | null;
+ x?: number;
+ y?: number;
+}
+
+interface OptionalEffectTiming {
+ delay?: number;
+ direction?: PlaybackDirection;
+ duration?: number | string;
+ easing?: string;
+ endDelay?: number;
+ fill?: FillMode;
+ iterationStart?: number;
+ iterations?: number;
+}
+
+interface OpusEncoderConfig {
+ complexity?: number;
+ format?: OpusBitstreamFormat;
+ frameDuration?: number;
+ packetlossperc?: number;
+ usedtx?: boolean;
+ useinbandfec?: boolean;
+}
+
+interface OriginAttributesDictionary {
+ firstPartyDomain?: string;
+ geckoViewSessionContextId?: string;
+ partitionKey?: string;
+ privateBrowsingId?: number;
+ userContextId?: number;
+}
+
+interface OriginAttributesPatternDictionary {
+ firstPartyDomain?: string;
+ geckoViewSessionContextId?: string;
+ partitionKey?: string;
+ partitionKeyPattern?: PartitionKeyPatternDictionary;
+ privateBrowsingId?: number;
+ userContextId?: number;
+}
+
+interface OscillatorOptions extends AudioNodeOptions {
+ detune?: number;
+ frequency?: number;
+ periodicWave?: PeriodicWave;
+ type?: OscillatorType;
+}
+
+interface PCErrorData {
+ message: string;
+ name: PCError;
+}
+
+interface PageTransitionEventInit extends EventInit {
+ inFrameSwap?: boolean;
+ persisted?: boolean;
+}
+
+interface PannerOptions extends AudioNodeOptions {
+ coneInnerAngle?: number;
+ coneOuterAngle?: number;
+ coneOuterGain?: number;
+ distanceModel?: DistanceModelType;
+ maxDistance?: number;
+ orientationX?: number;
+ orientationY?: number;
+ orientationZ?: number;
+ panningModel?: PanningModelType;
+ positionX?: number;
+ positionY?: number;
+ positionZ?: number;
+ refDistance?: number;
+ rolloffFactor?: number;
+}
+
+interface ParentProcInfoDictionary {
+ children?: ChildProcInfoDictionary[];
+ cpuCycleCount?: number;
+ cpuTime?: number;
+ memory?: number;
+ pid?: number;
+ threads?: ThreadInfoDictionary[];
+ type?: WebIDLProcType;
+}
+
+interface PartitionKeyPatternDictionary {
+ baseDomain?: string;
+ foreignByAncestorContext?: boolean;
+ port?: number;
+ scheme?: string;
+}
+
+interface PayerErrors {
+ email?: string;
+ name?: string;
+ phone?: string;
+}
+
+interface PaymentCurrencyAmount {
+ currency: string;
+ value: string;
+}
+
+interface PaymentDetailsBase {
+ displayItems?: PaymentItem[];
+ modifiers?: PaymentDetailsModifier[];
+ shippingOptions?: PaymentShippingOption[];
+}
+
+interface PaymentDetailsInit extends PaymentDetailsBase {
+ id?: string;
+ total: PaymentItem;
+}
+
+interface PaymentDetailsModifier {
+ additionalDisplayItems?: PaymentItem[];
+ data?: any;
+ supportedMethods: string;
+ total?: PaymentItem;
+}
+
+interface PaymentDetailsUpdate extends PaymentDetailsBase {
+ error?: string;
+ payerErrors?: PayerErrors;
+ paymentMethodErrors?: any;
+ shippingAddressErrors?: AddressErrors;
+ total?: PaymentItem;
+}
+
+interface PaymentItem {
+ amount: PaymentCurrencyAmount;
+ label: string;
+ pending?: boolean;
+}
+
+interface PaymentMethodChangeEventInit extends PaymentRequestUpdateEventInit {
+ methodDetails?: any;
+ methodName?: string;
+}
+
+interface PaymentMethodData {
+ data?: any;
+ supportedMethods: string;
+}
+
+interface PaymentOptions {
+ requestBillingAddress?: boolean;
+ requestPayerEmail?: boolean;
+ requestPayerName?: boolean;
+ requestPayerPhone?: boolean;
+ requestShipping?: boolean;
+ shippingType?: PaymentShippingType;
+}
+
+interface PaymentRequestUpdateEventInit extends EventInit {}
+
+interface PaymentShippingOption {
+ amount: PaymentCurrencyAmount;
+ id: string;
+ label: string;
+ selected?: boolean;
+}
+
+interface PaymentValidationErrors {
+ error?: string;
+ payer?: PayerErrors;
+ paymentMethod?: any;
+ shippingAddress?: AddressErrors;
+}
+
+interface PerformanceEntryEventInit extends EventInit {
+ duration?: DOMHighResTimeStamp;
+ entryType?: string;
+ epoch?: number;
+ name?: string;
+ origin?: string;
+ startTime?: DOMHighResTimeStamp;
+}
+
+interface PerformanceEntryFilterOptions {
+ entryType?: string;
+ initiatorType?: string;
+ name?: string;
+}
+
+interface PerformanceMarkOptions {
+ detail?: any;
+ startTime?: DOMHighResTimeStamp;
+}
+
+interface PerformanceMeasureOptions {
+ detail?: any;
+ duration?: DOMHighResTimeStamp;
+ end?: string | DOMHighResTimeStamp;
+ start?: string | DOMHighResTimeStamp;
+}
+
+interface PerformanceObserverInit {
+ buffered?: boolean;
+ durationThreshold?: DOMHighResTimeStamp;
+ entryTypes?: string[];
+ type?: string;
+}
+
+interface PeriodicWaveConstraints {
+ disableNormalization?: boolean;
+}
+
+interface PeriodicWaveOptions extends PeriodicWaveConstraints {
+ imag?: number[] | Float32Array;
+ real?: number[] | Float32Array;
+}
+
+interface PermissionSetParameters {
+ descriptor: any;
+ state: PermissionState;
+}
+
+interface PlacesBookmarkAdditionInit {
+ dateAdded: number;
+ frecency: number;
+ guid: string;
+ hidden: boolean;
+ id: number;
+ index: number;
+ isTagging: boolean;
+ itemType: number;
+ lastVisitDate: number | null;
+ parentGuid: string;
+ parentId: number;
+ source: number;
+ tags: string | null;
+ targetFolderGuid: string | null;
+ targetFolderItemId: number;
+ targetFolderTitle: string | null;
+ title: string;
+ url: string;
+ visitCount: number;
+}
+
+interface PlacesBookmarkGuidInit {
+ guid: string;
+ id: number;
+ isTagging: boolean;
+ itemType: number;
+ lastModified: number;
+ parentGuid: string;
+ source: number;
+ url?: string | null;
+}
+
+interface PlacesBookmarkKeywordInit {
+ guid: string;
+ id: number;
+ isTagging: boolean;
+ itemType: number;
+ keyword: string;
+ lastModified: number;
+ parentGuid: string;
+ source: number;
+ url?: string | null;
+}
+
+interface PlacesBookmarkMovedInit {
+ dateAdded: number;
+ frecency: number;
+ guid: string;
+ hidden: boolean;
+ id: number;
+ index: number;
+ isTagging: boolean;
+ itemType: number;
+ lastVisitDate: number | null;
+ oldIndex: number;
+ oldParentGuid: string;
+ parentGuid: string;
+ source: number;
+ tags: string | null;
+ title: string;
+ url?: string | null;
+ visitCount: number;
+}
+
+interface PlacesBookmarkRemovedInit {
+ guid: string;
+ id: number;
+ index: number;
+ isDescendantRemoval?: boolean;
+ isTagging: boolean;
+ itemType: number;
+ parentGuid: string;
+ parentId: number;
+ source: number;
+ title: string;
+ url: string;
+}
+
+interface PlacesBookmarkTagsInit {
+ guid: string;
+ id: number;
+ isTagging: boolean;
+ itemType: number;
+ lastModified: number;
+ parentGuid: string;
+ source: number;
+ tags: string[];
+ url?: string | null;
+}
+
+interface PlacesBookmarkTimeInit {
+ dateAdded: number;
+ guid: string;
+ id: number;
+ isTagging: boolean;
+ itemType: number;
+ lastModified: number;
+ parentGuid: string;
+ source: number;
+ url?: string | null;
+}
+
+interface PlacesBookmarkTitleInit {
+ guid: string;
+ id: number;
+ isTagging: boolean;
+ itemType: number;
+ lastModified: number;
+ parentGuid: string;
+ source: number;
+ title: string;
+ url?: string | null;
+}
+
+interface PlacesBookmarkUrlInit {
+ guid: string;
+ id: number;
+ isTagging: boolean;
+ itemType: number;
+ lastModified: number;
+ parentGuid: string;
+ source: number;
+ url: string;
+}
+
+interface PlacesFaviconInit {
+ faviconUrl: string;
+ pageGuid: string;
+ url: string;
+}
+
+interface PlacesVisitRemovedInit {
+ isPartialVisistsRemoval?: boolean;
+ isRemovedFromStore?: boolean;
+ pageGuid: string;
+ reason: number;
+ transitionType?: number;
+ url: string;
+}
+
+interface PlacesVisitTitleInit {
+ pageGuid: string;
+ title: string;
+ url: string;
+}
+
+interface PlaneLayout {
+ offset: number;
+ stride: number;
+}
+
+interface PluginCrashedEventInit extends EventInit {
+ gmpPlugin?: boolean;
+ pluginDumpID?: string;
+ pluginFilename?: string | null;
+ pluginID?: number;
+ pluginName?: string;
+ submittedCrashReport?: boolean;
+}
+
+interface PointerEventInit extends MouseEventInit {
+ altitudeAngle?: number;
+ azimuthAngle?: number;
+ coalescedEvents?: PointerEvent[];
+ height?: number;
+ isPrimary?: boolean;
+ pointerId?: number;
+ pointerType?: string;
+ predictedEvents?: PointerEvent[];
+ pressure?: number;
+ tangentialPressure?: number;
+ tiltX?: number;
+ tiltY?: number;
+ twist?: number;
+ width?: number;
+}
+
+interface PopStateEventInit extends EventInit {
+ state?: any;
+}
+
+interface PopupBlockedEventInit extends EventInit {
+ popupWindowFeatures?: string;
+ popupWindowName?: string;
+ popupWindowURI?: URI | null;
+ requestingWindow?: Window | null;
+}
+
+interface PopupPositionedEventInit extends EventInit {
+ alignmentOffset?: number;
+ alignmentPosition?: string;
+ isAnchored?: boolean;
+ popupAlignment?: string;
+}
+
+interface PositionOptions {
+ enableHighAccuracy?: boolean;
+ maximumAge?: number;
+ timeout?: number;
+}
+
+interface PositionStateEventInit extends EventInit {
+ duration: number;
+ playbackRate: number;
+ position: number;
+}
+
+interface PrivateAttributionConversionOptions {
+ ads?: string[];
+ histogramSize: number;
+ impression?: PrivateAttributionImpressionType;
+ lookbackDays?: number;
+ sources?: string[];
+ task: string;
+}
+
+interface PrivateAttributionImpressionOptions {
+ ad: string;
+ index: number;
+ target: string;
+ type?: PrivateAttributionImpressionType;
+}
+
+interface ProcessActorChildOptions extends ProcessActorSidedOptions {
+ observers?: string[];
+}
+
+interface ProcessActorOptions {
+ child?: ProcessActorChildOptions;
+ includeParent?: boolean;
+ loadInDevToolsLoader?: boolean;
+ parent?: ProcessActorSidedOptions;
+ remoteTypes?: string[];
+}
+
+interface ProcessActorSidedOptions {
+ esModuleURI?: string;
+}
+
+interface ProfilerMarkerOptions {
+ captureStack?: boolean;
+ category?: string;
+ innerWindowId?: number;
+ startTime?: DOMHighResTimeStamp;
+}
+
+interface ProgressEventInit extends EventInit {
+ lengthComputable?: boolean;
+ loaded?: number;
+ total?: number;
+}
+
+interface PromiseDebuggingStateHolder {
+ reason?: any;
+ state?: PromiseDebuggingState;
+ value?: any;
+}
+
+interface PromiseRejectionEventInit extends EventInit {
+ promise: any;
+ reason?: any;
+}
+
+interface PropertyDefinition {
+ inherits: boolean;
+ initialValue?: string;
+ name: string;
+ syntax?: string;
+}
+
+interface PropertyNamesOptions {
+ includeAliases?: boolean;
+ includeExperimentals?: boolean;
+ includeShorthands?: boolean;
+}
+
+interface PropertyPref {
+ name: string;
+ pref: string;
+}
+
+interface PublicKeyCredentialCreationOptions {
+ attestation?: string;
+ authenticatorSelection?: AuthenticatorSelectionCriteria;
+ challenge: BufferSource;
+ excludeCredentials?: PublicKeyCredentialDescriptor[];
+ extensions?: AuthenticationExtensionsClientInputs;
+ pubKeyCredParams: PublicKeyCredentialParameters[];
+ rp: PublicKeyCredentialRpEntity;
+ timeout?: number;
+ user: PublicKeyCredentialUserEntity;
+}
+
+interface PublicKeyCredentialCreationOptionsJSON {
+ attestation?: string;
+ attestationFormats?: string[];
+ authenticatorSelection?: AuthenticatorSelectionCriteria;
+ challenge: Base64URLString;
+ excludeCredentials?: PublicKeyCredentialDescriptorJSON[];
+ extensions?: AuthenticationExtensionsClientInputsJSON;
+ hints?: string[];
+ pubKeyCredParams: PublicKeyCredentialParameters[];
+ rp: PublicKeyCredentialRpEntity;
+ timeout?: number;
+ user: PublicKeyCredentialUserEntityJSON;
+}
+
+interface PublicKeyCredentialDescriptor {
+ id: BufferSource;
+ transports?: string[];
+ type: string;
+}
+
+interface PublicKeyCredentialDescriptorJSON {
+ id: Base64URLString;
+ transports?: string[];
+ type: string;
+}
+
+interface PublicKeyCredentialEntity {
+ name: string;
+}
+
+interface PublicKeyCredentialParameters {
+ alg: COSEAlgorithmIdentifier;
+ type: string;
+}
+
+interface PublicKeyCredentialRequestOptions {
+ allowCredentials?: PublicKeyCredentialDescriptor[];
+ challenge: BufferSource;
+ extensions?: AuthenticationExtensionsClientInputs;
+ rpId?: string;
+ timeout?: number;
+ userVerification?: string;
+}
+
+interface PublicKeyCredentialRequestOptionsJSON {
+ allowCredentials?: PublicKeyCredentialDescriptorJSON[];
+ attestation?: string;
+ attestationFormats?: string[];
+ challenge: Base64URLString;
+ extensions?: AuthenticationExtensionsClientInputsJSON;
+ hints?: string[];
+ rpId?: string;
+ timeout?: number;
+ userVerification?: string;
+}
+
+interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
+ id?: string;
+}
+
+interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
+ displayName: string;
+ id: BufferSource;
+}
+
+interface PublicKeyCredentialUserEntityJSON {
+ displayName: string;
+ id: Base64URLString;
+ name: string;
+}
+
+interface PushSubscriptionInit {
+ appServerKey?: BufferSource | null;
+ authSecret?: ArrayBuffer | null;
+ endpoint: string;
+ expirationTime?: EpochTimeStamp | null;
+ p256dhKey?: ArrayBuffer | null;
+ scope: string;
+}
+
+interface PushSubscriptionJSON {
+ endpoint?: string;
+ expirationTime?: EpochTimeStamp | null;
+ keys?: PushSubscriptionKeys;
+}
+
+interface PushSubscriptionKeys {
+ auth?: string;
+ p256dh?: string;
+}
+
+interface PushSubscriptionOptionsInit {
+ applicationServerKey?: BufferSource | string | null;
+}
+
+interface QueuingStrategy {
+ highWaterMark?: number;
+ size?: QueuingStrategySize;
+}
+
+interface QueuingStrategyInit {
+ highWaterMark: number;
+}
+
+interface RTCBandwidthEstimationInternal {
+ maxPaddingBps?: number;
+ pacerDelayMs?: number;
+ receiveBandwidthBps?: number;
+ rttMs?: number;
+ sendBandwidthBps?: number;
+ trackIdentifier: string;
+}
+
+interface RTCCodecStats extends RTCStats {
+ channels?: number;
+ clockRate?: number;
+ codecType?: RTCCodecType;
+ mimeType: string;
+ payloadType: number;
+ sdpFmtpLine?: string;
+ transportId: string;
+}
+
+interface RTCConfiguration {
+ bundlePolicy?: RTCBundlePolicy;
+ certificates?: RTCCertificate[];
+ iceServers?: RTCIceServer[];
+ iceTransportPolicy?: RTCIceTransportPolicy;
+ peerIdentity?: string | null;
+ sdpSemantics?: string;
+}
+
+interface RTCConfigurationInternal {
+ bundlePolicy?: RTCBundlePolicy;
+ certificatesProvided: boolean;
+ iceServers?: RTCIceServerInternal[];
+ iceTransportPolicy?: RTCIceTransportPolicy;
+ peerIdentityProvided: boolean;
+ sdpSemantics?: string;
+}
+
+interface RTCDTMFToneChangeEventInit extends EventInit {
+ tone?: string;
+}
+
+interface RTCDataChannelEventInit extends EventInit {
+ channel: RTCDataChannel;
+}
+
+interface RTCDataChannelInit {
+ id?: number;
+ maxPacketLifeTime?: number;
+ maxRetransmitTime?: number;
+ maxRetransmits?: number;
+ negotiated?: boolean;
+ ordered?: boolean;
+ protocol?: string;
+}
+
+interface RTCDataChannelStats extends RTCStats {
+ bytesReceived?: number;
+ bytesSent?: number;
+ dataChannelIdentifier?: number;
+ label?: string;
+ messagesReceived?: number;
+ messagesSent?: number;
+ protocol?: string;
+ state?: RTCDataChannelState;
+}
+
+interface RTCDtlsFingerprint {
+ algorithm?: string;
+ value?: string;
+}
+
+interface RTCEncodedAudioFrameMetadata {
+ contributingSources?: number[];
+ payloadType?: number;
+ sequenceNumber?: number;
+ synchronizationSource?: number;
+}
+
+interface RTCEncodedVideoFrameMetadata {
+ contributingSources?: number[];
+ dependencies?: number[];
+ frameId?: number;
+ height?: number;
+ payloadType?: number;
+ spatialIndex?: number;
+ synchronizationSource?: number;
+ temporalIndex?: number;
+ timestamp?: number;
+ width?: number;
+}
+
+interface RTCIceCandidateInit {
+ candidate?: string;
+ sdpMLineIndex?: number | null;
+ sdpMid?: string | null;
+ usernameFragment?: string | null;
+}
+
+interface RTCIceCandidatePairStats extends RTCStats {
+ bytesReceived?: number;
+ bytesSent?: number;
+ componentId?: number;
+ lastPacketReceivedTimestamp?: DOMHighResTimeStamp;
+ lastPacketSentTimestamp?: DOMHighResTimeStamp;
+ localCandidateId?: string;
+ nominated?: boolean;
+ priority?: number;
+ readable?: boolean;
+ remoteCandidateId?: string;
+ selected?: boolean;
+ state?: RTCStatsIceCandidatePairState;
+ transportId?: string;
+ writable?: boolean;
+}
+
+interface RTCIceCandidateStats extends RTCStats {
+ address?: string;
+ candidateType?: RTCIceCandidateType;
+ port?: number;
+ priority?: number;
+ protocol?: string;
+ proxied?: string;
+ relayProtocol?: string;
+ transportId?: string;
+}
+
+interface RTCIceServer {
+ credential?: string;
+ credentialType?: RTCIceCredentialType;
+ url?: string;
+ urls?: string | string[];
+ username?: string;
+}
+
+interface RTCIceServerInternal {
+ credentialProvided: boolean;
+ urls?: string[];
+ userNameProvided: boolean;
+}
+
+interface RTCIdentityAssertion {
+ idp?: string;
+ name?: string;
+}
+
+interface RTCIdentityAssertionResult {
+ assertion: string;
+ idp: RTCIdentityProviderDetails;
+}
+
+interface RTCIdentityProvider {
+ generateAssertion: GenerateAssertionCallback;
+ validateAssertion: ValidateAssertionCallback;
+}
+
+interface RTCIdentityProviderDetails {
+ domain: string;
+ protocol?: string;
+}
+
+interface RTCIdentityProviderOptions {
+ peerIdentity?: string;
+ protocol?: string;
+ usernameHint?: string;
+}
+
+interface RTCIdentityValidationResult {
+ contents: string;
+ identity: string;
+}
+
+interface RTCInboundRtpStreamStats extends RTCReceivedRtpStreamStats {
+ audioLevel?: number;
+ bytesReceived?: number;
+ concealedSamples?: number;
+ concealmentEvents?: number;
+ fecPacketsDiscarded?: number;
+ fecPacketsReceived?: number;
+ firCount?: number;
+ frameHeight?: number;
+ frameWidth?: number;
+ framesDecoded?: number;
+ framesDropped?: number;
+ framesPerSecond?: number;
+ framesReceived?: number;
+ headerBytesReceived?: number;
+ insertedSamplesForDeceleration?: number;
+ jitterBufferDelay?: number;
+ jitterBufferEmittedCount?: number;
+ lastPacketReceivedTimestamp?: DOMHighResTimeStamp;
+ mid?: string;
+ nackCount?: number;
+ pliCount?: number;
+ qpSum?: number;
+ remoteId?: string;
+ removedSamplesForAcceleration?: number;
+ silentConcealedSamples?: number;
+ totalAudioEnergy?: number;
+ totalDecodeTime?: number;
+ totalInterFrameDelay?: number;
+ totalProcessingDelay?: number;
+ totalSamplesDuration?: number;
+ totalSamplesReceived?: number;
+ totalSquaredInterFrameDelay?: number;
+ trackIdentifier: string;
+}
+
+interface RTCLocalSessionDescriptionInit {
+ sdp?: string;
+ type?: RTCSdpType;
+}
+
+interface RTCMediaSourceStats extends RTCStats {
+ kind: string;
+ trackIdentifier: string;
+}
+
+interface RTCOfferAnswerOptions {}
+
+interface RTCOfferOptions extends RTCOfferAnswerOptions {
+ iceRestart?: boolean;
+ offerToReceiveAudio?: boolean;
+ offerToReceiveVideo?: boolean;
+}
+
+interface RTCOutboundRtpStreamStats extends RTCSentRtpStreamStats {
+ firCount?: number;
+ frameHeight?: number;
+ frameWidth?: number;
+ framesEncoded?: number;
+ framesPerSecond?: number;
+ framesSent?: number;
+ headerBytesSent?: number;
+ hugeFramesSent?: number;
+ mid?: string;
+ nackCount?: number;
+ pliCount?: number;
+ qpSum?: number;
+ remoteId?: string;
+ retransmittedBytesSent?: number;
+ retransmittedPacketsSent?: number;
+ rid?: string;
+ totalEncodeTime?: number;
+ totalEncodedBytesTarget?: number;
+}
+
+interface RTCPeerConnectionIceEventInit extends EventInit {
+ candidate?: RTCIceCandidate | null;
+}
+
+interface RTCPeerConnectionStats extends RTCStats {
+ dataChannelsClosed?: number;
+ dataChannelsOpened?: number;
+}
+
+interface RTCRTPContributingSourceStats extends RTCStats {
+ contributorSsrc?: number;
+ inboundRtpStreamId?: string;
+}
+
+interface RTCReceivedRtpStreamStats extends RTCRtpStreamStats {
+ discardedPackets?: number;
+ jitter?: number;
+ packetsDiscarded?: number;
+ packetsLost?: number;
+ packetsReceived?: number;
+}
+
+interface RTCRemoteInboundRtpStreamStats extends RTCReceivedRtpStreamStats {
+ fractionLost?: number;
+ localId?: string;
+ roundTripTime?: number;
+ roundTripTimeMeasurements?: number;
+ totalRoundTripTime?: number;
+}
+
+interface RTCRemoteOutboundRtpStreamStats extends RTCSentRtpStreamStats {
+ localId?: string;
+ remoteTimestamp?: DOMHighResTimeStamp;
+}
+
+interface RTCRtcpParameters {
+ cname?: string;
+ reducedSize?: boolean;
+}
+
+interface RTCRtpCapabilities {
+ codecs: RTCRtpCodec[];
+ headerExtensions: RTCRtpHeaderExtensionCapability[];
+}
+
+interface RTCRtpCodec {
+ channels?: number;
+ clockRate: number;
+ mimeType: string;
+ sdpFmtpLine?: string;
+}
+
+interface RTCRtpCodecParameters extends RTCRtpCodec {
+ payloadType: number;
+}
+
+interface RTCRtpContributingSource {
+ audioLevel?: number;
+ rtpTimestamp: number;
+ source: number;
+ timestamp: DOMHighResTimeStamp;
+}
+
+interface RTCRtpEncodingParameters {
+ active?: boolean;
+ maxBitrate?: number;
+ maxFramerate?: number;
+ priority?: RTCPriorityType;
+ rid?: string;
+ scaleResolutionDownBy?: number;
+}
+
+interface RTCRtpHeaderExtensionCapability {
+ uri: string;
+}
+
+interface RTCRtpHeaderExtensionParameters {
+ encrypted?: boolean;
+ id?: number;
+ uri?: string;
+}
+
+interface RTCRtpParameters {
+ codecs?: RTCRtpCodecParameters[];
+ headerExtensions?: RTCRtpHeaderExtensionParameters[];
+ rtcp?: RTCRtcpParameters;
+}
+
+interface RTCRtpReceiveParameters extends RTCRtpParameters {}
+
+interface RTCRtpSendParameters extends RTCRtpParameters {
+ degradationPreference?: RTCDegradationPreference;
+ encodings: RTCRtpEncodingParameters[];
+ transactionId?: string;
+}
+
+interface RTCRtpStreamStats extends RTCStats {
+ codecId?: string;
+ kind: string;
+ mediaType?: string;
+ ssrc: number;
+ transportId?: string;
+}
+
+interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
+ voiceActivityFlag?: boolean | null;
+}
+
+interface RTCRtpTransceiverInit {
+ direction?: RTCRtpTransceiverDirection;
+ sendEncodings?: RTCRtpEncodingParameters[];
+ streams?: MediaStream[];
+}
+
+interface RTCSdpHistoryEntryInternal {
+ errors?: RTCSdpParsingErrorInternal[];
+ isLocal: boolean;
+ sdp: string;
+ timestamp: DOMHighResTimeStamp;
+}
+
+interface RTCSdpHistoryInternal {
+ pcid: string;
+ sdpHistory?: RTCSdpHistoryEntryInternal[];
+}
+
+interface RTCSdpParsingErrorInternal {
+ error: string;
+ lineNumber: number;
+}
+
+interface RTCSentRtpStreamStats extends RTCRtpStreamStats {
+ bytesSent?: number;
+ packetsSent?: number;
+}
+
+interface RTCSessionDescriptionInit {
+ sdp?: string;
+ type: RTCSdpType;
+}
+
+interface RTCStats {
+ id?: string;
+ timestamp?: DOMHighResTimeStamp;
+ type?: RTCStatsType;
+}
+
+interface RTCStatsCollection {
+ bandwidthEstimations?: RTCBandwidthEstimationInternal[];
+ codecStats?: RTCCodecStats[];
+ dataChannelStats?: RTCDataChannelStats[];
+ iceCandidatePairStats?: RTCIceCandidatePairStats[];
+ iceCandidateStats?: RTCIceCandidateStats[];
+ inboundRtpStreamStats?: RTCInboundRtpStreamStats[];
+ mediaSourceStats?: RTCMediaSourceStats[];
+ outboundRtpStreamStats?: RTCOutboundRtpStreamStats[];
+ peerConnectionStats?: RTCPeerConnectionStats[];
+ rawLocalCandidates?: string[];
+ rawRemoteCandidates?: string[];
+ remoteInboundRtpStreamStats?: RTCRemoteInboundRtpStreamStats[];
+ remoteOutboundRtpStreamStats?: RTCRemoteOutboundRtpStreamStats[];
+ rtpContributingSourceStats?: RTCRTPContributingSourceStats[];
+ trickledIceCandidateStats?: RTCIceCandidateStats[];
+ videoFrameHistories?: RTCVideoFrameHistoryInternal[];
+ videoSourceStats?: RTCVideoSourceStats[];
+}
+
+interface RTCStatsReportInternal extends RTCStatsCollection {
+ browserId: number;
+ callDurationMs?: number;
+ closed: boolean;
+ configuration?: RTCConfigurationInternal;
+ iceRestarts: number;
+ iceRollbacks: number;
+ jsepSessionErrors?: string;
+ offerer?: boolean;
+ pcid: string;
+ sdpHistory?: RTCSdpHistoryEntryInternal[];
+ timestamp: DOMHighResTimeStamp;
+}
+
+interface RTCTrackEventInit extends EventInit {
+ receiver: RTCRtpReceiver;
+ streams?: MediaStream[];
+ track: MediaStreamTrack;
+ transceiver: RTCRtpTransceiver;
+}
+
+interface RTCVideoFrameHistoryEntryInternal {
+ consecutiveFrames: number;
+ firstFrameTimestamp: DOMHighResTimeStamp;
+ height: number;
+ lastFrameTimestamp: DOMHighResTimeStamp;
+ localSsrc: number;
+ remoteSsrc: number;
+ rotationAngle: number;
+ width: number;
+}
+
+interface RTCVideoFrameHistoryInternal {
+ entries?: RTCVideoFrameHistoryEntryInternal[];
+ trackIdentifier: string;
+}
+
+interface RTCVideoSourceStats extends RTCMediaSourceStats {
+ frames?: number;
+ framesPerSecond?: number;
+ height?: number;
+ width?: number;
+}
+
+interface ReadOptions extends ReadUTF8Options {
+ maxBytes?: number | null;
+ offset?: number;
+}
+
+interface ReadUTF8Options {
+ decompress?: boolean;
+}
+
+interface ReadableStreamBYOBReaderReadOptions {
+ min?: number;
+}
+
+interface ReadableStreamGetReaderOptions {
+ mode?: ReadableStreamReaderMode;
+}
+
+interface ReadableStreamIteratorOptions {
+ preventCancel?: boolean;
+}
+
+interface ReadableStreamReadResult {
+ done?: boolean;
+ value?: any;
+}
+
+interface ReadableWritablePair {
+ readable: ReadableStream;
+ writable: WritableStream;
+}
+
+interface ReceiveMessageArgument {
+ data?: any;
+ json?: any;
+ name: string;
+ ports?: MessagePort[];
+ sync: boolean;
+ target: nsISupports;
+ targetFrameLoader?: FrameLoader;
+}
+
+interface RegistrationOptions {
+ scope?: string;
+ updateViaCache?: ServiceWorkerUpdateViaCache;
+}
+
+interface RemotenessOptions {
+ pendingSwitchID?: number;
+ remoteType: string | null;
+ switchingInProgressLoad?: boolean;
+}
+
+interface RemoveOptions {
+ ignoreAbsent?: boolean;
+ recursive?: boolean;
+ retryReadonly?: boolean;
+}
+
+interface ReportingObserverOptions {
+ buffered?: boolean;
+ types?: string[];
+}
+
+interface RequestInit {
+ body?: BodyInit | null;
+ cache?: RequestCache;
+ credentials?: RequestCredentials;
+ headers?: HeadersInit;
+ integrity?: string;
+ keepalive?: boolean;
+ method?: string;
+ mode?: RequestMode;
+ mozErrors?: boolean;
+ neverTaint?: boolean;
+ observe?: ObserverCallback;
+ priority?: RequestPriority;
+ redirect?: RequestRedirect;
+ referrer?: string;
+ referrerPolicy?: ReferrerPolicy;
+ signal?: AbortSignal | null;
+ triggeringPrincipal?: Principal;
+}
+
+interface ResizeObserverOptions {
+ box?: ResizeObserverBoxOptions;
+}
+
+interface ResourceId {
+ optional?: boolean;
+ path: string;
+}
+
+interface ResponseInit {
+ headers?: HeadersInit;
+ status?: number;
+ statusText?: string;
+}
+
+interface SVGBoundingBoxOptions {
+ clipped?: boolean;
+ fill?: boolean;
+ markers?: boolean;
+ stroke?: boolean;
+}
+
+interface SVGPathDataSettings {
+ normalize?: boolean;
+}
+
+interface SanitizerAttributeNamespace {
+ name: string;
+ namespace?: string | null;
+}
+
+interface SanitizerConfig {
+ attributes?: SanitizerAttribute[];
+ comments?: boolean;
+ dataAttributes?: boolean;
+ elements?: SanitizerElementWithAttributes[];
+ removeAttributes?: SanitizerAttribute[];
+ removeElements?: SanitizerElement[];
+ replaceWithChildrenElements?: SanitizerElement[];
+}
+
+interface SanitizerElementNamespace {
+ name: string;
+ namespace?: string | null;
+}
+
+interface SanitizerElementNamespaceWithAttributes extends SanitizerElementNamespace {
+ attributes?: SanitizerAttribute[];
+ removeAttributes?: SanitizerAttribute[];
+}
+
+interface SchedulerPostTaskOptions {
+ delay?: number;
+ priority?: TaskPriority;
+ signal?: AbortSignal;
+}
+
+interface ScrollIntoViewOptions extends ScrollOptions {
+ block?: ScrollLogicalPosition;
+ inline?: ScrollLogicalPosition;
+}
+
+interface ScrollOptions {
+ behavior?: ScrollBehavior;
+}
+
+interface ScrollToOptions extends ScrollOptions {
+ left?: number;
+ top?: number;
+}
+
+interface ScrollViewChangeEventInit extends EventInit {
+ state?: ScrollState;
+}
+
+interface SecurityPolicyViolationEventInit extends EventInit {
+ blockedURI?: string;
+ columnNumber?: number;
+ disposition?: SecurityPolicyViolationEventDisposition;
+ documentURI?: string;
+ effectiveDirective?: string;
+ lineNumber?: number;
+ originalPolicy?: string;
+ referrer?: string;
+ sample?: string;
+ sourceFile?: string;
+ statusCode?: number;
+ violatedDirective?: string;
+}
+
+interface SelectorWarning {
+ index: number;
+ kind: SelectorWarningKind;
+}
+
+interface ServerSocketOptions {
+ binaryType?: TCPSocketBinaryType;
+}
+
+interface SetHTMLOptions {
+ sanitizer?: Sanitizer | SanitizerConfig | SanitizerPresets;
+}
+
+interface ShadowRootInit {
+ clonable?: boolean;
+ delegatesFocus?: boolean;
+ mode: ShadowRootMode;
+ serializable?: boolean;
+ slotAssignment?: SlotAssignmentMode;
+}
+
+interface ShareData {
+ files?: File[];
+ text?: string;
+ title?: string;
+ url?: string;
+}
+
+interface SizeToContentConstraints {
+ maxHeight?: number;
+ maxWidth?: number;
+ prefWidth?: number;
+}
+
+interface SocketOptions {
+ binaryType?: TCPSocketBinaryType;
+ useSecureTransport?: boolean;
+}
+
+interface SpeechRecognitionErrorInit extends EventInit {
+ error?: SpeechRecognitionErrorCode;
+ message?: string;
+}
+
+interface SpeechRecognitionEventInit extends EventInit {
+ emma?: Document | null;
+ interpretation?: any;
+ resultIndex?: number;
+ results?: SpeechRecognitionResultList | null;
+}
+
+interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
+ error: SpeechSynthesisErrorCode;
+}
+
+interface SpeechSynthesisEventInit extends EventInit {
+ charIndex?: number;
+ charLength?: number | null;
+ elapsedTime?: number;
+ name?: string;
+ utterance: SpeechSynthesisUtterance;
+}
+
+interface SplitRelativeOptions {
+ allowCurrentDir?: boolean;
+ allowEmpty?: boolean;
+ allowParentDir?: boolean;
+}
+
+interface StaticRangeInit {
+ endContainer: Node;
+ endOffset: number;
+ startContainer: Node;
+ startOffset: number;
+}
+
+interface StereoPannerOptions extends AudioNodeOptions {
+ pan?: number;
+}
+
+interface StorageEstimate {
+ quota?: number;
+ usage?: number;
+}
+
+interface StorageEventInit extends EventInit {
+ key?: string | null;
+ newValue?: string | null;
+ oldValue?: string | null;
+ storageArea?: Storage | null;
+ url?: string;
+}
+
+interface StreamFilterDataEventInit extends EventInit {
+ data: ArrayBuffer;
+}
+
+interface StreamPipeOptions {
+ preventAbort?: boolean;
+ preventCancel?: boolean;
+ preventClose?: boolean;
+ signal?: AbortSignal;
+}
+
+interface StructuredSerializeOptions {
+ transfer?: any[];
+}
+
+interface StyleSheetApplicableStateChangeEventInit extends EventInit {
+ applicable?: boolean;
+ stylesheet?: CSSStyleSheet | null;
+}
+
+interface StyleSheetRemovedEventInit extends EventInit {
+ stylesheet?: CSSStyleSheet | null;
+}
+
+interface SubmitEventInit extends EventInit {
+ submitter?: HTMLElement | null;
+}
+
+interface SupportsOptions {
+ chrome?: boolean;
+ quirks?: boolean;
+ userAgent?: boolean;
+}
+
+interface SvcOutputMetadata {
+ temporalLayerId?: number;
+}
+
+interface TCPServerSocketEventInit extends EventInit {
+ socket?: TCPSocket | null;
+}
+
+interface TCPSocketErrorEventInit extends EventInit {
+ errorCode?: number;
+ message?: string;
+ name?: string;
+}
+
+interface TCPSocketEventInit extends EventInit {
+ data?: any;
+}
+
+interface TaskControllerInit {
+ priority?: TaskPriority;
+}
+
+interface TaskPriorityChangeEventInit extends EventInit {
+ previousPriority: TaskPriority;
+}
+
+interface TestInterfaceAsyncIterableSingleOptions {
+ failToInit?: boolean;
+}
+
+interface TestInterfaceAsyncIteratorOptions {
+ blockingPromises?: Promise[];
+ failNextAfter?: number;
+ multiplier?: number;
+ throwFromNext?: boolean;
+ throwFromReturn?: TestThrowingCallback;
+}
+
+interface TestInterfaceJSDictionary {
+ anyMember?: any;
+ anySequenceMember?: any[];
+ innerDictionary?: TestInterfaceJSDictionary2;
+ objectMember?: any;
+ objectOrStringMember?: any;
+ objectRecordMember?: Record;
+}
+
+interface TestInterfaceJSDictionary2 {
+ innerObject?: any;
+}
+
+interface TestInterfaceJSUnionableDictionary {
+ anyMember?: any;
+ objectMember?: any;
+}
+
+interface TextDecodeOptions {
+ stream?: boolean;
+}
+
+interface TextDecoderOptions {
+ fatal?: boolean;
+ ignoreBOM?: boolean;
+}
+
+interface TextEncoderEncodeIntoResult {
+ read?: number;
+ written?: number;
+}
+
+interface ThreadInfoDictionary {
+ cpuCycleCount?: number;
+ cpuTime?: number;
+ name?: string;
+ tid?: number;
+}
+
+interface ToggleEventInit extends EventInit {
+ newState?: string;
+ oldState?: string;
+}
+
+interface TouchEventInit extends EventModifierInit {
+ changedTouches?: Touch[];
+ targetTouches?: Touch[];
+ touches?: Touch[];
+}
+
+interface TouchInit {
+ clientX?: number;
+ clientY?: number;
+ force?: number;
+ identifier: number;
+ pageX?: number;
+ pageY?: number;
+ radiusX?: number;
+ radiusY?: number;
+ rotationAngle?: number;
+ screenX?: number;
+ screenY?: number;
+ target: EventTarget;
+}
+
+interface TrackBuffersManagerDebugInfo {
+ bufferSize?: number;
+ evictable?: number;
+ nextGetSampleIndex?: number;
+ nextInsertionIndex?: number;
+ nextSampleTime?: number;
+ numSamples?: number;
+ ranges?: BufferRange[];
+ type?: string;
+}
+
+interface TrackEventInit extends EventInit {
+ track?: VideoTrack | AudioTrack | TextTrack | null;
+}
+
+interface TransitionEventInit extends EventInit {
+ elapsedTime?: number;
+ propertyName?: string;
+ pseudoElement?: string;
+}
+
+interface TreeCellInfo {
+ childElt?: string;
+ col?: TreeColumn | null;
+ row?: number;
+}
+
+interface TrustedTypePolicyOptions {
+ createHTML?: CreateHTMLCallback;
+ createScript?: CreateScriptCallback;
+ createScriptURL?: CreateScriptURLCallback;
+}
+
+interface UDPMessageEventInit extends EventInit {
+ data?: any;
+ remoteAddress?: string;
+ remotePort?: number;
+}
+
+interface UDPOptions {
+ addressReuse?: boolean;
+ localAddress?: string;
+ localPort?: number;
+ loopback?: boolean;
+ remoteAddress?: string;
+ remotePort?: number;
+}
+
+interface UIEventInit extends EventInit {
+ detail?: number;
+ view?: Window | null;
+}
+
+interface ULongRange {
+ max?: number;
+ min?: number;
+}
+
+interface UniFFIScaffoldingCallResult {
+ code: UniFFIScaffoldingCallCode;
+ data?: UniFFIScaffoldingValue;
+}
+
+interface UserProximityEventInit extends EventInit {
+ near?: boolean;
+}
+
+interface UtilityActorsDictionary {
+ actorName?: WebIDLUtilityActorName;
+}
+
+interface VRDisplayEventInit extends EventInit {
+ display: VRDisplay;
+ reason?: VRDisplayEventReason;
+}
+
+interface VRLayer {
+ leftBounds?: number[] | Float32Array;
+ rightBounds?: number[] | Float32Array;
+ source?: HTMLCanvasElement | null;
+}
+
+interface ValidityStateFlags {
+ badInput?: boolean;
+ customError?: boolean;
+ patternMismatch?: boolean;
+ rangeOverflow?: boolean;
+ rangeUnderflow?: boolean;
+ stepMismatch?: boolean;
+ tooLong?: boolean;
+ tooShort?: boolean;
+ typeMismatch?: boolean;
+ valueMissing?: boolean;
+}
+
+interface VideoColorSpaceInit {
+ fullRange?: boolean | null;
+ matrix?: VideoMatrixCoefficients | null;
+ primaries?: VideoColorPrimaries | null;
+ transfer?: VideoTransferCharacteristics | null;
+}
+
+interface VideoConfiguration {
+ bitrate: number;
+ colorGamut?: ColorGamut;
+ contentType: string;
+ framerate: number;
+ hasAlphaChannel?: boolean;
+ hdrMetadataType?: HdrMetadataType;
+ height: number;
+ scalabilityMode?: string;
+ transferFunction?: TransferFunction;
+ width: number;
+}
+
+interface VideoDecoderConfig {
+ codec: string;
+ codedHeight?: number;
+ codedWidth?: number;
+ colorSpace?: VideoColorSpaceInit;
+ description?: ArrayBufferView | ArrayBuffer;
+ displayAspectHeight?: number;
+ displayAspectWidth?: number;
+ hardwareAcceleration?: HardwareAcceleration;
+ optimizeForLatency?: boolean;
+}
+
+interface VideoDecoderInit {
+ error: WebCodecsErrorCallback;
+ output: VideoFrameOutputCallback;
+}
+
+interface VideoDecoderSupport {
+ config?: VideoDecoderConfig;
+ supported?: boolean;
+}
+
+interface VideoEncoderConfig {
+ alpha?: AlphaOption;
+ avc?: AvcEncoderConfig;
+ bitrate?: number;
+ bitrateMode?: VideoEncoderBitrateMode;
+ codec: string;
+ contentHint?: string;
+ displayHeight?: number;
+ displayWidth?: number;
+ framerate?: number;
+ hardwareAcceleration?: HardwareAcceleration;
+ height: number;
+ latencyMode?: LatencyMode;
+ scalabilityMode?: string;
+ width: number;
+}
+
+interface VideoEncoderEncodeOptions {
+ avc?: VideoEncoderEncodeOptionsForAvc;
+ keyFrame?: boolean;
+}
+
+interface VideoEncoderEncodeOptionsForAvc {
+ quantizer?: number | null;
+}
+
+interface VideoEncoderInit {
+ error: WebCodecsErrorCallback;
+ output: EncodedVideoChunkOutputCallback;
+}
+
+interface VideoEncoderSupport {
+ config?: VideoEncoderConfig;
+ supported?: boolean;
+}
+
+interface VideoFrameBufferInit {
+ codedHeight: number;
+ codedWidth: number;
+ colorSpace?: VideoColorSpaceInit;
+ displayHeight?: number;
+ displayWidth?: number;
+ duration?: number;
+ format: VideoPixelFormat;
+ layout?: PlaneLayout[];
+ timestamp: number;
+ visibleRect?: DOMRectInit;
+}
+
+interface VideoFrameCallbackMetadata {
+ captureTime?: DOMHighResTimeStamp;
+ expectedDisplayTime: DOMHighResTimeStamp;
+ height: number;
+ mediaTime: number;
+ presentationTime: DOMHighResTimeStamp;
+ presentedFrames: number;
+ processingDuration?: number;
+ receiveTime?: DOMHighResTimeStamp;
+ rtpTimestamp?: number;
+ width: number;
+}
+
+interface VideoFrameCopyToOptions {
+ colorSpace?: PredefinedColorSpace;
+ format?: VideoPixelFormat;
+ layout?: PlaneLayout[];
+ rect?: DOMRectInit;
+}
+
+interface VideoFrameInit {
+ alpha?: AlphaOption;
+ displayHeight?: number;
+ displayWidth?: number;
+ duration?: number;
+ timestamp?: number;
+ visibleRect?: DOMRectInit;
+}
+
+interface VideoSinkDebugInfo {
+ endPromiseHolderIsEmpty?: boolean;
+ finished?: boolean;
+ hasVideo?: boolean;
+ isPlaying?: boolean;
+ isStarted?: boolean;
+ size?: number;
+ videoFrameEndTime?: number;
+ videoSinkEndRequestExists?: boolean;
+}
+
+interface WaveShaperOptions extends AudioNodeOptions {
+ curve?: number[] | Float32Array;
+ oversample?: OverSampleType;
+}
+
+interface WebAccessibleResourceInit {
+ extension_ids?: string[] | null;
+ matches?: MatchPatternSetOrStringSequence | null;
+ resources: MatchGlobOrString[];
+}
+
+interface WebExtensionContentScriptInit extends MozDocumentMatcherInit {
+ cssPaths?: string[];
+ jsPaths?: string[];
+ runAt?: ContentScriptRunAt;
+ world?: ContentScriptExecutionWorld;
+ worldId?: string | null;
+}
+
+interface WebExtensionInit {
+ allowedOrigins: MatchPatternSetOrStringSequence;
+ backgroundScripts?: string[] | null;
+ backgroundTypeModule?: boolean;
+ backgroundWorkerScript?: string | null;
+ baseURL: string;
+ contentScripts?: WebExtensionContentScriptInit[];
+ extensionPageCSP?: string | null;
+ id: string;
+ ignoreQuarantine?: boolean;
+ isPrivileged?: boolean;
+ localizeCallback: WebExtensionLocalizeCallback;
+ manifestVersion?: number;
+ mozExtensionHostname: string;
+ name?: string;
+ permissions?: string[];
+ readyPromise?: Promise;
+ temporarilyInstalled?: boolean;
+ type?: string;
+ webAccessibleResources?: WebAccessibleResourceInit[];
+}
+
+interface WebGLContextAttributes {
+ alpha?: GLboolean;
+ antialias?: GLboolean;
+ depth?: GLboolean;
+ failIfMajorPerformanceCaveat?: GLboolean;
+ forceSoftwareRendering?: GLboolean;
+ powerPreference?: WebGLPowerPreference;
+ premultipliedAlpha?: GLboolean;
+ preserveDrawingBuffer?: GLboolean;
+ stencil?: GLboolean;
+ xrCompatible?: boolean;
+}
+
+interface WebGLContextEventInit extends EventInit {
+ statusMessage?: string;
+}
+
+interface WebTransportCloseInfo {
+ closeCode?: number;
+ reason?: string;
+}
+
+interface WebTransportDatagramStats {
+ droppedIncoming?: number;
+ expiredOutgoing?: number;
+ lostOutgoing?: number;
+ timestamp?: DOMHighResTimeStamp;
+}
+
+interface WebTransportErrorInit {
+ message?: string;
+ streamErrorCode?: number;
+}
+
+interface WebTransportHash {
+ algorithm?: string;
+ value?: BufferSource;
+}
+
+interface WebTransportOptions {
+ allowPooling?: boolean;
+ congestionControl?: WebTransportCongestionControl;
+ requireUnreliable?: boolean;
+ serverCertificateHashes?: WebTransportHash[];
+}
+
+interface WebTransportReceiveStreamStats {
+ bytesRead?: number;
+ bytesReceived?: number;
+ timestamp?: DOMHighResTimeStamp;
+}
+
+interface WebTransportSendStreamOptions {
+ sendOrder?: number | null;
+}
+
+interface WebTransportSendStreamStats {
+ bytesAcknowledged?: number;
+ bytesSent?: number;
+ bytesWritten?: number;
+ timestamp?: DOMHighResTimeStamp;
+}
+
+interface WebTransportStats {
+ bytesReceived?: number;
+ bytesSent?: number;
+ datagrams?: WebTransportDatagramStats;
+ minRtt?: DOMHighResTimeStamp;
+ numIncomingStreamsCreated?: number;
+ numOutgoingStreamsCreated?: number;
+ packetsLost?: number;
+ packetsReceived?: number;
+ packetsSent?: number;
+ rttVariation?: DOMHighResTimeStamp;
+ smoothedRtt?: DOMHighResTimeStamp;
+ timestamp?: DOMHighResTimeStamp;
+}
+
+interface WebrtcGlobalMediaContext {
+ hasAv1: boolean;
+ hasH264Hardware: boolean;
+}
+
+interface WebrtcGlobalStatisticsReport {
+ reports?: RTCStatsReportInternal[];
+ sdpHistories?: RTCSdpHistoryInternal[];
+}
+
+interface WheelEventInit extends MouseEventInit {
+ deltaMode?: number;
+ deltaX?: number;
+ deltaY?: number;
+ deltaZ?: number;
+}
+
+interface WindowActorChildOptions extends WindowActorSidedOptions {
+ events?: Record;
+ observers?: string[];
+}
+
+interface WindowActorEventListenerOptions extends AddEventListenerOptions {
+ createActor?: boolean;
+}
+
+interface WindowActorOptions {
+ allFrames?: boolean;
+ child?: WindowActorChildOptions;
+ includeChrome?: boolean;
+ matches?: string[];
+ messageManagerGroups?: string[];
+ parent?: WindowActorSidedOptions;
+ remoteTypes?: string[];
+}
+
+interface WindowActorSidedOptions {
+ esModuleURI?: string;
+}
+
+interface WindowInfoDictionary {
+ documentTitle?: string;
+ documentURI?: URI | null;
+ isInProcess?: boolean;
+ isProcessRoot?: boolean;
+ outerWindowId?: number;
+}
+
+interface WindowPostMessageOptions extends StructuredSerializeOptions {
+ targetOrigin?: string;
+}
+
+interface WindowsFileAttributes {
+ hidden?: boolean;
+ readOnly?: boolean;
+ system?: boolean;
+}
+
+interface Wireframe {
+ canvasBackground?: number;
+ rects?: WireframeTaggedRect[];
+ version?: number;
+}
+
+interface WireframeTaggedRect {
+ color?: number;
+ height?: number;
+ node?: Node | null;
+ type?: WireframeRectType;
+ width?: number;
+ x?: number;
+ y?: number;
+}
+
+interface WorkerOptions {
+ credentials?: RequestCredentials;
+ name?: string;
+ type?: WorkerType;
+}
+
+interface WorkletOptions {
+ credentials?: RequestCredentials;
+}
+
+interface WriteOptions {
+ backupFile?: string;
+ compress?: boolean;
+ flush?: boolean;
+ mode?: WriteMode;
+ tmpPath?: string;
+}
+
+interface WriteParams {
+ data?: BufferSource | Blob | string | null;
+ position?: number | null;
+ size?: number | null;
+ type: WriteCommandType;
+}
+
+interface XRInputSourceEventInit extends EventInit {
+ frame: XRFrame;
+ inputSource: XRInputSource;
+}
+
+interface XRInputSourcesChangeEventInit extends EventInit {
+ added: XRInputSource[];
+ removed: XRInputSource[];
+ session: XRSession;
+}
+
+interface XRReferenceSpaceEventInit extends EventInit {
+ referenceSpace: XRReferenceSpace;
+ transform?: XRRigidTransform | null;
+}
+
+interface XRRenderStateInit {
+ baseLayer?: XRWebGLLayer | null;
+ depthFar?: number;
+ depthNear?: number;
+ inlineVerticalFieldOfView?: number;
+}
+
+interface XRSessionEventInit extends EventInit {
+ session: XRSession;
+}
+
+interface XRSessionInit {
+ optionalFeatures?: string[];
+ requiredFeatures?: string[];
+}
+
+interface XRWebGLLayerInit {
+ alpha?: boolean;
+ antialias?: boolean;
+ depth?: boolean;
+ framebufferScaleFactor?: number;
+ ignoreDepthValues?: boolean;
+ stencil?: boolean;
+}
+
+interface addonInstallOptions {
+ hash?: string | null;
+ url: string;
+}
+
+interface sendAbuseReportOptions {
+ authorization?: string | null;
+}
+
+type EventListener = ((event: Event) => void) | { handleEvent(event: Event): void };
+
+type MessageListener = ((argument: ReceiveMessageArgument) => any) | { receiveMessage(argument: ReceiveMessageArgument): any };
+
+type MozDocumentCallback =
+ | ((matcher: MozDocumentMatcher, window: WindowProxy) => void)
+ | { onNewDocument(matcher: MozDocumentMatcher, window: WindowProxy): void };
+
+type NodeFilter = ((node: Node) => number) | { acceptNode(node: Node): number };
+
+declare var NodeFilter: {
+ readonly FILTER_ACCEPT: 1;
+ readonly FILTER_REJECT: 2;
+ readonly FILTER_SKIP: 3;
+ readonly SHOW_ALL: 0xffffffff;
+ readonly SHOW_ELEMENT: 0x1;
+ readonly SHOW_ATTRIBUTE: 0x2;
+ readonly SHOW_TEXT: 0x4;
+ readonly SHOW_CDATA_SECTION: 0x8;
+ readonly SHOW_ENTITY_REFERENCE: 0x10;
+ readonly SHOW_ENTITY: 0x20;
+ readonly SHOW_PROCESSING_INSTRUCTION: 0x40;
+ readonly SHOW_COMMENT: 0x80;
+ readonly SHOW_DOCUMENT: 0x100;
+ readonly SHOW_DOCUMENT_TYPE: 0x200;
+ readonly SHOW_DOCUMENT_FRAGMENT: 0x400;
+ readonly SHOW_NOTATION: 0x800;
+};
+
+type ObserverCallback = ((observer: FetchObserver) => void) | { handleEvent(observer: FetchObserver): void };
+
+type UncaughtRejectionObserver = ((p: any) => boolean) | { onLeftUncaught(p: any): boolean };
+
+type UniFFICallbackHandler =
+ | ((
+ objectHandle: UniFFICallbackObjectHandle,
+ methodIndex: number,
+ ...args: UniFFIScaffoldingValue[]
+ ) => UniFFIScaffoldingValue | null)
+ | {
+ call(
+ objectHandle: UniFFICallbackObjectHandle,
+ methodIndex: number,
+ ...args: UniFFIScaffoldingValue[]
+ ): UniFFIScaffoldingValue | null;
+ };
+
+type XPathNSResolver =
+ | ((prefix: string | null) => string | null)
+ | { lookupNamespaceURI(prefix: string | null): string | null };
+
+interface ANGLE_instanced_arrays {
+ drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
+ drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
+ vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
+ readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88fe;
+}
+
+interface ARIAMixin {
+ ariaActiveDescendantElement: Element | null;
+ ariaAtomic: string | null;
+ ariaAutoComplete: string | null;
+ ariaBrailleLabel: string | null;
+ ariaBrailleRoleDescription: string | null;
+ ariaBusy: string | null;
+ ariaChecked: string | null;
+ ariaColCount: string | null;
+ ariaColIndex: string | null;
+ ariaColIndexText: string | null;
+ ariaColSpan: string | null;
+ ariaControlsElements: Element[] | null;
+ ariaCurrent: string | null;
+ ariaDescribedByElements: Element[] | null;
+ ariaDescription: string | null;
+ ariaDetailsElements: Element[] | null;
+ ariaDisabled: string | null;
+ ariaErrorMessageElements: Element[] | null;
+ ariaExpanded: string | null;
+ ariaFlowToElements: Element[] | null;
+ ariaHasPopup: string | null;
+ ariaHidden: string | null;
+ ariaInvalid: string | null;
+ ariaKeyShortcuts: string | null;
+ ariaLabel: string | null;
+ ariaLabelledByElements: Element[] | null;
+ ariaLevel: string | null;
+ ariaLive: string | null;
+ ariaModal: string | null;
+ ariaMultiLine: string | null;
+ ariaMultiSelectable: string | null;
+ ariaOrientation: string | null;
+ ariaOwnsElements: Element[] | null;
+ ariaPlaceholder: string | null;
+ ariaPosInSet: string | null;
+ ariaPressed: string | null;
+ ariaReadOnly: string | null;
+ ariaRelevant: string | null;
+ ariaRequired: string | null;
+ ariaRoleDescription: string | null;
+ ariaRowCount: string | null;
+ ariaRowIndex: string | null;
+ ariaRowIndexText: string | null;
+ ariaRowSpan: string | null;
+ ariaSelected: string | null;
+ ariaSetSize: string | null;
+ ariaSort: string | null;
+ ariaValueMax: string | null;
+ ariaValueMin: string | null;
+ ariaValueNow: string | null;
+ ariaValueText: string | null;
+ role: string | null;
+}
+
+interface AbortController {
+ readonly signal: AbortSignal;
+ abort(reason?: any): void;
+}
+
+declare var AbortController: {
+ prototype: AbortController;
+ new (): AbortController;
+ isInstance: IsInstance;
+};
+
+interface AbortSignalEventMap {
+ abort: Event;
+}
+
+interface AbortSignal extends EventTarget {
+ readonly aborted: boolean;
+ onabort: ((this: AbortSignal, ev: Event) => any) | null;
+ readonly reason: any;
+ throwIfAborted(): void;
+ addEventListener(
+ type: K,
+ listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var AbortSignal: {
+ prototype: AbortSignal;
+ new (): AbortSignal;
+ isInstance: IsInstance;
+ abort(reason?: any): AbortSignal;
+ any(signals: AbortSignal[]): AbortSignal;
+ timeout(milliseconds: number): AbortSignal;
+};
+
+interface AbstractRange {
+ readonly collapsed: boolean;
+ readonly endContainer: Node;
+ readonly endOffset: number;
+ readonly startContainer: Node;
+ readonly startOffset: number;
+}
+
+declare var AbstractRange: {
+ prototype: AbstractRange;
+ new (): AbstractRange;
+ isInstance: IsInstance;
+};
+
+interface AbstractWorkerEventMap {
+ error: Event;
+}
+
+interface AbstractWorker {
+ onerror: ((this: AbstractWorker, ev: Event) => any) | null;
+ addEventListener(
+ type: K,
+ listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+interface AccessibleNode {
+ readonly DOMNode: Node | null;
+ activeDescendant: AccessibleNode | null;
+ atomic: boolean | null;
+ readonly attributes: string[];
+ autocomplete: string | null;
+ busy: boolean | null;
+ checked: string | null;
+ colCount: number | null;
+ colIndex: number | null;
+ colSpan: number | null;
+ readonly computedRole: string;
+ current: string | null;
+ details: AccessibleNode | null;
+ disabled: boolean | null;
+ errorMessage: AccessibleNode | null;
+ expanded: boolean | null;
+ hasPopUp: string | null;
+ hidden: boolean | null;
+ invalid: string | null;
+ keyShortcuts: string | null;
+ label: string | null;
+ level: number | null;
+ live: string | null;
+ modal: boolean | null;
+ multiline: boolean | null;
+ multiselectable: boolean | null;
+ orientation: string | null;
+ placeholder: string | null;
+ posInSet: number | null;
+ pressed: string | null;
+ readOnly: boolean | null;
+ relevant: string | null;
+ required: boolean | null;
+ role: string | null;
+ roleDescription: string | null;
+ rowCount: number | null;
+ rowIndex: number | null;
+ rowSpan: number | null;
+ selected: boolean | null;
+ setSize: number | null;
+ sort: string | null;
+ readonly states: string[];
+ valueMax: number | null;
+ valueMin: number | null;
+ valueNow: number | null;
+ valueText: string | null;
+ get(attribute: string): any;
+ has(...attributes: string[]): boolean;
+ is(...states: string[]): boolean;
+}
+
+declare var AccessibleNode: {
+ prototype: AccessibleNode;
+ new (): AccessibleNode;
+ isInstance: IsInstance;
+};
+
+interface Addon {
+ readonly canUninstall: boolean;
+ readonly description: string;
+ readonly id: string;
+ readonly isActive: boolean;
+ readonly isEnabled: boolean;
+ readonly name: string;
+ readonly type: string;
+ readonly version: string;
+ setEnabled(value: boolean): Promise;
+ uninstall(): Promise;
+}
+
+declare var Addon: {
+ prototype: Addon;
+ new (): Addon;
+ isInstance: IsInstance;
+};
+
+interface AddonEvent extends Event {
+ readonly id: string;
+}
+
+declare var AddonEvent: {
+ prototype: AddonEvent;
+ new (type: string, eventInitDict: AddonEventInit): AddonEvent;
+ isInstance: IsInstance;
+};
+
+interface AddonInstall extends EventTarget {
+ readonly error: string | null;
+ readonly maxProgress: number;
+ readonly progress: number;
+ readonly state: string;
+ cancel(): Promise;
+ install(): Promise;
+}
+
+declare var AddonInstall: {
+ prototype: AddonInstall;
+ new (): AddonInstall;
+ isInstance: IsInstance;
+};
+
+interface AddonManager extends EventTarget {
+ createInstall(options?: addonInstallOptions): Promise;
+ getAddonByID(id: string): Promise;
+ sendAbuseReport(addonId: string, data: Record, options?: sendAbuseReportOptions): Promise;
+}
+
+declare var AddonManager: {
+ prototype: AddonManager;
+ new (): AddonManager;
+ isInstance: IsInstance;
+};
+
+interface AnalyserNode extends AudioNode, AudioNodePassThrough {
+ fftSize: number;
+ readonly frequencyBinCount: number;
+ maxDecibels: number;
+ minDecibels: number;
+ smoothingTimeConstant: number;
+ getByteFrequencyData(array: Uint8Array): void;
+ getByteTimeDomainData(array: Uint8Array): void;
+ getFloatFrequencyData(array: Float32Array): void;
+ getFloatTimeDomainData(array: Float32Array): void;
+}
+
+declare var AnalyserNode: {
+ prototype: AnalyserNode;
+ new (context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
+ isInstance: IsInstance;
+};
+
+interface Animatable {
+ animate(keyframes: any, options?: UnrestrictedDoubleOrKeyframeAnimationOptions): Animation;
+ getAnimations(options?: GetAnimationsOptions): Animation[];
+}
+
+interface AnimationEventMap {
+ cancel: Event;
+ finish: Event;
+ remove: Event;
+}
+
+interface Animation extends EventTarget {
+ currentTime: number | null;
+ effect: AnimationEffect | null;
+ readonly finished: Promise;
+ id: string;
+ readonly isRunningOnCompositor: boolean;
+ oncancel: ((this: Animation, ev: Event) => any) | null;
+ onfinish: ((this: Animation, ev: Event) => any) | null;
+ onremove: ((this: Animation, ev: Event) => any) | null;
+ readonly pending: boolean;
+ readonly playState: AnimationPlayState;
+ playbackRate: number;
+ readonly ready: Promise;
+ readonly replaceState: AnimationReplaceState;
+ startTime: number | null;
+ timeline: AnimationTimeline | null;
+ cancel(): void;
+ commitStyles(): void;
+ finish(): void;
+ pause(): void;
+ persist(): void;
+ play(): void;
+ reverse(): void;
+ updatePlaybackRate(playbackRate: number): void;
+ addEventListener(
+ type: K,
+ listener: (this: Animation, ev: AnimationEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: Animation, ev: AnimationEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var Animation: {
+ prototype: Animation;
+ new (effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
+ isInstance: IsInstance;
+};
+
+interface AnimationEffect {
+ getComputedTiming(): ComputedEffectTiming;
+ getTiming(): EffectTiming;
+ updateTiming(timing?: OptionalEffectTiming): void;
+}
+
+declare var AnimationEffect: {
+ prototype: AnimationEffect;
+ new (): AnimationEffect;
+ isInstance: IsInstance;
+};
+
+interface AnimationEvent extends Event {
+ readonly animationName: string;
+ readonly elapsedTime: number;
+ readonly pseudoElement: string;
+}
+
+declare var AnimationEvent: {
+ prototype: AnimationEvent;
+ new (type: string, eventInitDict?: AnimationEventInit): AnimationEvent;
+ isInstance: IsInstance;
+};
+
+interface AnimationFrameProvider {
+ cancelAnimationFrame(handle: number): void;
+ requestAnimationFrame(callback: FrameRequestCallback): number;
+}
+
+interface AnimationPlaybackEvent extends Event {
+ readonly currentTime: number | null;
+ readonly timelineTime: number | null;
+}
+
+declare var AnimationPlaybackEvent: {
+ prototype: AnimationPlaybackEvent;
+ new (type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
+ isInstance: IsInstance;
+};
+
+interface AnimationTimeline {
+ readonly currentTime: number | null;
+}
+
+declare var AnimationTimeline: {
+ prototype: AnimationTimeline;
+ new (): AnimationTimeline;
+ isInstance: IsInstance;
+};
+
+interface AnonymousContent {
+ readonly root: ShadowRoot;
+}
+
+declare var AnonymousContent: {
+ prototype: AnonymousContent;
+ new (): AnonymousContent;
+ isInstance: IsInstance;
+};
+
+interface Attr extends Node {
+ readonly localName: string;
+ readonly name: string;
+ readonly namespaceURI: string | null;
+ readonly ownerElement: Element | null;
+ readonly prefix: string | null;
+ readonly specified: boolean;
+ value: string;
+}
+
+declare var Attr: {
+ prototype: Attr;
+ new (): Attr;
+ isInstance: IsInstance;
+};
+
+interface AudioBuffer {
+ readonly duration: number;
+ readonly length: number;
+ readonly numberOfChannels: number;
+ readonly sampleRate: number;
+ copyFromChannel(destination: Float32Array, channelNumber: number, startInChannel?: number): void;
+ copyToChannel(source: Float32Array, channelNumber: number, startInChannel?: number): void;
+ getChannelData(channel: number): Float32Array;
+}
+
+declare var AudioBuffer: {
+ prototype: AudioBuffer;
+ new (options: AudioBufferOptions): AudioBuffer;
+ isInstance: IsInstance;
+};
+
+interface AudioBufferSourceNode extends AudioScheduledSourceNode, AudioNodePassThrough {
+ buffer: AudioBuffer | null;
+ readonly detune: AudioParam;
+ loop: boolean;
+ loopEnd: number;
+ loopStart: number;
+ readonly playbackRate: AudioParam;
+ start(when?: number, grainOffset?: number, grainDuration?: number): void;
+ addEventListener(
+ type: K,
+ listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var AudioBufferSourceNode: {
+ prototype: AudioBufferSourceNode;
+ new (context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
+ isInstance: IsInstance;
+};
+
+interface AudioContext extends BaseAudioContext {
+ readonly baseLatency: number;
+ readonly outputLatency: number;
+ close(): Promise;
+ createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
+ createMediaStreamDestination(): MediaStreamAudioDestinationNode;
+ createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
+ createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode;
+ getOutputTimestamp(): AudioTimestamp;
+ suspend(): Promise;
+ addEventListener(
+ type: K,
+ listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var AudioContext: {
+ prototype: AudioContext;
+ new (contextOptions?: AudioContextOptions): AudioContext;
+ isInstance: IsInstance;
+};
+
+interface AudioData {
+ readonly duration: number;
+ readonly format: AudioSampleFormat | null;
+ readonly numberOfChannels: number;
+ readonly numberOfFrames: number;
+ readonly sampleRate: number;
+ readonly timestamp: number;
+ allocationSize(options: AudioDataCopyToOptions): number;
+ clone(): AudioData;
+ close(): void;
+ copyTo(destination: ArrayBufferView | ArrayBuffer, options: AudioDataCopyToOptions): void;
+}
+
+declare var AudioData: {
+ prototype: AudioData;
+ new (init: AudioDataInit): AudioData;
+ isInstance: IsInstance;
+};
+
+interface AudioDecoderEventMap {
+ dequeue: Event;
+}
+
+/** Available only in secure contexts. */
+interface AudioDecoder extends EventTarget {
+ readonly decodeQueueSize: number;
+ ondequeue: ((this: AudioDecoder, ev: Event) => any) | null;
+ readonly state: CodecState;
+ close(): void;
+ configure(config: AudioDecoderConfig): void;
+ decode(chunk: EncodedAudioChunk): void;
+ flush(): Promise;
+ reset(): void;
+ addEventListener(
+ type: K,
+ listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var AudioDecoder: {
+ prototype: AudioDecoder;
+ new (init: AudioDecoderInit): AudioDecoder;
+ isInstance: IsInstance;
+ isConfigSupported(config: AudioDecoderConfig): Promise;
+};
+
+interface AudioDestinationNode extends AudioNode {
+ readonly maxChannelCount: number;
+}
+
+declare var AudioDestinationNode: {
+ prototype: AudioDestinationNode;
+ new (): AudioDestinationNode;
+ isInstance: IsInstance;
+};
+
+interface AudioEncoderEventMap {
+ dequeue: Event;
+}
+
+/** Available only in secure contexts. */
+interface AudioEncoder extends EventTarget {
+ readonly encodeQueueSize: number;
+ ondequeue: ((this: AudioEncoder, ev: Event) => any) | null;
+ readonly state: CodecState;
+ close(): void;
+ configure(config: AudioEncoderConfig): void;
+ encode(data: AudioData): void;
+ flush(): Promise;
+ reset(): void;
+ addEventListener(
+ type: K,
+ listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var AudioEncoder: {
+ prototype: AudioEncoder;
+ new (init: AudioEncoderInit): AudioEncoder;
+ isInstance: IsInstance;
+ isConfigSupported(config: AudioEncoderConfig): Promise;
+};
+
+interface AudioListener {
+ setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
+ setPosition(x: number, y: number, z: number): void;
+}
+
+declare var AudioListener: {
+ prototype: AudioListener;
+ new (): AudioListener;
+ isInstance: IsInstance;
+};
+
+interface AudioNode extends EventTarget {
+ channelCount: number;
+ channelCountMode: ChannelCountMode;
+ channelInterpretation: ChannelInterpretation;
+ readonly context: BaseAudioContext;
+ readonly id: number;
+ readonly numberOfInputs: number;
+ readonly numberOfOutputs: number;
+ connect(destination: AudioNode, output?: number, input?: number): AudioNode;
+ connect(destination: AudioParam, output?: number): void;
+ disconnect(): void;
+ disconnect(output: number): void;
+ disconnect(destination: AudioNode): void;
+ disconnect(destination: AudioNode, output: number): void;
+ disconnect(destination: AudioNode, output: number, input: number): void;
+ disconnect(destination: AudioParam): void;
+ disconnect(destination: AudioParam, output: number): void;
+}
+
+declare var AudioNode: {
+ prototype: AudioNode;
+ new (): AudioNode;
+ isInstance: IsInstance;
+};
+
+interface AudioNodePassThrough {
+ passThrough: boolean;
+}
+
+interface AudioParam {
+ readonly defaultValue: number;
+ readonly isTrackSuspended: boolean;
+ readonly maxValue: number;
+ readonly minValue: number;
+ readonly name: string;
+ readonly parentNodeId: number;
+ value: number;
+ cancelScheduledValues(startTime: number): AudioParam;
+ exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
+ linearRampToValueAtTime(value: number, endTime: number): AudioParam;
+ setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
+ setValueAtTime(value: number, startTime: number): AudioParam;
+ setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
+}
+
+declare var AudioParam: {
+ prototype: AudioParam;
+ new (): AudioParam;
+ isInstance: IsInstance;
+};
+
+/** Available only in secure contexts. */
+interface AudioParamMap {
+ forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
+}
+
+declare var AudioParamMap: {
+ prototype: AudioParamMap;
+ new (): AudioParamMap;
+ isInstance: IsInstance;
+};
+
+interface AudioProcessingEvent extends Event {
+ readonly inputBuffer: AudioBuffer;
+ readonly outputBuffer: AudioBuffer;
+ readonly playbackTime: number;
+}
+
+declare var AudioProcessingEvent: {
+ prototype: AudioProcessingEvent;
+ new (): AudioProcessingEvent;
+ isInstance: IsInstance;
+};
+
+interface AudioScheduledSourceNodeEventMap {
+ ended: Event;
+}
+
+interface AudioScheduledSourceNode extends AudioNode {
+ onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
+ start(when?: number): void;
+ stop(when?: number): void;
+ addEventListener(
+ type: K,
+ listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var AudioScheduledSourceNode: {
+ prototype: AudioScheduledSourceNode;
+ new (): AudioScheduledSourceNode;
+ isInstance: IsInstance;
+};
+
+interface AudioTrack {
+ enabled: boolean;
+ readonly id: string;
+ readonly kind: string;
+ readonly label: string;
+ readonly language: string;
+}
+
+declare var AudioTrack: {
+ prototype: AudioTrack;
+ new (): AudioTrack;
+ isInstance: IsInstance;
+};
+
+interface AudioTrackListEventMap {
+ addtrack: Event;
+ change: Event;
+ removetrack: Event;
+}
+
+interface AudioTrackList extends EventTarget {
+ readonly length: number;
+ onaddtrack: ((this: AudioTrackList, ev: Event) => any) | null;
+ onchange: ((this: AudioTrackList, ev: Event) => any) | null;
+ onremovetrack: ((this: AudioTrackList, ev: Event) => any) | null;
+ getTrackById(id: string): AudioTrack | null;
+ addEventListener(
+ type: K,
+ listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+ [index: number]: AudioTrack;
+}
+
+declare var AudioTrackList: {
+ prototype: AudioTrackList;
+ new (): AudioTrackList;
+ isInstance: IsInstance;
+};
+
+/** Available only in secure contexts. */
+interface AudioWorklet extends Worklet {
+ readonly port: MessagePort;
+}
+
+declare var AudioWorklet: {
+ prototype: AudioWorklet;
+ new (): AudioWorklet;
+ isInstance: IsInstance;
+};
+
+interface AudioWorkletNodeEventMap {
+ processorerror: Event;
+}
+
+/** Available only in secure contexts. */
+interface AudioWorkletNode extends AudioNode {
+ onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
+ readonly parameters: AudioParamMap;
+ readonly port: MessagePort;
+ addEventListener(
+ type: K,
+ listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var AudioWorkletNode: {
+ prototype: AudioWorkletNode;
+ new (context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
+ isInstance: IsInstance;
+};
+
+/** Available only in secure contexts. */
+interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
+ readonly authenticatorData: ArrayBuffer;
+ readonly signature: ArrayBuffer;
+ readonly userHandle: ArrayBuffer | null;
+}
+
+declare var AuthenticatorAssertionResponse: {
+ prototype: AuthenticatorAssertionResponse;
+ new (): AuthenticatorAssertionResponse;
+ isInstance: IsInstance;
+};
+
+/** Available only in secure contexts. */
+interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
+ readonly attestationObject: ArrayBuffer;
+ getAuthenticatorData(): ArrayBuffer;
+ getPublicKey(): ArrayBuffer | null;
+ getPublicKeyAlgorithm(): COSEAlgorithmIdentifier;
+ getTransports(): string[];
+}
+
+declare var AuthenticatorAttestationResponse: {
+ prototype: AuthenticatorAttestationResponse;
+ new (): AuthenticatorAttestationResponse;
+ isInstance: IsInstance;
+};
+
+/** Available only in secure contexts. */
+interface AuthenticatorResponse {
+ readonly clientDataJSON: ArrayBuffer;
+}
+
+declare var AuthenticatorResponse: {
+ prototype: AuthenticatorResponse;
+ new (): AuthenticatorResponse;
+ isInstance: IsInstance;
+};
+
+interface BarProp {
+ visible: boolean;
+}
+
+declare var BarProp: {
+ prototype: BarProp;
+ new (): BarProp;
+ isInstance: IsInstance;
+};
+
+interface BaseAudioContextEventMap {
+ statechange: Event;
+}
+
+interface BaseAudioContext extends EventTarget {
+ /** Available only in secure contexts. */
+ readonly audioWorklet: AudioWorklet;
+ readonly currentTime: number;
+ readonly destination: AudioDestinationNode;
+ readonly listener: AudioListener;
+ onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
+ readonly sampleRate: number;
+ readonly state: AudioContextState;
+ createAnalyser(): AnalyserNode;
+ createBiquadFilter(): BiquadFilterNode;
+ createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
+ createBufferSource(): AudioBufferSourceNode;
+ createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
+ createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
+ createConstantSource(): ConstantSourceNode;
+ createConvolver(): ConvolverNode;
+ createDelay(maxDelayTime?: number): DelayNode;
+ createDynamicsCompressor(): DynamicsCompressorNode;
+ createGain(): GainNode;
+ createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
+ createOscillator(): OscillatorNode;
+ createPanner(): PannerNode;
+ createPeriodicWave(
+ real: number[] | Float32Array,
+ imag: number[] | Float32Array,
+ constraints?: PeriodicWaveConstraints
+ ): PeriodicWave;
+ createScriptProcessor(
+ bufferSize?: number,
+ numberOfInputChannels?: number,
+ numberOfOutputChannels?: number
+ ): ScriptProcessorNode;
+ createStereoPanner(): StereoPannerNode;
+ createWaveShaper(): WaveShaperNode;
+ decodeAudioData(
+ audioData: ArrayBuffer,
+ successCallback?: DecodeSuccessCallback,
+ errorCallback?: DecodeErrorCallback
+ ): Promise;
+ resume(): Promise;
+ addEventListener(
+ type: K,
+ listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var BaseAudioContext: {
+ prototype: BaseAudioContext;
+ new (): BaseAudioContext;
+ isInstance: IsInstance;
+};
+
+interface BatteryManagerEventMap {
+ chargingchange: Event;
+ chargingtimechange: Event;
+ dischargingtimechange: Event;
+ levelchange: Event;
+}
+
+interface BatteryManager extends EventTarget {
+ readonly charging: boolean;
+ readonly chargingTime: number;
+ readonly dischargingTime: number;
+ readonly level: number;
+ onchargingchange: ((this: BatteryManager, ev: Event) => any) | null;
+ onchargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
+ ondischargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
+ onlevelchange: ((this: BatteryManager, ev: Event) => any) | null;
+ addEventListener(
+ type: K,
+ listener: (this: BatteryManager, ev: BatteryManagerEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: BatteryManager, ev: BatteryManagerEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var BatteryManager: {
+ prototype: BatteryManager;
+ new (): BatteryManager;
+ isInstance: IsInstance;
+};
+
+// @ts-ignore
+interface BeforeUnloadEvent extends Event {
+ returnValue: string;
+}
+
+declare var BeforeUnloadEvent: {
+ prototype: BeforeUnloadEvent;
+ new (): BeforeUnloadEvent;
+ isInstance: IsInstance;
+};
+
+interface BiquadFilterNode extends AudioNode, AudioNodePassThrough {
+ readonly Q: AudioParam;
+ readonly detune: AudioParam;
+ readonly frequency: AudioParam;
+ readonly gain: AudioParam;
+ type: BiquadFilterType;
+ getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
+}
+
+declare var BiquadFilterNode: {
+ prototype: BiquadFilterNode;
+ new (context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
+ isInstance: IsInstance;
+};
+
+interface Blob {
+ readonly blobImplType: string;
+ readonly size: number;
+ readonly type: string;
+ arrayBuffer(): Promise;
+ bytes(): Promise;
+ slice(start?: number, end?: number, contentType?: string): Blob;
+ stream(): ReadableStream;
+ text(): Promise;
+}
+
+declare var Blob: {
+ prototype: Blob;
+ new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+ isInstance: IsInstance;
+};
+
+interface BlobEvent extends Event {
+ readonly data: Blob;
+}
+
+declare var BlobEvent: {
+ prototype: BlobEvent;
+ new (type: string, eventInitDict: BlobEventInit): BlobEvent;
+ isInstance: IsInstance;
+};
+
+interface Body {
+ readonly bodyUsed: boolean;
+ arrayBuffer(): Promise;
+ blob(): Promise;
+ bytes(): Promise;
+ formData(): Promise;
+ json(): Promise;
+ text(): Promise;
+}
+
+interface BroadcastChannelEventMap {
+ message: Event;
+ messageerror: Event;
+}
+
+interface BroadcastChannel extends EventTarget {
+ readonly name: string;
+ onmessage: ((this: BroadcastChannel, ev: Event) => any) | null;
+ onmessageerror: ((this: BroadcastChannel, ev: Event) => any) | null;
+ close(): void;
+ postMessage(message: any): void;
+ addEventListener(
+ type: K,
+ listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var BroadcastChannel: {
+ prototype: BroadcastChannel;
+ new (channel: string): BroadcastChannel;
+ isInstance: IsInstance;
+ unpartitionedTestingChannel(channel: string): BroadcastChannel;
+};
+
+interface BrowsingContext extends LoadContextMixin {
+ allowJavascript: boolean;
+ readonly ancestorsAreCurrent: boolean;
+ authorStyleDisabledDefault: boolean;
+ browserId: number;
+ readonly childOffset: number;
+ readonly childSessionHistory: ChildSHistory | null;
+ readonly children: BrowsingContext[];
+ readonly createdDynamically: boolean;
+ readonly currentWindowContext: WindowContext | null;
+ customPlatform: string;
+ customUserAgent: string;
+ defaultLoadFlags: number;
+ displayMode: DisplayMode;
+ readonly docShell: nsIDocShell | null;
+ readonly embedderElement: Element | null;
+ readonly embedderElementType: string;
+ forceDesktopViewport: boolean;
+ forceOffline: boolean;
+ forcedColorsOverride: ForcedColorsOverride;
+ fullZoom: number;
+ readonly group: BrowsingContextGroup;
+ hasSiblings: boolean;
+ readonly historyID: any;
+ readonly id: number;
+ inRDMPane: boolean;
+ readonly isActive: boolean;
+ isAppTab: boolean;
+ readonly isDiscarded: boolean;
+ readonly isInBFCache: boolean;
+ mediumOverride: string;
+ readonly name: string;
+ readonly opener: BrowsingContext | null;
+ overrideDPPX: number;
+ readonly parent: BrowsingContext | null;
+ readonly parentWindowContext: WindowContext | null;
+ prefersColorSchemeOverride: PrefersColorSchemeOverride;
+ sandboxFlags: number;
+ serviceWorkersTestingEnabled: boolean;
+ suspendMediaWhenInactive: boolean;
+ readonly targetTopLevelLinkClicksToBlank: boolean;
+ textZoom: number;
+ readonly top: BrowsingContext;
+ readonly topWindowContext: WindowContext | null;
+ readonly touchEventsOverride: TouchEventsOverride;
+ useGlobalHistory: boolean;
+ watchedByDevTools: boolean;
+ readonly window: WindowProxy | null;
+ getAllBrowsingContextsInSubtree(): BrowsingContext[];
+ resetNavigationRateLimit(): void;
+ setRDMPaneMaxTouchPoints(maxTouchPoints: number): void;
+ setRDMPaneOrientation(type: OrientationType, rotationAngle: number): void;
+}
+
+declare var BrowsingContext: {
+ prototype: BrowsingContext;
+ new (): BrowsingContext;
+ isInstance: IsInstance;
+ get(aId: number): BrowsingContext | null;
+ getCurrentTopByBrowserId(aId: number): BrowsingContext | null;
+ getFromWindow(window: WindowProxy): BrowsingContext | null;
+};
+
+interface BrowsingContextGroup {
+ readonly id: number;
+ getToplevels(): BrowsingContext[];
+}
+
+declare var BrowsingContextGroup: {
+ prototype: BrowsingContextGroup;
+ new (): BrowsingContextGroup;
+ isInstance: IsInstance;
+};
+
+interface BufferSource {}
+
+interface ByteLengthQueuingStrategy {
+ readonly highWaterMark: number;
+ readonly size: Function;
+}
+
+declare var ByteLengthQueuingStrategy: {
+ prototype: ByteLengthQueuingStrategy;
+ new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
+ isInstance: IsInstance;
+};
+
+interface CDATASection extends Text {}
+
+declare var CDATASection: {
+ prototype: CDATASection;
+ new (): CDATASection;
+ isInstance: IsInstance;
+};
+
+interface CSPViolationReportBody extends ReportBody {
+ readonly blockedURL: string | null;
+ readonly columnNumber: number | null;
+ readonly disposition: SecurityPolicyViolationEventDisposition;
+ readonly documentURL: string;
+ readonly effectiveDirective: string;
+ readonly lineNumber: number | null;
+ readonly originalPolicy: string;
+ readonly referrer: string | null;
+ readonly sample: string | null;
+ readonly sourceFile: string | null;
+ readonly statusCode: number;
+ toJSON(): any;
+}
+
+declare var CSPViolationReportBody: {
+ prototype: CSPViolationReportBody;
+ new (): CSPViolationReportBody;
+ isInstance: IsInstance;
+};
+
+interface CSSAnimation extends Animation {
+ readonly animationName: string;
+ addEventListener(
+ type: K,
+ listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var CSSAnimation: {
+ prototype: CSSAnimation;
+ new (): CSSAnimation;
+ isInstance: IsInstance;
+};
+
+interface CSSConditionRule extends CSSGroupingRule {
+ readonly conditionText: string;
+}
+
+declare var CSSConditionRule: {
+ prototype: CSSConditionRule;
+ new (): CSSConditionRule;
+ isInstance: IsInstance;
+};
+
+interface CSSContainerRule extends CSSConditionRule {
+ readonly containerName: string;
+ readonly containerQuery: string;
+ queryContainerFor(element: Element): Element | null;
+}
+
+declare var CSSContainerRule: {
+ prototype: CSSContainerRule;
+ new (): CSSContainerRule;
+ isInstance: IsInstance;
+};
+
+interface CSSCounterStyleRule extends CSSRule {
+ additiveSymbols: string;
+ fallback: string;
+ name: string;
+ negative: string;
+ pad: string;
+ prefix: string;
+ range: string;
+ speakAs: string;
+ suffix: string;
+ symbols: string;
+ system: string;
+}
+
+declare var CSSCounterStyleRule: {
+ prototype: CSSCounterStyleRule;
+ new (): CSSCounterStyleRule;
+ isInstance: IsInstance;
+};
+
+interface CSSCustomPropertyRegisteredEvent extends Event {
+ readonly propertyDefinition: InspectorCSSPropertyDefinition;
+}
+
+declare var CSSCustomPropertyRegisteredEvent: {
+ prototype: CSSCustomPropertyRegisteredEvent;
+ new (type: string, eventInitDict?: CSSCustomPropertyRegisteredEventInit): CSSCustomPropertyRegisteredEvent;
+ isInstance: IsInstance;
+};
+
+interface CSSFontFaceRule extends CSSRule {
+ readonly style: CSSStyleDeclaration;
+}
+
+declare var CSSFontFaceRule: {
+ prototype: CSSFontFaceRule;
+ new (): CSSFontFaceRule;
+ isInstance: IsInstance;
+};
+
+interface CSSFontFeatureValuesRule extends CSSRule {
+ fontFamily: string;
+ valueText: string;
+}
+
+declare var CSSFontFeatureValuesRule: {
+ prototype: CSSFontFeatureValuesRule;
+ new (): CSSFontFeatureValuesRule;
+ isInstance: IsInstance;
+};
+
+interface CSSFontPaletteValuesRule extends CSSRule {
+ readonly basePalette: string;
+ readonly fontFamily: string;
+ readonly name: string;
+ readonly overrideColors: string;
+}
+
+declare var CSSFontPaletteValuesRule: {
+ prototype: CSSFontPaletteValuesRule;
+ new (): CSSFontPaletteValuesRule;
+ isInstance: IsInstance;
+};
+
+interface CSSGroupingRule extends CSSRule {
+ readonly cssRules: CSSRuleList;
+ deleteRule(index: number): void;
+ insertRule(rule: string, index?: number): number;
+}
+
+declare var CSSGroupingRule: {
+ prototype: CSSGroupingRule;
+ new (): CSSGroupingRule;
+ isInstance: IsInstance;
+};
+
+interface CSSImportRule extends CSSRule {
+ readonly href: string;
+ readonly layerName: string | null;
+ readonly media: MediaList | null;
+ readonly styleSheet: CSSStyleSheet | null;
+ readonly supportsText: string | null;
+}
+
+declare var CSSImportRule: {
+ prototype: CSSImportRule;
+ new (): CSSImportRule;
+ isInstance: IsInstance;
+};
+
+interface CSSKeyframeRule extends CSSRule {
+ keyText: string;
+ readonly style: CSSStyleDeclaration;
+}
+
+declare var CSSKeyframeRule: {
+ prototype: CSSKeyframeRule;
+ new (): CSSKeyframeRule;
+ isInstance: IsInstance;
+};
+
+interface CSSKeyframesRule extends CSSRule {
+ readonly cssRules: CSSRuleList;
+ readonly length: number;
+ name: string;
+ appendRule(rule: string): void;
+ deleteRule(select: string): void;
+ findRule(select: string): CSSKeyframeRule | null;
+ [index: number]: CSSKeyframeRule;
+}
+
+declare var CSSKeyframesRule: {
+ prototype: CSSKeyframesRule;
+ new (): CSSKeyframesRule;
+ isInstance: IsInstance;
+};
+
+interface CSSLayerBlockRule extends CSSGroupingRule {
+ readonly name: string;
+}
+
+declare var CSSLayerBlockRule: {
+ prototype: CSSLayerBlockRule;
+ new (): CSSLayerBlockRule;
+ isInstance: IsInstance;
+};
+
+interface CSSLayerStatementRule extends CSSRule {
+ readonly nameList: string[];
+}
+
+declare var CSSLayerStatementRule: {
+ prototype: CSSLayerStatementRule;
+ new (): CSSLayerStatementRule;
+ isInstance: IsInstance;
+};
+
+interface CSSMarginRule extends CSSRule {
+ readonly name: string;
+ readonly style: CSSStyleDeclaration;
+}
+
+declare var CSSMarginRule: {
+ prototype: CSSMarginRule;
+ new (): CSSMarginRule;
+ isInstance: IsInstance;
+};
+
+interface CSSMediaRule extends CSSConditionRule {
+ readonly media: MediaList;
+}
+
+declare var CSSMediaRule: {
+ prototype: CSSMediaRule;
+ new (): CSSMediaRule;
+ isInstance: IsInstance;
+};
+
+interface CSSMozDocumentRule extends CSSConditionRule {}
+
+declare var CSSMozDocumentRule: {
+ prototype: CSSMozDocumentRule;
+ new (): CSSMozDocumentRule;
+ isInstance: IsInstance;
+};
+
+interface CSSNamespaceRule extends CSSRule {
+ readonly namespaceURI: string;
+ readonly prefix: string;
+}
+
+declare var CSSNamespaceRule: {
+ prototype: CSSNamespaceRule;
+ new (): CSSNamespaceRule;
+ isInstance: IsInstance;
+};
+
+interface CSSNestedDeclarations extends CSSRule {
+ readonly style: CSSStyleDeclaration;
+}
+
+declare var CSSNestedDeclarations: {
+ prototype: CSSNestedDeclarations;
+ new (): CSSNestedDeclarations;
+ isInstance: IsInstance;
+};
+
+interface CSSPageDescriptors {}
+
+interface CSSPageRule extends CSSGroupingRule {
+ selectorText: string;
+ readonly style: CSSPageDescriptors;
+}
+
+declare var CSSPageRule: {
+ prototype: CSSPageRule;
+ new (): CSSPageRule;
+ isInstance: IsInstance;
+};
+
+interface CSSPositionTryDescriptors {}
+
+interface CSSPositionTryRule extends CSSRule {
+ readonly name: string;
+ readonly style: CSSPositionTryDescriptors;
+}
+
+declare var CSSPositionTryRule: {
+ prototype: CSSPositionTryRule;
+ new (): CSSPositionTryRule;
+ isInstance: IsInstance;
+};
+
+interface CSSPropertyRule extends CSSRule {
+ readonly inherits: boolean;
+ readonly initialValue: string | null;
+ readonly name: string;
+ readonly syntax: string;
+}
+
+declare var CSSPropertyRule: {
+ prototype: CSSPropertyRule;
+ new (): CSSPropertyRule;
+ isInstance: IsInstance;
+};
+
+interface CSSPseudoElement {
+ readonly element: Element;
+ readonly type: string;
+}
+
+declare var CSSPseudoElement: {
+ prototype: CSSPseudoElement;
+ new (): CSSPseudoElement;
+ isInstance: IsInstance;
+};
+
+interface CSSRule {
+ cssText: string;
+ readonly parentRule: CSSRule | null;
+ readonly parentStyleSheet: CSSStyleSheet | null;
+ readonly type: number;
+ readonly STYLE_RULE: 1;
+ readonly CHARSET_RULE: 2;
+ readonly IMPORT_RULE: 3;
+ readonly MEDIA_RULE: 4;
+ readonly FONT_FACE_RULE: 5;
+ readonly PAGE_RULE: 6;
+ readonly NAMESPACE_RULE: 10;
+ readonly KEYFRAMES_RULE: 7;
+ readonly KEYFRAME_RULE: 8;
+ readonly COUNTER_STYLE_RULE: 11;
+ readonly SUPPORTS_RULE: 12;
+ readonly DOCUMENT_RULE: 13;
+ readonly FONT_FEATURE_VALUES_RULE: 14;
+}
+
+declare var CSSRule: {
+ prototype: CSSRule;
+ new (): CSSRule;
+ readonly STYLE_RULE: 1;
+ readonly CHARSET_RULE: 2;
+ readonly IMPORT_RULE: 3;
+ readonly MEDIA_RULE: 4;
+ readonly FONT_FACE_RULE: 5;
+ readonly PAGE_RULE: 6;
+ readonly NAMESPACE_RULE: 10;
+ readonly KEYFRAMES_RULE: 7;
+ readonly KEYFRAME_RULE: 8;
+ readonly COUNTER_STYLE_RULE: 11;
+ readonly SUPPORTS_RULE: 12;
+ readonly DOCUMENT_RULE: 13;
+ readonly FONT_FEATURE_VALUES_RULE: 14;
+ isInstance: IsInstance;
+};
+
+interface CSSRuleList {
+ readonly length: number;
+ item(index: number): CSSRule | null;
+ [index: number]: CSSRule;
+}
+
+declare var CSSRuleList: {
+ prototype: CSSRuleList;
+ new (): CSSRuleList;
+ isInstance: IsInstance;
+};
+
+interface CSSScopeRule extends CSSGroupingRule {
+ readonly end: string | null;
+ readonly start: string | null;
+}
+
+declare var CSSScopeRule: {
+ prototype: CSSScopeRule;
+ new (): CSSScopeRule;
+ isInstance: IsInstance;
+};
+
+interface CSSStartingStyleRule extends CSSGroupingRule {}
+
+declare var CSSStartingStyleRule: {
+ prototype: CSSStartingStyleRule;
+ new (): CSSStartingStyleRule;
+ isInstance: IsInstance;
+};
+
+interface CSSStyleDeclaration {
+ cssText: string;
+ readonly length: number;
+ readonly parentRule: CSSRule | null;
+ readonly usedFontSize: number;
+ getCSSImageURLs(property: string): string[];
+ getPropertyPriority(property: string): string;
+ getPropertyValue(property: string): string;
+ item(index: number): string;
+ removeProperty(property: string): string;
+ setProperty(property: string, value: string | null, priority?: string): void;
+ [index: number]: string;
+}
+
+declare var CSSStyleDeclaration: {
+ prototype: CSSStyleDeclaration;
+ new (): CSSStyleDeclaration;
+ isInstance: IsInstance;
+};
+
+interface CSSStyleRule extends CSSGroupingRule {
+ readonly selectorCount: number;
+ selectorText: string;
+ readonly style: CSSStyleDeclaration;
+ getSelectorWarnings(): SelectorWarning[];
+ selectorMatchesElement(selectorIndex: number, element: Element, pseudo?: string, includeVisitedStyle?: boolean): boolean;
+ selectorSpecificityAt(index: number, desugared?: boolean): number;
+ selectorTextAt(index: number, desugared?: boolean): string;
+}
+
+declare var CSSStyleRule: {
+ prototype: CSSStyleRule;
+ new (): CSSStyleRule;
+ isInstance: IsInstance;
+};
+
+interface CSSStyleSheet extends StyleSheet {
+ readonly cssRules: CSSRuleList;
+ readonly ownerRule: CSSRule | null;
+ readonly parsingMode: CSSStyleSheetParsingMode;
+ readonly rules: CSSRuleList;
+ addRule(selector?: string, style?: string, index?: number): number;
+ deleteRule(index: number): void;
+ insertRule(rule: string, index?: number): number;
+ removeRule(index?: number): void;
+ replace(text: string): Promise;
+ replaceSync(text: string): void;
+}
+
+declare var CSSStyleSheet: {
+ prototype: CSSStyleSheet;
+ new (options?: CSSStyleSheetInit): CSSStyleSheet;
+ isInstance: IsInstance;
+};
+
+interface CSSSupportsRule extends CSSConditionRule {}
+
+declare var CSSSupportsRule: {
+ prototype: CSSSupportsRule;
+ new (): CSSSupportsRule;
+ isInstance: IsInstance;
+};
+
+interface CSSTransition extends Animation {
+ readonly transitionProperty: string;
+ addEventListener(
+ type: K,
+ listener: (this: CSSTransition, ev: AnimationEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: CSSTransition, ev: AnimationEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var CSSTransition: {
+ prototype: CSSTransition;
+ new (): CSSTransition;
+ isInstance: IsInstance;
+};
+
+interface Cache {
+ add(request: RequestInfo | URL): Promise;
+ addAll(requests: RequestInfo[]): Promise;
+ delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise;
+ keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise;
+ match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise;
+ matchAll(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise;
+ put(request: RequestInfo | URL, response: Response): Promise;
+}
+
+declare var Cache: {
+ prototype: Cache;
+ new (): Cache;
+ isInstance: IsInstance;
+};
+
+interface CacheStorage {
+ delete(cacheName: string): Promise;
+ has(cacheName: string): Promise;
+ keys(): Promise;
+ match(request: RequestInfo | URL, options?: MultiCacheQueryOptions): Promise;
+ open(cacheName: string): Promise;
+}
+
+declare var CacheStorage: {
+ prototype: CacheStorage;
+ new (namespace: CacheStorageNamespace, principal: Principal): CacheStorage;
+ isInstance: IsInstance;
+};
+
+interface CallbackDebuggerNotification extends DebuggerNotification {
+ readonly phase: CallbackDebuggerNotificationPhase;
+}
+
+declare var CallbackDebuggerNotification: {
+ prototype: CallbackDebuggerNotification;
+ new (): CallbackDebuggerNotification;
+ isInstance: IsInstance;
+};
+
+interface CanonicalBrowsingContext extends BrowsingContext {
+ readonly activeSessionHistoryEntry: nsISHEntry | null;
+ readonly canOpenModalPicker: boolean;
+ crossGroupOpener: CanonicalBrowsingContext | null;
+ readonly currentRemoteType: string | null;
+ readonly currentURI: URI | null;
+ readonly currentWindowGlobal: WindowGlobalParent | null;
+ readonly embedderWindowGlobal: WindowGlobalParent | null;
+ forceAppWindowActive: boolean;
+ isActive: boolean;
+ readonly isReplaced: boolean;
+ readonly isUnderHiddenEmbedderElement: boolean;
+ readonly mediaController: MediaController | null;
+ readonly mostRecentLoadingSessionHistoryEntry: nsISHEntry | null;
+ readonly secureBrowserUI: nsISecureBrowserUI | null;
+ readonly sessionHistory: nsISHistory | null;
+ targetTopLevelLinkClicksToBlank: boolean;
+ readonly topChromeWindow: WindowProxy | null;
+ touchEventsOverride: TouchEventsOverride;
+ readonly webProgress: nsIWebProgress | null;
+ clearRestoreState(): void;
+ fixupAndLoadURIString(aURI: string, aOptions?: LoadURIOptions): void;
+ getWindowGlobals(): WindowGlobalParent[];
+ goBack(aCancelContentJSEpoch?: number, aRequireUserInteraction?: boolean, aUserActivation?: boolean): void;
+ goForward(aCancelContentJSEpoch?: number, aRequireUserInteraction?: boolean, aUserActivation?: boolean): void;
+ goToIndex(aIndex: number, aCancelContentJSEpoch?: number, aUserActivation?: boolean): void;
+ loadURI(aURI: URI, aOptions?: LoadURIOptions): void;
+ notifyMediaMutedChanged(muted: boolean): void;
+ notifyStartDelayedAutoplayMedia(): void;
+ print(aPrintSettings: nsIPrintSettings): Promise;
+ reload(aReloadFlags: number): void;
+ resetScalingZoom(): void;
+ startApzAutoscroll(aAnchorX: number, aAnchorY: number, aScrollId: number, aPresShellId: number): boolean;
+ stop(aStopFlags: number): void;
+ stopApzAutoscroll(aScrollId: number, aPresShellId: number): void;
+}
+
+declare var CanonicalBrowsingContext: {
+ prototype: CanonicalBrowsingContext;
+ new (): CanonicalBrowsingContext;
+ isInstance: IsInstance;
+ countSiteOrigins(roots: BrowsingContext[]): number;
+};
+
+interface CanvasCaptureMediaStream extends MediaStream {
+ readonly canvas: HTMLCanvasElement;
+ requestFrame(): void;
+ addEventListener(
+ type: K,
+ listener: (this: CanvasCaptureMediaStream, ev: MediaStreamEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: CanvasCaptureMediaStream, ev: MediaStreamEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var CanvasCaptureMediaStream: {
+ prototype: CanvasCaptureMediaStream;
+ new (): CanvasCaptureMediaStream;
+ isInstance: IsInstance;
+};
+
+interface CanvasCompositing {
+ globalAlpha: number;
+ globalCompositeOperation: string;
+}
+
+interface CanvasDrawImage {
+ contextProperties: CanvasContextProperties;
+ drawImage(image: CanvasImageSource, dx: number, dy: number): void;
+ drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
+ drawImage(
+ image: CanvasImageSource,
+ sx: number,
+ sy: number,
+ sw: number,
+ sh: number,
+ dx: number,
+ dy: number,
+ dw: number,
+ dh: number
+ ): void;
+}
+
+interface CanvasDrawPath {
+ beginPath(): void;
+ clip(winding?: CanvasWindingRule): void;
+ clip(path: Path2D, winding?: CanvasWindingRule): void;
+ fill(winding?: CanvasWindingRule): void;
+ fill(path: Path2D, winding?: CanvasWindingRule): void;
+ isPointInPath(x: number, y: number, winding?: CanvasWindingRule): boolean;
+ isPointInPath(path: Path2D, x: number, y: number, winding?: CanvasWindingRule): boolean;
+ isPointInStroke(x: number, y: number): boolean;
+ isPointInStroke(path: Path2D, x: number, y: number): boolean;
+ stroke(): void;
+ stroke(path: Path2D): void;
+}
+
+interface CanvasFillStrokeStyles {
+ fillStyle: string | CanvasGradient | CanvasPattern;
+ strokeStyle: string | CanvasGradient | CanvasPattern;
+ createConicGradient(angle: number, cx: number, cy: number): CanvasGradient;
+ createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
+ createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
+ createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
+}
+
+interface CanvasFilters {
+ filter: string;
+}
+
+interface CanvasGradient {
+ addColorStop(offset: number, color: string): void;
+}
+
+declare var CanvasGradient: {
+ prototype: CanvasGradient;
+ new (): CanvasGradient;
+ isInstance: IsInstance;
+};
+
+interface CanvasImageData {
+ createImageData(sw: number, sh: number): ImageData;
+ createImageData(imagedata: ImageData): ImageData;
+ getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
+ putImageData(imagedata: ImageData, dx: number, dy: number): void;
+ putImageData(
+ imagedata: ImageData,
+ dx: number,
+ dy: number,
+ dirtyX: number,
+ dirtyY: number,
+ dirtyWidth: number,
+ dirtyHeight: number
+ ): void;
+}
+
+interface CanvasImageSmoothing {
+ imageSmoothingEnabled: boolean;
+}
+
+interface CanvasPathDrawingStyles {
+ lineCap: CanvasLineCap;
+ lineDashOffset: number;
+ lineJoin: CanvasLineJoin;
+ lineWidth: number;
+ miterLimit: number;
+ getLineDash(): number[];
+ setLineDash(segments: number[]): void;
+}
+
+interface CanvasPathMethods {
+ arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+ arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+ bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+ closePath(): void;
+ ellipse(
+ x: number,
+ y: number,
+ radiusX: number,
+ radiusY: number,
+ rotation: number,
+ startAngle: number,
+ endAngle: number,
+ anticlockwise?: boolean
+ ): void;
+ lineTo(x: number, y: number): void;
+ moveTo(x: number, y: number): void;
+ quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+ rect(x: number, y: number, w: number, h: number): void;
+ roundRect(x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | (number | DOMPointInit)[]): void;
+}
+
+interface CanvasPattern {
+ setTransform(matrix?: DOMMatrix2DInit): void;
+}
+
+declare var CanvasPattern: {
+ prototype: CanvasPattern;
+ new (): CanvasPattern;
+ isInstance: IsInstance;
+};
+
+interface CanvasRect {
+ clearRect(x: number, y: number, w: number, h: number): void;
+ fillRect(x: number, y: number, w: number, h: number): void;
+ strokeRect(x: number, y: number, w: number, h: number): void;
+}
+
+interface CanvasRenderingContext2D
+ extends CanvasCompositing,
+ CanvasDrawImage,
+ CanvasDrawPath,
+ CanvasFillStrokeStyles,
+ CanvasFilters,
+ CanvasImageData,
+ CanvasImageSmoothing,
+ CanvasPathDrawingStyles,
+ CanvasPathMethods,
+ CanvasRect,
+ CanvasShadowStyles,
+ CanvasState,
+ CanvasText,
+ CanvasTextDrawingStyles,
+ CanvasTransform,
+ CanvasUserInterface {
+ readonly canvas: HTMLCanvasElement | null;
+ demote(): void;
+ drawWindow(window: Window, x: number, y: number, w: number, h: number, bgColor: string, flags?: number): void;
+ getContextAttributes(): CanvasRenderingContext2DSettings;
+ getDebugInfo(ensureTarget?: boolean): CanvasRenderingContext2DDebugInfo;
+ readonly DRAWWINDOW_DRAW_CARET: 0x01;
+ readonly DRAWWINDOW_DO_NOT_FLUSH: 0x02;
+ readonly DRAWWINDOW_DRAW_VIEW: 0x04;
+ readonly DRAWWINDOW_USE_WIDGET_LAYERS: 0x08;
+ readonly DRAWWINDOW_ASYNC_DECODE_IMAGES: 0x10;
+}
+
+declare var CanvasRenderingContext2D: {
+ prototype: CanvasRenderingContext2D;
+ new (): CanvasRenderingContext2D;
+ readonly DRAWWINDOW_DRAW_CARET: 0x01;
+ readonly DRAWWINDOW_DO_NOT_FLUSH: 0x02;
+ readonly DRAWWINDOW_DRAW_VIEW: 0x04;
+ readonly DRAWWINDOW_USE_WIDGET_LAYERS: 0x08;
+ readonly DRAWWINDOW_ASYNC_DECODE_IMAGES: 0x10;
+ isInstance: IsInstance;
+};
+
+interface CanvasShadowStyles {
+ shadowBlur: number;
+ shadowColor: string;
+ shadowOffsetX: number;
+ shadowOffsetY: number;
+}
+
+interface CanvasState {
+ isContextLost(): boolean;
+ reset(): void;
+ restore(): void;
+ save(): void;
+}
+
+interface CanvasText {
+ fillText(text: string, x: number, y: number, maxWidth?: number): void;
+ measureText(text: string): TextMetrics;
+ strokeText(text: string, x: number, y: number, maxWidth?: number): void;
+}
+
+interface CanvasTextDrawingStyles {
+ direction: CanvasDirection;
+ font: string;
+ fontKerning: CanvasFontKerning;
+ fontStretch: CanvasFontStretch;
+ fontVariantCaps: CanvasFontVariantCaps;
+ letterSpacing: string;
+ textAlign: CanvasTextAlign;
+ textBaseline: CanvasTextBaseline;
+ textRendering: CanvasTextRendering;
+ wordSpacing: string;
+}
+
+interface CanvasTransform {
+ getTransform(): DOMMatrix;
+ resetTransform(): void;
+ rotate(angle: number): void;
+ scale(x: number, y: number): void;
+ setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+ setTransform(transform?: DOMMatrix2DInit): void;
+ transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+ translate(x: number, y: number): void;
+}
+
+interface CanvasUserInterface {
+ drawFocusIfNeeded(element: Element): void;
+}
+
+interface CaretPosition {
+ readonly offset: number;
+ readonly offsetNode: Node | null;
+ getClientRect(): DOMRect | null;
+}
+
+declare var CaretPosition: {
+ prototype: CaretPosition;
+ new (): CaretPosition;
+ isInstance: IsInstance;
+};
+
+interface CaretStateChangedEvent extends Event {
+ readonly boundingClientRect: DOMRectReadOnly | null;
+ readonly caretVisible: boolean;
+ readonly caretVisuallyVisible: boolean;
+ readonly clientX: number;
+ readonly clientY: number;
+ readonly collapsed: boolean;
+ readonly reason: CaretChangedReason;
+ readonly selectedTextContent: string;
+ readonly selectionEditable: boolean;
+ readonly selectionVisible: boolean;
+}
+
+declare var CaretStateChangedEvent: {
+ prototype: CaretStateChangedEvent;
+ new (type: string, eventInit?: CaretStateChangedEventInit): CaretStateChangedEvent;
+ isInstance: IsInstance;
+};
+
+interface ChannelMergerNode extends AudioNode {}
+
+declare var ChannelMergerNode: {
+ prototype: ChannelMergerNode;
+ new (context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
+ isInstance: IsInstance;
+};
+
+interface ChannelSplitterNode extends AudioNode {}
+
+declare var ChannelSplitterNode: {
+ prototype: ChannelSplitterNode;
+ new (context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
+ isInstance: IsInstance;
+};
+
+interface ChannelWrapperEventMap {
+ error: Event;
+ start: Event;
+ stop: Event;
+}
+
+interface ChannelWrapper extends EventTarget {
+ readonly browserElement: nsISupports | null;
+ readonly canModify: boolean;
+ channel: MozChannel | null;
+ contentType: string;
+ readonly documentURI: URI | null;
+ readonly documentURL: string | null;
+ readonly errorString: string | null;
+ readonly finalURI: URI | null;
+ readonly finalURL: string;
+ readonly frameAncestors: MozFrameAncestorInfo[] | null;
+ readonly frameId: number;
+ readonly id: number;
+ readonly isServiceWorkerScript: boolean;
+ readonly loadInfo: LoadInfo | null;
+ readonly method: string;
+ onerror: ((this: ChannelWrapper, ev: Event) => any) | null;
+ onstart: ((this: ChannelWrapper, ev: Event) => any) | null;
+ onstop: ((this: ChannelWrapper, ev: Event) => any) | null;
+ readonly originURI: URI | null;
+ readonly originURL: string | null;
+ readonly parentFrameId: number;
+ readonly proxyInfo: MozProxyInfo | null;
+ readonly remoteAddress: string | null;
+ readonly requestSize: number;
+ readonly responseSize: number;
+ readonly statusCode: number;
+ readonly statusLine: string;
+ readonly suspended: boolean;
+ readonly thirdParty: boolean;
+ readonly type: MozContentPolicyType;
+ readonly urlClassification: MozUrlClassification | null;
+ cancel(result: number, reason?: number): void;
+ errorCheck(): void;
+ getRequestHeader(header: string): string | null;
+ getRequestHeaders(): MozHTTPHeader[];
+ getResponseHeaders(): MozHTTPHeader[];
+ matches(filter?: MozRequestFilter, extension?: WebExtensionPolicy | null, options?: MozRequestMatchOptions): boolean;
+ redirectTo(url: URI): void;
+ registerTraceableChannel(extension: WebExtensionPolicy, remoteTab: RemoteTab | null): void;
+ resume(): void;
+ setRequestHeader(header: string, value: string, merge?: boolean): void;
+ setResponseHeader(header: string, value: string, merge?: boolean): void;
+ suspend(profileMarkerText: string): void;
+ upgradeToSecure(): void;
+ addEventListener(
+ type: K,
+ listener: (this: ChannelWrapper, ev: ChannelWrapperEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: ChannelWrapper, ev: ChannelWrapperEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var ChannelWrapper: {
+ prototype: ChannelWrapper;
+ new (): ChannelWrapper;
+ isInstance: IsInstance;
+ get(channel: MozChannel): ChannelWrapper;
+ getRegisteredChannel(aChannelId: number, extension: WebExtensionPolicy, remoteTab: RemoteTab | null): ChannelWrapper | null;
+};
+
+interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
+ data: string;
+ readonly length: number;
+ appendData(data: string): void;
+ deleteData(offset: number, count: number): void;
+ insertData(offset: number, data: string): void;
+ replaceData(offset: number, count: number, data: string): void;
+ substringData(offset: number, count: number): string;
+}
+
+declare var CharacterData: {
+ prototype: CharacterData;
+ new (): CharacterData;
+ isInstance: IsInstance;
+};
+
+interface CheckerboardReportService {
+ flushActiveReports(): void;
+ getReports(): CheckerboardReport[];
+ isRecordingEnabled(): boolean;
+ setRecordingEnabled(aEnabled: boolean): void;
+}
+
+declare var CheckerboardReportService: {
+ prototype: CheckerboardReportService;
+ new (): CheckerboardReportService;
+ isInstance: IsInstance;
+};
+
+interface ChildNode {
+ after(...nodes: (Node | string)[]): void;
+ before(...nodes: (Node | string)[]): void;
+ remove(): void;
+ replaceWith(...nodes: (Node | string)[]): void;
+}
+
+interface ChildProcessMessageManager extends SyncMessageSender {}
+
+declare var ChildProcessMessageManager: {
+ prototype: ChildProcessMessageManager;
+ new (): ChildProcessMessageManager;
+ isInstance: IsInstance;
+};
+
+interface ChildSHistory {
+ readonly count: number;
+ readonly index: number;
+ readonly legacySHistory: nsISHistory;
+ canGo(aOffset: number, aRequireUserInteraction?: boolean): boolean;
+ go(aOffset: number, aRequireUserInteraction?: boolean, aUserActivation?: boolean): void;
+ reload(aReloadFlags: number): void;
+}
+
+declare var ChildSHistory: {
+ prototype: ChildSHistory;
+ new (): ChildSHistory;
+ isInstance: IsInstance;
+};
+
+interface ChromeMessageBroadcaster extends MessageBroadcaster, FrameScriptLoader {}
+
+declare var ChromeMessageBroadcaster: {
+ prototype: ChromeMessageBroadcaster;
+ new (): ChromeMessageBroadcaster;
+ isInstance: IsInstance;
+};
+
+interface ChromeMessageSender extends MessageSender, FrameScriptLoader {}
+
+declare var ChromeMessageSender: {
+ prototype: ChromeMessageSender;
+ new (): ChromeMessageSender;
+ isInstance: IsInstance;
+};
+
+interface ChromeNodeList extends NodeList {
+ append(aNode: Node): void;
+ remove(aNode: Node): void;
+}
+
+declare var ChromeNodeList: {
+ prototype: ChromeNodeList;
+ new (): ChromeNodeList;
+ isInstance: IsInstance;
+};
+
+interface ChromeWorker extends Worker {
+ addEventListener(
+ type: K,
+ listener: (this: ChromeWorker, ev: WorkerEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: ChromeWorker, ev: WorkerEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var ChromeWorker: {
+ prototype: ChromeWorker;
+ new (scriptURL: string | URL, options?: WorkerOptions): ChromeWorker;
+ isInstance: IsInstance;
+};
+
+/** Available only in secure contexts. */
+interface Clipboard extends EventTarget {
+ read(): Promise;
+ readText(): Promise;
+ write(data: ClipboardItems): Promise;
+ writeText(data: string): Promise;
+}
+
+declare var Clipboard: {
+ prototype: Clipboard;
+ new (): Clipboard;
+ isInstance: IsInstance;
+};
+
+interface ClipboardEvent extends Event {
+ readonly clipboardData: DataTransfer | null;
+}
+
+declare var ClipboardEvent: {
+ prototype: ClipboardEvent;
+ new (type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
+ isInstance: IsInstance;
+};
+
+/** Available only in secure contexts. */
+interface ClipboardItem {
+ readonly presentationStyle: PresentationStyle;
+ readonly types: string[];
+ getType(type: string): Promise;
+}
+
+declare var ClipboardItem: {
+ prototype: ClipboardItem;
+ new (
+ items: Record>,
+ options?: ClipboardItemOptions
+ ): ClipboardItem;
+ isInstance: IsInstance;
+ supports(type: string): boolean;
+};
+
+interface ClonedErrorHolder {}
+
+declare var ClonedErrorHolder: {
+ prototype: ClonedErrorHolder;
+ new (aError: any): ClonedErrorHolder;
+ isInstance: IsInstance;
+};
+
+interface CloseEvent extends Event {
+ readonly code: number;
+ readonly reason: string;
+ readonly wasClean: boolean;
+}
+
+declare var CloseEvent: {
+ prototype: CloseEvent;
+ new (type: string, eventInitDict?: CloseEventInit): CloseEvent;
+ isInstance: IsInstance;
+};
+
+interface CloseWatcherEventMap {
+ cancel: Event;
+ close: Event;
+}
+
+interface CloseWatcher extends EventTarget {
+ oncancel: ((this: CloseWatcher, ev: Event) => any) | null;
+ onclose: ((this: CloseWatcher, ev: Event) => any) | null;
+ close(): void;
+ destroy(): void;
+ requestClose(): void;
+ addEventListener(
+ type: K,
+ listener: (this: CloseWatcher, ev: CloseWatcherEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: CloseWatcher, ev: CloseWatcherEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var CloseWatcher: {
+ prototype: CloseWatcher;
+ new (options?: CloseWatcherOptions): CloseWatcher;
+ isInstance: IsInstance;
+};
+
+interface CommandEvent extends Event {
+ readonly command: string | null;
+}
+
+declare var CommandEvent: {
+ prototype: CommandEvent;
+ new (): CommandEvent;
+ isInstance: IsInstance;
+};
+
+interface Comment extends CharacterData {}
+
+declare var Comment: {
+ prototype: Comment;
+ new (data?: string): Comment;
+ isInstance: IsInstance;
+};
+
+interface CompositionEvent extends UIEvent {
+ readonly data: string | null;
+ readonly locale: string;
+ readonly ranges: TextClause[];
+ initCompositionEvent(
+ typeArg: string,
+ canBubbleArg?: boolean,
+ cancelableArg?: boolean,
+ viewArg?: Window | null,
+ dataArg?: string | null,
+ localeArg?: string
+ ): void;
+}
+
+declare var CompositionEvent: {
+ prototype: CompositionEvent;
+ new (type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
+ isInstance: IsInstance;
+};
+
+interface CompressionStream extends GenericTransformStream {}
+
+declare var CompressionStream: {
+ prototype: CompressionStream;
+ new (format: CompressionFormat): CompressionStream;
+ isInstance: IsInstance;
+};
+
+interface ConsoleInstance {
+ assert(condition?: boolean, ...data: any[]): void;
+ clear(): void;
+ count(label?: string): void;
+ countReset(label?: string): void;
+ debug(...data: any[]): void;
+ dir(...data: any[]): void;
+ dirxml(...data: any[]): void;
+ error(...data: any[]): void;
+ exception(...data: any[]): void;
+ group(...data: any[]): void;
+ groupCollapsed(...data: any[]): void;
+ groupEnd(): void;
+ info(...data: any[]): void;
+ log(...data: any[]): void;
+ profile(...data: any[]): void;
+ profileEnd(...data: any[]): void;
+ reportForServiceWorkerScope(
+ scope: string,
+ message: string,
+ filename: string,
+ lineNumber: number,
+ columnNumber: number,
+ level: ConsoleLevel
+ ): void;
+ shouldLog(level: ConsoleLogLevel): boolean;
+ table(...data: any[]): void;
+ time(label?: string): void;
+ timeEnd(label?: string): void;
+ timeLog(label?: string, ...data: any[]): void;
+ timeStamp(data?: any): void;
+ trace(...data: any[]): void;
+ warn(...data: any[]): void;
+}
+
+declare var ConsoleInstance: {
+ prototype: ConsoleInstance;
+ new (): ConsoleInstance;
+ isInstance: IsInstance;
+};
+
+interface ConstantSourceNode extends AudioScheduledSourceNode {
+ readonly offset: AudioParam;
+ addEventListener(
+ type: K,
+ listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ addEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | AddEventListenerOptions
+ ): void;
+ removeEventListener(
+ type: K,
+ listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any,
+ options?: boolean | EventListenerOptions
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListenerOrEventListenerObject,
+ options?: boolean | EventListenerOptions
+ ): void;
+}
+
+declare var ConstantSourceNode: {
+ prototype: ConstantSourceNode;
+ new (context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
+ isInstance: IsInstance;
+};
+
+interface ContentFrameMessageManager
+ extends EventTarget,
+ MessageListenerManagerMixin,
+ MessageManagerGlobal,
+ MessageSenderMixin,
+ SyncMessageSenderMixin {
+ readonly content: WindowProxy | null;
+ readonly docShell: nsIDocShell | null;
+ readonly tabEventTarget: nsIEventTarget | null;
+}
+
+declare var ContentFrameMessageManager: {
+ prototype: ContentFrameMessageManager;
+ new (): ContentFrameMessageManager;
+ isInstance: IsInstance;
+};
+
+interface ContentProcessMessageManager
+ extends MessageListenerManagerMixin,
+ MessageManagerGlobal,
+ MessageSenderMixin,
+ SyncMessageSenderMixin {
+ readonly initialProcessData: any;
+ readonly sharedData: MozSharedMap | null;
+}
+
+declare var ContentProcessMessageManager: {
+ prototype: ContentProcessMessageManager;
+ new (): ContentProcessMessageManager;
+ isInstance: IsInstance;
+};
+
+interface ContentVisibilityAutoStateChangeEvent extends Event {
+ readonly skipped: boolean;
+}
+
+declare var ContentVisibilityAutoStateChangeEvent: {
+ prototype: ContentVisibilityAutoStateChangeEvent;
+ new (type: string, eventInitDict?: ContentVisibilityAutoStateChangeEventInit): ContentVisibilityAutoStateChangeEvent;
+ isInstance: IsInstance;
+};
+
+interface ConvolverNode extends AudioNode, AudioNodePassThrough {
+ buffer: AudioBuffer | null;
+ normalize: boolean;
+}
+
+declare var ConvolverNode: {
+ prototype: ConvolverNode;
+ new (context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
+ isInstance: IsInstance